1 # -*- coding: utf-8 -*-
3 # Copyright (C) 2008-2024 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
39 from daCore import version
40 lpi = PlatformInfo.PlatformInfo()
42 # ==============================================================================
43 class GenericCaseViewer(object):
45 Gestion des commandes de création d'une vue de cas
48 "_name", "_objname", "_lineSerie", "_switchoff", "_content",
49 "_numobservers", "_object", "_missing",
52 def __init__(self, __name="", __objname="case", __content=None, __object=None):
53 "Initialisation et enregistrement de l'entete"
54 self._name = str(__name)
55 self._objname = str(__objname)
57 self._switchoff = False
58 self._numobservers = 2
59 self._content = __content
60 self._object = __object
61 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# """
63 def _append(self, *args):
64 "Transformation d'une commande individuelle en un enregistrement"
65 raise NotImplementedError()
67 def _extract(self, *args):
68 "Transformation d'enregistrement(s) en commande(s) individuelle(s)"
69 raise NotImplementedError()
71 def _initialize(self, __multilines):
72 "Permet des pré-conversions automatiques simples de commandes ou clés"
74 "Study_name" : "StudyName", # noqa: E203
75 "Study_repertory" : "StudyRepertory", # noqa: E203
76 "MaximumNumberOfSteps" : "MaximumNumberOfIterations", # noqa: E203
77 "EnableMultiProcessing": "EnableWiseParallelism",
78 "FunctionDict" : "ScriptWithSwitch", # noqa: E203
79 "FUNCTIONDICT_FILE" : "SCRIPTWITHSWITCH_FILE", # noqa: E203
81 for k, v in __translation.items():
82 __multilines = __multilines.replace(k, v)
85 def _finalize(self, __upa=None):
86 "Enregistrement du final"
87 __hasNotExecute = True
88 for __l in self._lineSerie:
89 if "%s.execute"%(self._objname,) in __l:
90 __hasNotExecute = False
92 self._lineSerie.append("%s.execute()"%(self._objname,))
93 if __upa is not None and len(__upa) > 0:
94 __upa = __upa.replace("ADD", str(self._objname))
95 self._lineSerie.append(__upa)
97 def _addLine(self, line=""):
98 "Ajoute un enregistrement individuel"
99 self._lineSerie.append(line)
101 def _get_objname(self):
104 def dump(self, __filename=None, __upa=None):
105 "Restitution normalisée des commandes"
106 self._finalize(__upa)
107 __text = "\n".join(self._lineSerie)
109 if __filename is not None:
110 __file = os.path.abspath(__filename)
111 __fid = open(__file, "w")
116 def load(self, __filename=None, __content=None, __object=None):
117 "Chargement normalisé des commandes"
118 if __filename is not None and os.path.exists(__filename):
119 self._content = open(__filename, 'r').read()
120 self._content = self._initialize(self._content)
121 elif __content is not None and type(__content) is str:
122 self._content = self._initialize(__content)
123 elif __object is not None and type(__object) is dict:
124 self._object = copy.deepcopy(__object)
126 pass # use "self._content" from initialization
127 __commands = self._extract(self._content, self._object)
130 class _TUIViewer(GenericCaseViewer):
132 Établissement des commandes d'un cas ADAO TUI (Cas<->TUI)
136 def __init__(self, __name="", __objname="case", __content=None, __object=None):
137 "Initialisation et enregistrement de l'entete"
138 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
139 self._addLine("# -*- coding: utf-8 -*-")
140 self._addLine("#\n# Python script using ADAO TUI\n#")
141 self._addLine("from numpy import array, matrix")
142 self._addLine("from adao import adaoBuilder")
143 self._addLine("%s = adaoBuilder.New('%s')"%(self._objname, self._name))
144 if self._content is not None:
145 for command in self._content:
146 self._append(*command)
148 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
149 "Transformation d'une commande individuelle en un enregistrement"
150 if __command is not None and __keys is not None and __local is not None:
151 if "Concept" in __keys:
152 logging.debug("TUI Order processed: %s"%(__local["Concept"],))
154 if __pre is not None:
155 __text += "%s = "%__pre
156 __text += "%s.%s( "%(self._objname, str(__command))
158 __keys.remove("self")
159 if __command not in ("set", "get") and "Concept" in __keys:
160 __keys.remove("Concept")
162 if k not in __local: continue # noqa: E701
164 if __v is None: continue # noqa: E701
165 if k == "SyncObs" and not __v: continue # noqa: E241,E271,E272,E701
166 if k == "Checked" and not __v: continue # noqa: E241,E271,E272,E701
167 if k == "ColMajor" and not __v: continue # noqa: E241,E271,E272,E701
168 if k == "CrossObs" and not __v: continue # noqa: E241,E271,E272,E701
169 if k == "InputFunctionAsMulti" and not __v: continue # noqa: E241,E271,E272,E701
170 if k == "PerformanceProfile" and __v: continue # noqa: E241,E271,E272,E701
171 if k == "Stored" and not __v: continue # noqa: E241,E271,E272,E701
172 if k == "nextStep" and not __v: continue # noqa: E241,E271,E272,E701
173 if k == "noDetails": continue # noqa: E241,E271,E272,E701
174 if isinstance(__v, Persistence.Persistence):
177 __text = self._missing%__v.__name__ + __text
178 if isinstance(__v, dict):
179 for val in __v.values():
181 __text = self._missing%val.__name__ + __text
182 numpy.set_printoptions(precision=15, threshold=1000000, linewidth=1000 * 15)
183 __text += "%s=%s, "%(k, repr(__v))
184 numpy.set_printoptions(precision=8, threshold=1000, linewidth=75)
185 __text = __text.rstrip(", ")
187 self._addLine(__text)
189 def _extract(self, __multilines="", __object=None):
190 "Transformation d'enregistrement(s) en commande(s) individuelle(s)"
193 __multilines = __multilines.replace("\r\n", "\n")
194 for line in __multilines.split("\n"):
195 if "adaoBuilder.New" in line and "=" in line:
196 self._objname = line.split("=")[0].strip()
198 logging.debug("TUI Extracting commands of '%s' object..."%(self._objname,))
202 if self._objname + ".set" in line:
203 __commands.append( line.replace(self._objname + ".", "", 1) )
204 logging.debug("TUI Extracted command: %s"%(__commands[-1],))
207 class _COMViewer(GenericCaseViewer):
209 Établissement des commandes d'un cas COMM (Eficas Native Format/Cas<-COM)
211 __slots__ = ("_observerIndex", "_objdata")
213 def __init__(self, __name="", __objname="case", __content=None, __object=None):
214 "Initialisation et enregistrement de l'entete"
215 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
216 self._observerIndex = 0
217 self._addLine("# -*- coding: utf-8 -*-")
218 self._addLine("#\n# Python script using ADAO COMM\n#")
219 self._addLine("from numpy import array, matrix")
221 self._addLine("%s = {}"%__objname)
222 if self._content is not None:
223 for command in self._content:
224 self._append(*command)
226 def _extract(self, __multilines=None, __object=None):
227 "Transformation d'enregistrement(s) en commande(s) individuelle(s)"
228 __suppparameters = {}
229 if __multilines is not None:
230 if 'adaoBuilder' in __multilines:
231 raise ValueError("Impossible to load given content as an ADAO COMM one (Hint: it's perhaps not a COMM input, but a TUI one).")
232 if "ASSIMILATION_STUDY" in __multilines:
233 __suppparameters.update({'StudyType': "ASSIMILATION_STUDY"})
234 __multilines = __multilines.replace("ASSIMILATION_STUDY", "dict")
235 elif "OPTIMIZATION_STUDY" in __multilines:
236 __suppparameters.update({'StudyType': "ASSIMILATION_STUDY"})
237 __multilines = __multilines.replace("OPTIMIZATION_STUDY", "dict")
238 elif "REDUCTION_STUDY" in __multilines:
239 __suppparameters.update({'StudyType': "ASSIMILATION_STUDY"})
240 __multilines = __multilines.replace("REDUCTION_STUDY", "dict")
241 elif "CHECKING_STUDY" in __multilines:
242 __suppparameters.update({'StudyType': "CHECKING_STUDY"})
243 __multilines = __multilines.replace("CHECKING_STUDY", "dict")
245 __multilines = __multilines.replace("ASSIMILATION_STUDY", "dict")
247 __multilines = __multilines.replace("_F(", "dict(")
248 __multilines = __multilines.replace(",),);", ",),)")
250 for line in __multilines.split("\n"):
253 __fulllines += line + "\n"
254 __multilines = __fulllines
255 self._objname = "case"
257 exec("self._objdata = " + __multilines)
259 if self._objdata is None or not (type(self._objdata) is dict) or not ('AlgorithmParameters' in self._objdata):
260 raise ValueError("Impossible to load given content as an ADAO COMM one (no dictionnary or no 'AlgorithmParameters' key found).")
261 # ----------------------------------------------------------------------
262 logging.debug("COMM Extracting commands of '%s' object..."%(self._objname,))
264 __UserPostAnalysis = ""
265 for k, r in self._objdata.items():
267 logging.debug("COMM Extracted command: %s:%s"%(k, r))
268 if __command == "StudyName" and len(str(r)) > 0:
269 __commands.append( "set( Concept='Name', String='%s')"%(str(r),) )
270 elif __command == "StudyRepertory":
271 __commands.append( "set( Concept='Directory', String='%s')"%(str(r),) )
272 elif __command == "Debug" and str(r) == "0":
273 __commands.append( "set( Concept='NoDebug' )" )
274 elif __command == "Debug" and str(r) == "1":
275 __commands.append( "set( Concept='Debug' )" )
276 elif __command == "ExecuteInContainer":
277 __suppparameters.update({'ExecuteInContainer': r})
279 elif __command == "UserPostAnalysis" and type(r) is dict:
281 __UserPostAnalysis = r['STRING'].replace("ADD", str(self._objname))
282 __commands.append( "set( Concept='UserPostAnalysis', String=\"\"\"%s\"\"\" )"%(__UserPostAnalysis,) )
283 elif 'SCRIPT_FILE' in r and os.path.exists(r['SCRIPT_FILE']):
284 __UserPostAnalysis = open(r['SCRIPT_FILE'], 'r').read()
285 __commands.append( "set( Concept='UserPostAnalysis', Script='%s' )"%(r['SCRIPT_FILE'],) )
286 elif 'Template' in r and 'ValueTemplate' not in r:
288 if r['Template'] not in Templates.UserPostAnalysisTemplates:
289 raise ValueError("User post-analysis template \"%s\" does not exist."%(r['Template'],))
291 __UserPostAnalysis = Templates.UserPostAnalysisTemplates[r['Template']]
292 __commands.append( "set( Concept='UserPostAnalysis', Template='%s' )"%(r['Template'],) )
293 elif 'Template' in r and 'ValueTemplate' in r:
294 # Le template ayant pu être modifié, donc on ne prend que le ValueTemplate...
295 __UserPostAnalysis = r['ValueTemplate']
296 __commands.append( "set( Concept='UserPostAnalysis', String=\"\"\"%s\"\"\" )"%(__UserPostAnalysis,) )
298 __UserPostAnalysis = ""
300 elif __command == "AlgorithmParameters" and type(r) is dict and 'Algorithm' in r:
301 if 'data' in r and r['Parameters'] == 'Dict':
303 if 'STRING' in __from:
304 __parameters = ", Parameters=%s"%(repr(eval(__from['STRING'])),)
305 elif 'SCRIPT_FILE' in __from: # Pas de test d'existence du fichier pour accepter un fichier relatif
306 __parameters = ", Script='%s'"%(__from['SCRIPT_FILE'],)
307 else: # if 'Parameters' in r and r['Parameters'] == 'Defaults':
308 __Dict = copy.deepcopy(r)
309 __Dict.pop('Algorithm', '')
310 __Dict.pop('Parameters', '')
311 if 'SetSeed' in __Dict:
312 __Dict['SetSeed'] = int(__Dict['SetSeed'])
313 if 'Bounds' in __Dict and type(__Dict['Bounds']) is str:
314 __Dict['Bounds'] = eval(__Dict['Bounds'])
315 if 'BoxBounds' in __Dict and type(__Dict['BoxBounds']) is str:
316 __Dict['BoxBounds'] = eval(__Dict['BoxBounds'])
318 __parameters = ', Parameters=%s'%(repr(__Dict),)
321 __commands.append( "set( Concept='AlgorithmParameters', Algorithm='%s'%s )"%(r['Algorithm'], __parameters) )
323 elif __command == "Observers" and type(r) is dict and 'SELECTION' in r:
324 if type(r['SELECTION']) is str:
325 __selection = (r['SELECTION'],)
327 __selection = tuple(r['SELECTION'])
328 for sk in __selection:
329 __idata = r['%s_data'%sk]
330 if __idata['NodeType'] == 'Template' and 'Template' in __idata:
331 __template = __idata['Template']
332 if 'Info' in __idata:
333 __info = ", Info=\"\"\"%s\"\"\""%(__idata['Info'],)
336 __commands.append( "set( Concept='Observer', Variable='%s', Template=\"\"\"%s\"\"\"%s )"%(sk, __template, __info) )
337 if __idata['NodeType'] == 'String' and 'Value' in __idata:
338 __value = __idata['Value']
339 __commands.append( "set( Concept='Observer', Variable='%s', String=\"\"\"%s\"\"\" )"%(sk, __value) )
341 # Background, ObservationError, ObservationOperator...
342 elif type(r) is dict:
344 if 'Stored' in r and bool(r['Stored']):
345 __argumentsList.append(['Stored', True])
346 if 'INPUT_TYPE' in r and 'data' in r:
347 # Vector, Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Function
348 __itype = r['INPUT_TYPE']
350 if 'FROM' in __idata:
351 # String, Script, DataFile, Template, ScriptWithOneFunction, ScriptWithFunctions
352 __ifrom = __idata['FROM']
353 __idata.pop('FROM', '')
354 if __ifrom == 'String' or __ifrom == 'Template':
355 __argumentsList.append([__itype, __idata['STRING']])
356 if __ifrom == 'Script':
357 __argumentsList.append([__itype, True])
358 __argumentsList.append(['Script', __idata['SCRIPT_FILE']])
359 if __ifrom == 'DataFile':
360 __argumentsList.append([__itype, True])
361 __argumentsList.append(['DataFile', __idata['DATA_FILE']])
362 if __ifrom == 'ScriptWithOneFunction':
363 __argumentsList.append(['OneFunction', True])
364 __argumentsList.append(['Script', __idata.pop('SCRIPTWITHONEFUNCTION_FILE')])
366 __argumentsList.append(['Parameters', __idata])
367 if __ifrom == 'ScriptWithFunctions':
368 __argumentsList.append(['ThreeFunctions', True])
369 __argumentsList.append(['Script', __idata.pop('SCRIPTWITHFUNCTIONS_FILE')])
371 __argumentsList.append(['Parameters', __idata])
372 __arguments = ["%s = %s"%(k, repr(v)) for k, v in __argumentsList]
373 __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments)))
375 __commands.append( "set( Concept='%s', Parameters=%s )"%('SupplementaryParameters', repr(__suppparameters)))
377 # ----------------------------------------------------------------------
378 __commands.sort() # Pour commencer par 'AlgorithmParameters'
379 __commands.append(__UserPostAnalysis)
382 class _SCDViewer(GenericCaseViewer):
384 Établissement des commandes d'un cas SCD (Study Config Dictionary/Cas->SCD)
386 Remarque : le fichier généré est différent de celui obtenu par EFICAS
389 "__DebugCommandNotSet", "__ObserverCommandNotSet",
390 "__UserPostAnalysisNotSet", "__hasAlgorithm")
392 def __init__(self, __name="", __objname="case", __content=None, __object=None):
393 "Initialisation et enregistrement de l'entête"
394 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
396 if __content is not None:
397 for command in __content:
398 if command[0] == "set":
399 __command = command[2]["Concept"]
401 __command = command[0].replace("set", "", 1)
402 if __command == 'Name':
403 self._name = command[2]["String"]
405 self.__DebugCommandNotSet = True
406 self.__ObserverCommandNotSet = True
407 self.__UserPostAnalysisNotSet = True
409 self._addLine("# -*- coding: utf-8 -*-")
410 self._addLine("#\n# Input for ADAO converter to SCD\n#")
412 self._addLine("study_config = {}")
413 self._addLine("study_config['Name'] = '%s'"%self._name)
415 self._addLine("inputvariables_config = {}")
416 self._addLine("inputvariables_config['Order'] =['adao_default']")
417 self._addLine("inputvariables_config['adao_default'] = -1")
418 self._addLine("study_config['InputVariables'] = inputvariables_config")
420 self._addLine("outputvariables_config = {}")
421 self._addLine("outputvariables_config['Order'] = ['adao_default']")
422 self._addLine("outputvariables_config['adao_default'] = -1")
423 self._addLine("study_config['OutputVariables'] = outputvariables_config")
424 if __content is not None:
425 for command in __content:
426 self._append(*command)
428 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
429 "Transformation d'une commande individuelle en un enregistrement"
430 if __command == "set":
431 __command = __local["Concept"]
433 __command = __command.replace("set", "", 1)
434 logging.debug("SCD Order processed: %s"%(__command))
437 if __command in (None, 'execute', 'executePythonScheme', 'executeYACSScheme', 'get', 'Name'):
439 elif __command in ['Directory',]:
440 __text = "#\nstudy_config['Repertory'] = %s"%(repr(__local['String']))
441 elif __command in ['Debug', 'setDebug']:
442 __text = "#\nstudy_config['Debug'] = '1'"
443 self.__DebugCommandNotSet = False
444 elif __command in ['NoDebug', 'setNoDebug']:
445 __text = "#\nstudy_config['Debug'] = '0'"
446 self.__DebugCommandNotSet = False
447 elif __command in ['Observer', 'setObserver']:
448 if self.__ObserverCommandNotSet:
449 self._addLine("observers = {}")
450 self._addLine("study_config['Observers'] = observers")
451 self.__ObserverCommandNotSet = False
452 __obs = __local['Variable']
453 self._numobservers += 1
455 __text += "observers['%s'] = {}\n"%__obs
456 if __local['String'] is not None:
457 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
458 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, __local['String'])
459 if __local['Script'] is not None:
460 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'Script')
461 __text += "observers['%s']['Script'] = \"%s\"\n"%(__obs, __local['Script'])
462 if __local['Template'] is not None and __local['Template'] in Templates.ObserverTemplates:
463 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
464 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, Templates.ObserverTemplates[__local['Template']])
465 if __local['Info'] is not None:
466 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __local['Info'])
468 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __obs)
469 __text += "observers['%s']['number'] = %s"%(__obs, self._numobservers)
470 elif __command in ['UserPostAnalysis', 'setUserPostAnalysis']:
472 __text += "Analysis_config = {}\n"
473 if __local['String'] is not None:
474 __text += "Analysis_config['From'] = 'String'\n"
475 __text += "Analysis_config['Data'] = \"\"\"%s\"\"\"\n"%(__local['String'],)
476 if __local['Script'] is not None:
477 __text += "Analysis_config['From'] = 'Script'\n"
478 __text += "Analysis_config['Data'] = \"\"\"%s\"\"\"\n"%(__local['Script'],)
479 if __local['Template'] is not None and __local['Template'] in Templates.UserPostAnalysisTemplates:
480 __text += "Analysis_config['From'] = 'String'\n"
481 __text += "Analysis_config['Data'] = \"\"\"%s\"\"\"\n"%(Templates.UserPostAnalysisTemplates[__local['Template']],)
482 __text += "study_config['UserPostAnalysis'] = Analysis_config"
483 self.__UserPostAnalysisNotSet = False
484 elif __local is not None: # __keys is not None and
485 numpy.set_printoptions(precision=15, threshold=1000000, linewidth=1000 * 15)
487 __text += "%s_config = {}\n"%__command
488 __local.pop('self', '')
490 __vectorIsDataFile = False
491 __vectorIsScript = False
492 for __k, __v in __local.items():
494 __to_be_removed.append(__k)
495 for __k in __to_be_removed:
497 for __k, __v in __local.items():
500 if __k in ['ScalarSparseMatrix', 'DiagonalSparseMatrix', 'Matrix', 'OneFunction', 'ThreeFunctions'] \
501 and 'Script' in __local \
502 and __local['Script'] is not None:
504 if __k in ['Vector', 'VectorSerie'] \
505 and 'DataFile' in __local \
506 and __local['DataFile'] is not None:
508 if __k == 'Parameters' and not (__command in ['AlgorithmParameters', 'SupplementaryParameters']):
510 if __k == 'Algorithm':
511 __text += "study_config['Algorithm'] = %s\n"%(repr(__v))
512 elif __k == 'DataFile':
515 __v = "'" + repr(__v) + "'"
516 for __lk in ['Vector', 'VectorSerie']:
517 if __lk in __local and __local[__lk]:
519 __text += "%s_config['Type'] = '%s'\n"%(__command, __k)
520 __text += "%s_config['From'] = '%s'\n"%(__command, __f)
521 __text += "%s_config['Data'] = %s\n"%(__command, __v)
522 __text = __text.replace("''", "'")
523 __vectorIsDataFile = True
524 elif __k == 'Script':
527 __v = "'" + repr(__v) + "'"
528 for __lk in ['ScalarSparseMatrix', 'DiagonalSparseMatrix', 'Matrix']:
529 if __lk in __local and __local[__lk]:
531 if __command == "AlgorithmParameters":
533 if 'OneFunction' in __local and __local['OneFunction']:
534 __text += "%s_ScriptWithOneFunction = {}\n"%(__command,)
535 __text += "%s_ScriptWithOneFunction['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
536 __text += "%s_ScriptWithOneFunction['Script'] = {}\n"%(__command,)
537 __text += "%s_ScriptWithOneFunction['Script']['Direct'] = %s\n"%(__command, __v)
538 __text += "%s_ScriptWithOneFunction['Script']['Tangent'] = %s\n"%(__command, __v)
539 __text += "%s_ScriptWithOneFunction['Script']['Adjoint'] = %s\n"%(__command, __v)
540 __text += "%s_ScriptWithOneFunction['DifferentialIncrement'] = 1e-06\n"%(__command,)
541 __text += "%s_ScriptWithOneFunction['CenteredFiniteDifference'] = 0\n"%(__command,)
543 __f = 'ScriptWithOneFunction'
544 __v = '%s_ScriptWithOneFunction'%(__command,)
545 if 'ThreeFunctions' in __local and __local['ThreeFunctions']:
546 __text += "%s_ScriptWithFunctions = {}\n"%(__command,)
547 __text += "%s_ScriptWithFunctions['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
548 __text += "%s_ScriptWithFunctions['Script'] = {}\n"%(__command,)
549 __text += "%s_ScriptWithFunctions['Script']['Direct'] = %s\n"%(__command, __v)
550 __text += "%s_ScriptWithFunctions['Script']['Tangent'] = %s\n"%(__command, __v)
551 __text += "%s_ScriptWithFunctions['Script']['Adjoint'] = %s\n"%(__command, __v)
553 __f = 'ScriptWithFunctions'
554 __v = '%s_ScriptWithFunctions'%(__command,)
555 __text += "%s_config['Type'] = '%s'\n"%(__command, __k)
556 __text += "%s_config['From'] = '%s'\n"%(__command, __f)
557 __text += "%s_config['Data'] = %s\n"%(__command, __v)
558 __text = __text.replace("''", "'")
559 __vectorIsScript = True
560 elif __k in ('Stored', 'Checked', 'ColMajor', 'CrossObs', 'SyncObs', 'InputFunctionAsMulti', 'nextStep'):
562 __text += "%s_config['%s'] = '%s'\n"%(__command, __k, int(bool(__v)))
563 elif __k in ('PerformanceProfile', 'noDetails'):
565 __text += "%s_config['%s'] = '%s'\n"%(__command, __k, int(bool(__v)))
567 if __k == 'Vector' and __vectorIsScript:
569 if __k == 'Vector' and __vectorIsDataFile:
571 if __k == 'Parameters':
573 if isinstance(__v, Persistence.Persistence):
576 __text = self._missing%__v.__name__ + __text
577 if isinstance(__v, dict):
578 for val in __v.values():
580 __text = self._missing%val.__name__ + __text
581 __text += "%s_config['Type'] = '%s'\n"%(__command, __k)
582 __text += "%s_config['From'] = '%s'\n"%(__command, 'String')
583 __text += "%s_config['Data'] = \"\"\"%s\"\"\"\n"%(__command, repr(__v))
584 __text += "study_config['%s'] = %s_config"%(__command, __command)
585 numpy.set_printoptions(precision=8, threshold=1000, linewidth=75)
587 self._switchoff = True
588 if __text is not None:
589 self._addLine(__text)
591 self._switchoff = False
593 def _finalize(self, *__args):
594 self.__loadVariablesByScript()
595 if self.__DebugCommandNotSet:
596 self._addLine("#\nstudy_config['Debug'] = '0'")
597 if self.__UserPostAnalysisNotSet:
599 self._addLine("Analysis_config = {}")
600 self._addLine("Analysis_config['From'] = 'String'")
601 self._addLine("Analysis_config['Data'] = \"\"\"import numpy")
602 self._addLine("xa=ADD.get('Analysis')[-1]")
603 self._addLine("print('Analysis:',xa)\"\"\"")
604 self._addLine("study_config['UserPostAnalysis'] = Analysis_config")
606 def __loadVariablesByScript(self):
607 __ExecVariables = {} # Necessaire pour recuperer la variable
608 exec("\n".join(self._lineSerie), __ExecVariables)
609 study_config = __ExecVariables['study_config']
610 # Pour Python 3 : self.__hasAlgorithm = bool(study_config['Algorithm'])
611 if 'Algorithm' in study_config:
612 self.__hasAlgorithm = True
614 self.__hasAlgorithm = False
615 if not self.__hasAlgorithm and \
616 "AlgorithmParameters" in study_config and \
617 isinstance(study_config['AlgorithmParameters'], dict) and \
618 "From" in study_config['AlgorithmParameters'] and \
619 "Data" in study_config['AlgorithmParameters'] and \
620 study_config['AlgorithmParameters']['From'] == 'Script':
621 __asScript = study_config['AlgorithmParameters']['Data']
622 __var = ImportFromScript(__asScript).getvalue( "Algorithm" )
623 __text = "#\nstudy_config['Algorithm'] = '%s'"%(__var,)
624 self._addLine(__text)
625 if self.__hasAlgorithm and \
626 "AlgorithmParameters" in study_config and \
627 isinstance(study_config['AlgorithmParameters'], dict) and \
628 "From" not in study_config['AlgorithmParameters'] and \
629 "Data" not in study_config['AlgorithmParameters']:
631 __text += "AlgorithmParameters_config['Type'] = 'Dict'\n"
632 __text += "AlgorithmParameters_config['From'] = 'String'\n"
633 __text += "AlgorithmParameters_config['Data'] = '{}'\n"
634 self._addLine(__text)
635 if 'SupplementaryParameters' in study_config and \
636 isinstance(study_config['SupplementaryParameters'], dict) and \
637 "From" in study_config['SupplementaryParameters'] and \
638 study_config['SupplementaryParameters']["From"] == 'String' and \
639 "Data" in study_config['SupplementaryParameters']:
640 __dict = eval(study_config['SupplementaryParameters']["Data"])
641 if 'ExecuteInContainer' in __dict:
642 self._addLine("#\nstudy_config['ExecuteInContainer'] = '%s'"%__dict['ExecuteInContainer'])
644 self._addLine("#\nstudy_config['ExecuteInContainer'] = 'No'")
645 if 'StudyType' in __dict:
646 self._addLine("#\nstudy_config['StudyType'] = '%s'"%__dict['StudyType'])
647 if 'StudyType' in __dict and __dict['StudyType'] != "ASSIMILATION_STUDY":
648 self.__UserPostAnalysisNotSet = False
651 class _YACSViewer(GenericCaseViewer):
653 Etablissement des commandes d'un cas YACS (Cas->SCD->YACS)
655 __slots__ = ("__internalSCD", "_append")
657 def __init__(self, __name="", __objname="case", __content=None, __object=None):
658 "Initialisation et enregistrement de l'entete"
659 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
660 self.__internalSCD = _SCDViewer(__name, __objname, __content, __object)
661 self._append = self.__internalSCD._append
663 def dump(self, __filename=None, __upa=None):
664 "Restitution normalisée des commandes"
666 if __filename is None:
667 raise ValueError("A file name has to be given for YACS XML output.")
669 __file = os.path.abspath(__filename)
670 if os.path.isfile(__file) or os.path.islink(__file):
673 if not lpi.has_salome or not lpi.has_adao:
675 "Unable to get SALOME (%s) or ADAO (%s) environnement for YACS conversion.\n"%(lpi.has_salome, lpi.has_adao) + \
676 "Please load the right SALOME environnement before trying to use it.")
678 from daYacsSchemaCreator.run import create_schema_from_content
680 self.__internalSCD._finalize(__upa)
681 __SCDdump = self.__internalSCD.dump()
682 create_schema_from_content(__SCDdump, __file)
684 if not os.path.exists(__file):
685 __msg = "An error occured during the ADAO YACS Schema build for\n"
686 __msg += "the target output file:\n"
687 __msg += " %s\n"%__file
688 __msg += "See errors details in your launching terminal log.\n"
689 raise ValueError(__msg)
691 __fid = open(__file, "r")
692 __text = __fid.read()
696 # ==============================================================================
697 class _ReportViewer(GenericCaseViewer):
699 Partie commune de restitution simple
703 def __init__(self, __name="", __objname="case", __content=None, __object=None):
704 "Initialisation et enregistrement de l'entete"
705 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
706 self._r = Reporting.ReportStorage()
709 self._r.append("ADAO Study report", "title")
711 self._r.append(str(self._name), "title")
712 self._r.append("Summary build with %s version %s"%(version.name, version.version))
713 if self._content is not None:
714 for command in self._content:
715 self._append(*command)
717 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
718 "Transformation d'une commande individuelle en un enregistrement"
719 if __command is not None and __keys is not None and __local is not None:
720 if __command in ("set", "get") and "Concept" in __keys:
721 __command = __local["Concept"]
722 __text = "<i>%s</i> command has been set"%str(__command.replace("set", ""))
725 if k not in __local: continue # noqa: E701
727 if __v is None: continue # noqa: E701
728 if k == "SyncObs" and not __v: continue # noqa: E241,E271,E272,E701
729 if k == "Checked" and not __v: continue # noqa: E241,E271,E272,E701
730 if k == "ColMajor" and not __v: continue # noqa: E241,E271,E272,E701
731 if k == "CrossObs" and not __v: continue # noqa: E241,E271,E272,E701
732 if k == "InputFunctionAsMulti" and not __v: continue # noqa: E241,E271,E272,E701
733 if k == "PerformanceProfile" and __v: continue # noqa: E241,E271,E272,E701
734 if k == "Stored" and not __v: continue # noqa: E241,E271,E272,E701
735 if k == "nextStep" and not __v: continue # noqa: E241,E271,E272,E701
736 if k == "noDetails": continue # noqa: E241,E271,E272,E701
737 if k == "Concept": continue # noqa: E241,E271,E272,E701
738 if k == "self": continue # noqa: E241,E271,E272,E701
739 if isinstance(__v, Persistence.Persistence):
741 numpy.set_printoptions(precision=15, threshold=1000000, linewidth=1000 * 15)
742 __ktext += "\n %s = %s,"%(k, repr(__v))
743 numpy.set_printoptions(precision=8, threshold=1000, linewidth=75)
745 __text += " with values:" + __ktext
746 __text = __text.rstrip(", ")
747 self._r.append(__text, "uli")
749 def _finalize(self, __upa=None):
750 "Enregistrement du final"
751 raise NotImplementedError()
753 class _SimpleReportInRstViewer(_ReportViewer):
755 Restitution simple en RST
759 def _finalize(self, __upa=None):
760 self._lineSerie.append(Reporting.ReportViewInRst(self._r).__str__())
762 class _SimpleReportInHtmlViewer(_ReportViewer):
764 Restitution simple en HTML
768 def _finalize(self, __upa=None):
769 self._lineSerie.append(Reporting.ReportViewInHtml(self._r).__str__())
771 class _SimpleReportInPlainTxtViewer(_ReportViewer):
773 Restitution simple en TXT
777 def _finalize(self, __upa=None):
778 self._lineSerie.append(Reporting.ReportViewInPlainTxt(self._r).__str__())
780 # ==============================================================================
781 class ImportFromScript(object):
783 Obtention d'une variable nommee depuis un fichier script importé
785 __slots__ = ("__basename", "__filenspace", "__filestring")
787 def __init__(self, __filename=None):
788 "Verifie l'existence et importe le script"
789 if __filename is None:
790 raise ValueError("The name of the file, containing the variable to be read, has to be specified.")
791 __fullname, __i = __filename, 0
792 while not os.path.exists(__fullname) and __i < len(sys.path):
793 # Correction avec le sys.path si nécessaire
794 __fullname = os.path.join(sys.path[__i], __filename)
796 if not os.path.exists(__filename):
797 if os.path.exists(__fullname):
798 __filename = __fullname
801 "The file containing the variable to be imported doesn't seem to" + \
802 " exist. Please check the file. The given file name is:\n \"%s\""%str(__filename))
803 if os.path.dirname(__filename) != '':
804 sys.path.insert(0, os.path.dirname(__filename))
805 __basename = os.path.basename(__filename).rstrip(".py")
807 __basename = __filename.rstrip(".py")
808 PlatformInfo.checkFileNameImportability( __basename + ".py" )
809 self.__basename = __basename
811 self.__filenspace = __import__(__basename, globals(), locals(), [])
813 self.__filenspace = ""
814 with open(__filename, 'r') as fid:
815 self.__filestring = fid.read()
817 def getvalue(self, __varname=None, __synonym=None ):
818 "Renvoie la variable demandee par son nom ou son synonyme"
819 if __varname is None:
820 raise ValueError("The name of the variable to be read has to be specified. Please check the content of the file and the syntax.")
821 if not hasattr(self.__filenspace, __varname):
822 if __synonym is None:
824 "The imported script file \"%s\""%(str(self.__basename) + ".py",) + \
825 " doesn't contain the mandatory variable \"%s\""%(__varname,) + \
826 " to be read. Please check the content of the file and the syntax.")
827 elif not hasattr(self.__filenspace, __synonym):
829 "The imported script file \"%s\""%(str(self.__basename) + ".py",) + \
830 " doesn't contain the mandatory variable \"%s\""%(__synonym,) + \
831 " to be read. Please check the content of the file and the syntax.")
833 return getattr(self.__filenspace, __synonym)
835 return getattr(self.__filenspace, __varname)
838 "Renvoie le script complet"
839 return self.__filestring
841 # ==============================================================================
842 class ImportDetector(object):
844 Détection des caractéristiques de fichiers ou objets en entrée
846 __slots__ = ("__url", "__usr", "__root", "__end")
851 def __exit__(self, exc_type, exc_val, exc_tb):
854 def __init__(self, __url, UserMime=""):
856 raise ValueError("The name or url of the file object has to be specified.")
858 self.__url = __url.decode()
860 self.__url = str(__url)
861 if UserMime is bytes:
862 self.__usr = UserMime.decode().lower()
864 self.__usr = str(UserMime).lower()
865 (self.__root, self.__end) = os.path.splitext(self.__url)
867 mimetypes.add_type('application/numpy.npy', '.npy')
868 mimetypes.add_type('application/numpy.npz', '.npz')
869 mimetypes.add_type('application/dymola.sdf', '.sdf')
870 if sys.platform.startswith("win"):
871 mimetypes.add_type('text/plain', '.txt')
872 mimetypes.add_type('text/csv', '.csv')
873 mimetypes.add_type('text/tab-separated-values', '.tsv')
877 def is_local_file(self):
878 if os.path.isfile(os.path.realpath(self.__url)):
883 def is_not_local_file(self):
884 return not self.is_local_file()
886 def raise_error_if_not_local_file(self):
887 if self.is_not_local_file():
888 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))
892 # Directory related tests
893 # -----------------------
894 def is_local_dir(self):
895 if os.path.isdir(self.__url):
900 def is_not_local_dir(self):
901 return not self.is_local_dir()
903 def raise_error_if_not_local_dir(self):
904 if self.is_not_local_dir():
905 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))
909 # Mime related functions
910 # ------------------------
911 def get_standard_mime(self):
912 (__mtype, __encoding) = mimetypes.guess_type(self.__url, strict=False)
915 def get_user_mime(self):
916 __fake = "fake." + self.__usr.lower()
917 (__mtype, __encoding) = mimetypes.guess_type(__fake, strict=False)
920 def get_comprehensive_mime(self):
921 if self.get_standard_mime() is not None:
922 return self.get_standard_mime()
923 elif self.get_user_mime() is not None:
924 return self.get_user_mime()
928 # Name related functions
929 # ----------------------
930 def get_user_name(self):
933 def get_absolute_name(self):
934 return os.path.abspath(os.path.realpath(self.__url))
936 def get_extension(self):
939 class ImportFromFile(object):
941 Obtention de variables disrétisées en 1D, définies par une ou des variables
942 nommées, et sous la forme d'une série de points éventuellement indexés. La
943 lecture d'un fichier au format spécifié (ou intuité) permet de charger ces
945 - des fichiers textes en colonnes de type TXT, CSV, TSV...
946 - des fichiers de données binaires NPY, NPZ, SDF...
947 La lecture du fichier complet ne se fait que si nécessaire, pour assurer la
948 performance tout en disposant de l'interprétation du contenu. Les fichiers
949 textes doivent présenter en première ligne (hors commentaire ou ligne vide)
950 les noms des variables de colonnes. Les commentaires commencent par un "#".
953 "_filename", "_colnames", "_colindex", "_varsline", "_format",
954 "_delimiter", "_skiprows", "__url", "__filestring", "__header",
955 "__allowvoid", "__binaryformats", "__supportedformats")
960 def __exit__(self, exc_type, exc_val, exc_tb):
963 def __init__(self, Filename=None, ColNames=None, ColIndex=None, Format="Guess", AllowVoidNameList=True):
965 Verifie l'existence et les informations de définition du fichier. Les
966 noms de colonnes ou de variables sont ignorées si le format ne permet
969 - Filename : nom du fichier
970 - ColNames : noms de la ou des colonnes/variables à lire
971 - ColIndex : nom unique de la colonne/variable servant d'index
972 - Format : format du fichier et/ou des données inclues
973 - AllowVoidNameList : permet, si la liste de noms est vide, de
974 prendre par défaut toutes les colonnes
976 self.__binaryformats = (
977 "application/numpy.npy",
978 "application/numpy.npz",
979 "application/dymola.sdf",
981 self.__url = ImportDetector( Filename, Format)
982 self.__url.raise_error_if_not_local_file()
983 self._filename = self.__url.get_absolute_name()
984 PlatformInfo.checkFileNameConformity( self._filename )
986 self._format = self.__url.get_comprehensive_mime()
988 self.__header, self._varsline, self._skiprows = self.__getentete()
990 if self._format == "text/csv" or Format.upper() == "CSV":
991 self._format = "text/csv"
992 self.__filestring = "".join(self.__header)
993 if self.__filestring.count(",") > 0:
994 self._delimiter = ","
995 elif self.__filestring.count(";") > 0:
996 self._delimiter = ";"
998 self._delimiter = None
999 elif self._format == "text/tab-separated-values" or Format.upper() == "TSV":
1000 self._format = "text/tab-separated-values"
1001 self._delimiter = "\t"
1003 self._delimiter = None
1005 if ColNames is not None:
1006 self._colnames = tuple(ColNames)
1008 self._colnames = None
1010 if ColIndex is not None:
1011 self._colindex = str(ColIndex)
1013 self._colindex = None
1015 self.__allowvoid = bool(AllowVoidNameList)
1017 def __getentete(self, __nblines = 3):
1018 "Lit l'entête du fichier pour trouver la définition des variables"
1019 # La première ligne non vide non commentée est toujours considérée
1020 # porter les labels de colonne, donc pas des valeurs
1021 __header, __varsline, __skiprows = [], "", 1
1022 if self._format in self.__binaryformats:
1025 with open(self._filename, 'r') as fid:
1026 __line = fid.readline().strip()
1027 while "#" in __line or len(__line) < 1:
1028 __header.append(__line)
1030 __line = fid.readline().strip()
1031 __varsline = __line # Ligne de labels par convention
1032 for i in range(max(0, __nblines)):
1033 __header.append(fid.readline())
1034 return (__header, __varsline, __skiprows)
1036 def __getindices(self, __colnames, __colindex, __delimiter=None ):
1037 "Indices de colonnes correspondants à l'index et aux variables"
1038 if __delimiter is None:
1039 __varserie = self._varsline.strip('#').strip().split()
1041 __varserie = self._varsline.strip('#').strip().split(str(__delimiter))
1043 if __colnames is not None:
1045 __colnames = tuple(__colnames)
1046 for v in __colnames:
1047 for i, n in enumerate(__varserie):
1050 __usecols = tuple(__usecols)
1051 if len(__usecols) == 0:
1052 if self.__allowvoid:
1055 raise ValueError("Can not found any column corresponding to the required names %s"%(__colnames,))
1059 if __colindex is not None:
1061 __colindex = str(__colindex)
1062 for i, n in enumerate(__varserie):
1068 return (__usecols, __useindex)
1070 def getsupported(self):
1071 self.__supportedformats = {}
1072 self.__supportedformats["text/plain"] = True
1073 self.__supportedformats["text/csv"] = True
1074 self.__supportedformats["text/tab-separated-values"] = True
1075 self.__supportedformats["application/numpy.npy"] = True
1076 self.__supportedformats["application/numpy.npz"] = True
1077 self.__supportedformats["application/dymola.sdf"] = lpi.has_sdf
1078 return self.__supportedformats
1080 def getvalue(self, ColNames=None, ColIndex=None ):
1081 "Renvoie la ou les variables demandées par la liste de leurs noms"
1082 # Uniquement si mise à jour
1083 if ColNames is not None:
1084 self._colnames = tuple(ColNames)
1085 if ColIndex is not None:
1086 self._colindex = str(ColIndex)
1089 if self._format == "application/numpy.npy":
1090 __columns = numpy.load(self._filename)
1092 elif self._format == "application/numpy.npz":
1094 with numpy.load(self._filename) as __allcolumns:
1095 if self._colnames is None:
1096 self._colnames = __allcolumns.files
1097 for nom in self._colnames: # Si une variable demandée n'existe pas
1098 if nom not in __allcolumns.files:
1099 self._colnames = tuple( __allcolumns.files )
1100 for nom in self._colnames:
1101 if nom in __allcolumns.files:
1102 if __columns is not None:
1103 # Attention : toutes les variables doivent avoir la même taille
1104 __columns = numpy.vstack((__columns, numpy.reshape(__allcolumns[nom], (1, -1))))
1107 __columns = numpy.reshape(__allcolumns[nom], (1, -1))
1108 if self._colindex is not None and self._colindex in __allcolumns.files:
1109 __index = numpy.array(numpy.reshape(__allcolumns[self._colindex], (1, -1)), dtype=bytes)
1110 elif self._format == "text/plain":
1111 __usecols, __useindex = self.__getindices(self._colnames, self._colindex)
1112 __columns = numpy.loadtxt(self._filename, usecols = __usecols, skiprows=self._skiprows)
1113 if __useindex is not None:
1114 __index = numpy.loadtxt(self._filename, dtype = bytes, usecols = (__useindex,), skiprows=self._skiprows)
1115 if __usecols is None: # Si une variable demandée n'existe pas
1116 self._colnames = None
1118 elif self._format == "application/dymola.sdf" and lpi.has_sdf:
1120 __content = sdf.load(self._filename)
1122 if self._colnames is None:
1123 self._colnames = [__content.datasets[i].name for i in range(len(__content.datasets))]
1124 for nom in self._colnames:
1125 if nom in __content:
1126 if __columns is not None:
1127 # Attention : toutes les variables doivent avoir la même taille
1128 __columns = numpy.vstack((__columns, numpy.reshape(__content[nom].data, (1, -1))))
1131 __columns = numpy.reshape(__content[nom].data, (1, -1))
1132 if self._colindex is not None and self._colindex in __content:
1133 __index = __content[self._colindex].data
1135 elif self._format == "text/csv":
1136 __usecols, __useindex = self.__getindices(self._colnames, self._colindex, self._delimiter)
1137 __columns = numpy.loadtxt(self._filename, usecols = __usecols, delimiter = self._delimiter, skiprows=self._skiprows)
1138 if __useindex is not None:
1139 __index = numpy.loadtxt(self._filename, dtype = bytes, usecols = (__useindex,), delimiter = self._delimiter, skiprows=self._skiprows)
1140 if __usecols is None: # Si une variable demandée n'existe pas
1141 self._colnames = None
1143 elif self._format == "text/tab-separated-values":
1144 __usecols, __useindex = self.__getindices(self._colnames, self._colindex, self._delimiter)
1145 __columns = numpy.loadtxt(self._filename, usecols = __usecols, delimiter = self._delimiter, skiprows=self._skiprows)
1146 if __useindex is not None:
1147 __index = numpy.loadtxt(self._filename, dtype = bytes, usecols = (__useindex,), delimiter = self._delimiter, skiprows=self._skiprows)
1148 if __usecols is None: # Si une variable demandée n'existe pas
1149 self._colnames = None
1151 raise ValueError("Unkown file format \"%s\" or no reader available"%self._format)
1152 if __columns is None:
1155 def toString(value):
1157 return value.decode()
1160 if __index is not None:
1161 __index = tuple([toString(v) for v in __index])
1163 return (self._colnames, __columns, self._colindex, __index)
1165 def getstring(self):
1166 "Renvoie le fichier texte complet"
1167 if self._format in self.__binaryformats:
1170 with open(self._filename, 'r') as fid:
1173 def getformat(self):
1176 class ImportScalarLinesFromFile(ImportFromFile):
1178 Importation de fichier contenant des variables scalaires nommées. Le
1179 fichier comporte soit 2, soit 4 colonnes, obligatoirement nommées "Name",
1180 "Value", "Minimum", "Maximum" si les noms sont précisés. Sur chaque ligne
1181 est indiqué le nom, la valeur, et éventuelement deux bornes min et max (ou
1182 None si nécessaire pour une borne).
1184 Seule la méthode "getvalue" est changée.
1188 def __enter__(self):
1191 def __exit__(self, exc_type, exc_val, exc_tb):
1194 def __init__(self, Filename=None, ColNames=None, ColIndex=None, Format="Guess"):
1195 ImportFromFile.__init__(self, Filename, ColNames, ColIndex, Format)
1196 if self._format not in ["text/plain", "text/csv", "text/tab-separated-values"]:
1197 raise ValueError("Unkown file format \"%s\""%self._format)
1199 def getvalue(self, VarNames = None, HeaderNames=()):
1200 "Renvoie la ou les variables demandées par la liste de leurs noms"
1201 if VarNames is not None:
1202 __varnames = tuple(VarNames)
1206 if "Name" in self._varsline and "Value" in self._varsline and "Minimum" in self._varsline and "Maximum" in self._varsline:
1207 __ftype = "NamValMinMax"
1208 __dtypes = {'names' : ('Name', 'Value', 'Minimum', 'Maximum'), # noqa: E203
1209 'formats': ('S128', 'g', 'g', 'g')}
1210 __usecols = (0, 1, 2, 3)
1212 def __replaceNoneN( s ):
1213 if s.strip() == b'None':
1218 def __replaceNoneP( s ):
1219 if s.strip() == b'None':
1223 __converters = {2: __replaceNoneN, 3: __replaceNoneP}
1224 elif "Name" in self._varsline and "Value" in self._varsline and ("Minimum" not in self._varsline or "Maximum" not in self._varsline):
1226 __dtypes = {'names' : ('Name', 'Value'), # noqa: E203
1227 'formats': ('S128', 'g')}
1230 elif len(HeaderNames) > 0 and numpy.all([kw in self._varsline for kw in HeaderNames]):
1231 __ftype = "NamLotOfVals"
1232 __dtypes = {'names' : HeaderNames, # noqa: E203
1233 'formats': tuple(['S128',] + ['g'] * (len(HeaderNames) - 1))}
1234 __usecols = tuple(range(len(HeaderNames)))
1236 def __replaceNone( s ):
1237 if s.strip() == b'None':
1241 __converters = dict()
1242 for i in range(1, len(HeaderNames)):
1243 __converters[i] = __replaceNone
1245 raise ValueError("Can not find names of columns for initial values. Wrong first line is:\n \"%s\""%self._varsline)
1247 if self._format == "text/plain":
1248 __content = numpy.loadtxt(
1251 usecols = __usecols,
1252 skiprows = self._skiprows,
1253 converters = __converters,
1256 elif self._format in ["text/csv", "text/tab-separated-values"]:
1257 __content = numpy.loadtxt(
1260 usecols = __usecols,
1261 skiprows = self._skiprows,
1262 converters = __converters,
1263 delimiter = self._delimiter,
1267 raise ValueError("Unkown file format \"%s\""%self._format)
1269 __names, __thevalue, __bounds = [], [], []
1270 for sub in __content:
1271 if len(__usecols) == 4:
1272 na, va, mi, ma = sub
1273 if numpy.isneginf(mi):
1274 mi = None # Réattribue les variables None
1275 elif numpy.isnan(mi):
1276 mi = None # Réattribue les variables None
1277 if numpy.isposinf(ma):
1278 ma = None # Réattribue les variables None
1279 elif numpy.isnan(ma):
1280 ma = None # Réattribue les variables None
1281 elif len(__usecols) == 2 and __ftype == "NamVal":
1287 for i, v in enumerate(nsub[1:]):
1293 if (__varnames is None or na in __varnames) and (na not in __names):
1294 # Ne stocke que la premiere occurence d'une variable
1296 __thevalue.append(va)
1297 __bounds.append((mi, ma))
1299 __names = tuple(__names)
1300 __thevalue = numpy.array(__thevalue)
1301 __bounds = tuple(__bounds)
1303 return (__names, __thevalue, __bounds)
1305 # ==============================================================================
1306 class EficasGUI(object):
1308 Lancement autonome de l'interface EFICAS/ADAO
1310 __slots__ = ("__msg", "__path_settings_ok")
1312 def __init__(self, __addpath = None):
1313 # Chemin pour l'installation (ordre important)
1315 self.__path_settings_ok = False
1317 if "EFICAS_TOOLS_ROOT" in os.environ:
1318 __EFICAS_TOOLS_ROOT = os.environ["EFICAS_TOOLS_ROOT"]
1320 elif "EFICAS_NOUVEAU_ROOT" in os.environ:
1321 __EFICAS_TOOLS_ROOT = os.environ["EFICAS_NOUVEAU_ROOT"]
1324 self.__msg += "\nKeyError:\n" + \
1325 " the required environment variable EFICAS_TOOLS_ROOT is unknown.\n" + \
1326 " You have either to be in SALOME environment, or to set this\n" + \
1327 " variable in your environment to the right path \"<...>\" to\n" + \
1328 " find an installed EFICAS application. For example:\n" + \
1329 " EFICAS_TOOLS_ROOT=\"<...>\" command\n"
1333 __path_ok = True and __path_ok
1335 self.__msg += "\nImportError:\n" + \
1336 " the required ADAO library can not be found to be imported.\n" + \
1337 " You have either to be in ADAO environment, or to be in SALOME\n" + \
1338 " environment, or to set manually in your Python 3 environment the\n" + \
1339 " right path \"<...>\" to find an installed ADAO application. For\n" + \
1341 " PYTHONPATH=\"<...>:${PYTHONPATH}\" command\n"
1344 import PyQt5 # noqa: F401
1345 __path_ok = True and __path_ok
1347 self.__msg += "\nImportError:\n" + \
1348 " the required PyQt5 library can not be found to be imported.\n" + \
1349 " You have either to have a raisonable up-to-date Python 3\n" + \
1350 " installation (less than 5 years), or to be in SALOME environment.\n"
1354 self.__msg += "\nWarning:\n" + \
1355 " It seems you have some troubles with your installation.\n" + \
1356 " Be aware that some other errors may exist, that are not\n" + \
1357 " explained as above, like some incomplete or obsolete\n" + \
1358 " Python 3, or incomplete module installation.\n" + \
1360 " Please correct the above error(s) before launching the\n" + \
1361 " standalone EFICAS/ADAO interface.\n"
1362 logging.debug("Some of the ADAO/EFICAS/QT5 paths have not been found")
1363 self.__path_settings_ok = False
1365 logging.debug("All the ADAO/EFICAS/QT5 paths have been found")
1366 self.__path_settings_ok = True
1368 if self.__path_settings_ok:
1369 sys.path.insert(0, __EFICAS_TOOLS_ROOT)
1370 sys.path.insert(0, os.path.join(adao.adao_py_dir, "daEficas"))
1371 if __addpath is not None and os.path.exists(os.path.abspath(__addpath)):
1372 sys.path.insert(0, os.path.abspath(__addpath))
1373 logging.debug("All the paths have been correctly set up")
1376 logging.debug("Errors in path settings have been found")
1379 if self.__path_settings_ok:
1380 logging.debug("Launching standalone EFICAS/ADAO interface...")
1381 from daEficas import prefs
1382 from InterfaceQT4 import eficas_go
1383 eficas_go.lanceEficas(code=prefs.code)
1385 logging.debug("Can not launch standalone EFICAS/ADAO interface for path errors.")
1387 # ==============================================================================
1388 if __name__ == "__main__":
1389 print("\n AUTODIAGNOSTIC\n")