1 # -*- coding: utf-8 -*-
3 # Copyright (C) 2008-2018 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"
34 from daCore import Persistence
35 from daCore import PlatformInfo
36 from daCore import Templates
38 # ==============================================================================
39 class GenericCaseViewer(object):
41 Gestion des commandes de creation d'une vue de cas
43 def __init__(self, __name="", __objname="case", __content=None, __object=None):
44 "Initialisation et enregistrement de l'entete"
45 self._name = str(__name)
46 self._objname = str(__objname)
48 self._switchoff = False
49 self._numobservers = 2
50 self._content = __content
51 self._object = __object
52 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# """
53 def _append(self, *args):
54 "Transformation de commande individuelle en enregistrement"
55 raise NotImplementedError()
56 def _extract(self, *args):
57 "Transformation d'enregistrement en commande individuelle"
58 raise NotImplementedError()
59 def _finalize(self, __upa=None):
60 "Enregistrement du final"
61 if __upa is not None and len(__upa)>0:
62 self._lineSerie.append("%s.execute()"%(self._objname,))
63 self._lineSerie.append(__upa)
64 def _addLine(self, line=""):
65 "Ajoute un enregistrement individuel"
66 self._lineSerie.append(line)
67 def _get_objname(self):
69 def dump(self, __filename=None, __upa=None):
70 "Restitution normalisée des commandes"
72 __text = "\n".join(self._lineSerie)
74 if __filename is not None:
75 __file = os.path.abspath(__filename)
76 __fid = open(__file,"w")
80 def load(self, __filename=None, __content=None, __object=None):
81 "Chargement normalisé des commandes"
82 if __filename is not None and os.path.exists(__filename):
83 self._content = open(__filename, 'r').read()
84 elif __content is not None and type(__content) is str:
85 self._content = __content
86 elif __object is not None and type(__object) is dict:
87 self._object = copy.deepcopy(__object)
89 pass # use "self._content" from initialization
90 __commands = self._extract(self._content, self._object)
93 class _TUIViewer(GenericCaseViewer):
95 Etablissement des commandes d'un cas ADAO TUI (Cas<->TUI)
97 def __init__(self, __name="", __objname="case", __content=None, __object=None):
98 "Initialisation et enregistrement de l'entete"
99 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
100 self._addLine("# -*- coding: utf-8 -*-")
101 self._addLine("#\n# Python script for ADAO TUI\n#")
102 self._addLine("from numpy import array, matrix")
103 self._addLine("import adaoBuilder")
104 self._addLine("%s = adaoBuilder.New('%s')"%(self._objname, self._name))
105 if self._content is not None:
106 for command in self._content:
107 self._append(*command)
108 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
109 "Transformation d'une commande individuelle en un enregistrement"
110 if __command is not None and __keys is not None and __local is not None:
112 if __pre is not None:
113 __text += "%s = "%__pre
114 __text += "%s.%s( "%(self._objname,str(__command))
115 if "self" in __keys: __keys.remove("self")
116 if __command not in ("set","get") and "Concept" in __keys: __keys.remove("Concept")
119 if __v is None: continue
120 if k == "Checked" and not __v: continue
121 if k == "Stored" and not __v: continue
122 if k == "AvoidRC" and __v: continue
123 if k == "noDetails": continue
124 if isinstance(__v,Persistence.Persistence): __v = __v.values()
125 if callable(__v): __text = self._missing%__v.__name__+__text
126 if isinstance(__v,dict):
127 for val in __v.values():
128 if callable(val): __text = self._missing%val.__name__+__text
129 numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
130 __text += "%s=%s, "%(k,repr(__v))
131 numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
134 self._addLine(__text)
135 def _extract(self, __multilines="", __object=None):
136 "Transformation un enregistrement en une commande individuelle"
139 __multilines = __multilines.replace("\r\n","\n")
140 for line in __multilines.split("\n"):
141 if "adaoBuilder.New" in line and "=" in line:
142 self._objname = line.split("=")[0].strip()
144 logging.debug("TUI Extracting commands of '%s' object..."%(self._objname,))
148 if self._objname+".set" in line:
149 __commands.append( line.replace(self._objname+".","",1) )
150 logging.debug("TUI Extracted command: %s"%(__commands[-1],))
153 class _EPDViewer(GenericCaseViewer):
155 Etablissement des commandes d'un cas EPD (Eficas Python Dictionnary/Cas<-EPD)
157 def __init__(self, __name="", __objname="case", __content=None, __object=None):
158 "Initialisation et enregistrement de l'entete"
159 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
160 self._observerIndex = 0
161 self._addLine("# -*- coding: utf-8 -*-")
162 self._addLine("#\n# Python script for ADAO EPD\n#")
163 self._addLine("from numpy import array, matrix")
165 self._addLine("%s = {}"%__objname)
166 if self._content is not None:
167 for command in self._content:
168 self._append(*command)
169 def _extract(self, __multilines=None, __object=None):
170 "Transformation un enregistrement en une commande individuelle"
171 if __multilines is not None:
172 __multilines = __multilines.replace("\r\n","\n")
175 __getlocals = locals()
176 for k in __getlocals:
178 if type(__getlocals[k]) is dict:
179 if 'ASSIMILATION_STUDY' in __getlocals[k]:
181 self._objdata = __getlocals[k]['ASSIMILATION_STUDY']
182 if 'CHECKING_STUDY' in __getlocals[k]:
184 self._objdata = __getlocals[k]['CHECKING_STUDY']
187 elif __multilines is None and __object is not None and type(__object) is dict:
188 self._objname = "case"
190 if 'ASSIMILATION_STUDY' in __object:
191 self._objdata = __object['ASSIMILATION_STUDY']
192 if 'CHECKING_STUDY' in __object:
193 self._objdata = __object['CHECKING_STUDY']
197 if self._objdata is None or not(type(self._objdata) is dict) or not('AlgorithmParameters' in self._objdata):
198 raise ValueError("Impossible to load given content as a ADAO EPD one (no dictionnary or no 'AlgorithmParameters' key found).")
199 # ----------------------------------------------------------------------
200 logging.debug("EPD Extracting commands of '%s' object..."%(self._objname,))
202 __UserPostAnalysis = ""
203 for k,r in self._objdata.items():
205 logging.debug("EPD Extracted command: %s:%s"%(k, r))
206 if __command == "StudyName" and len(str(r))>0:
207 __commands.append( "set( Concept='Name', String='%s')"%(str(r),) )
208 elif __command == "StudyRepertory":
209 __commands.append( "set( Concept='Directory', String='%s')"%(str(r),) )
211 elif __command == "UserPostAnalysis" and type(r) is dict:
212 if 'STRING_DATA' in r:
213 __UserPostAnalysis = r['STRING_DATA']['STRING']
214 elif 'SCRIPT_DATA' in r and os.path.exists(r['SCRIPT_DATA']['SCRIPT_FILE']):
215 __UserPostAnalysis = open(r['SCRIPT_DATA']['SCRIPT_FILE'],'r').read()
216 elif 'TEMPLATE_DATA' in r:
218 __itempl = r['TEMPLATE_DATA']['Template']
219 __UserPostAnalysis = r['TEMPLATE_DATA'][__itempl]['ValueTemplate']
221 __UserPostAnalysis = ""
222 __UserPostAnalysis = __UserPostAnalysis.replace("ADD",self._objname)
224 elif __command == "AlgorithmParameters" and type(r) is dict and 'Algorithm' in r:
225 if 'Parameters%s'%(r['Algorithm'],) in r and r['Parameters'] == 'Defaults':
226 __Dict = r['Parameters%s'%(r['Algorithm'],)]
227 if 'SetSeed' in __Dict:__Dict['SetSeed'] = int(__Dict['SetSeed'])
228 if 'BoxBounds' in __Dict and type(__Dict['BoxBounds']) is str:
229 __Dict['BoxBounds'] = eval(__Dict['BoxBounds'])
230 __parameters = ', Parameters=%s'%(repr(__Dict),)
231 elif 'Dict' in r and r['Parameters'] == 'Dict':
232 __from = r['Dict']['data']
233 if 'STRING_DATA' in __from:
234 __parameters = ", Parameters=%s"%(repr(eval(__from['STRING_DATA']['STRING'])),)
235 elif 'SCRIPT_DATA' in __from and os.path.exists(__from['SCRIPT_DATA']['SCRIPT_FILE']):
236 __parameters = ", Script='%s'"%(__from['SCRIPT_DATA']['SCRIPT_FILE'],)
239 __commands.append( "set( Concept='AlgorithmParameters', Algorithm='%s'%s )"%(r['Algorithm'],__parameters) )
241 elif __command == "Observers" and type(r) is dict and 'SELECTION' in r:
242 if type(r['SELECTION']) is str:
243 __selection = (r['SELECTION'],)
245 __selection = tuple(r['SELECTION'])
246 for sk in __selection:
247 __idata = r[sk]['%s_data'%sk]
248 if __idata['NodeType'] == 'Template' and 'Template' in __idata['ObserverTemplate']:
249 __template =__idata['ObserverTemplate']['Template']
250 __commands.append( "set( Concept='Observer', Variable='%s', Template='%s' )"%(sk,__template) )
251 if __idata['NodeType'] == 'String' and 'Value' in __idata:
252 __value =__idata['Value']
253 __commands.append( "set( Concept='Observer', Variable='%s', String='%s' )"%(sk,__value) )
255 # Background, ObservationError, ObservationOperator...
256 elif type(r) is dict:
258 if 'Stored' in r and bool(r['Stored']):
259 __argumentsList.append(['Stored',True])
260 if 'INPUT_TYPE' in r and r['INPUT_TYPE'] in r:
261 # Vector, Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Function
262 __itype = r['INPUT_TYPE']
263 __idata = r[__itype]['data']
264 if 'FROM' in __idata and __idata['FROM'].upper()+'_DATA' in __idata:
265 # String, Script, Template, ScriptWithOneFunction, ScriptWithFunctions
266 __ifrom = __idata['FROM']
267 if __ifrom == 'String' or __ifrom == 'Template':
268 __argumentsList.append([__itype,__idata['STRING_DATA']['STRING']])
269 if __ifrom == 'Script':
270 __argumentsList.append([__itype,True])
271 __argumentsList.append(['Script',__idata['SCRIPT_DATA']['SCRIPT_FILE']])
272 if __ifrom == 'ScriptWithOneFunction':
273 __argumentsList.append(['OneFunction',True])
274 __argumentsList.append(['Script',__idata['SCRIPTWITHONEFUNCTION_DATA'].pop('SCRIPTWITHONEFUNCTION_FILE')])
275 if len(__idata['SCRIPTWITHONEFUNCTION_DATA'])>0:
276 __argumentsList.append(['Parameters',__idata['SCRIPTWITHONEFUNCTION_DATA']])
277 if __ifrom == 'ScriptWithFunctions':
278 __argumentsList.append(['ThreeFunctions',True])
279 __argumentsList.append(['Script',__idata['SCRIPTWITHFUNCTIONS_DATA'].pop('SCRIPTWITHFUNCTIONS_FILE')])
280 if len(__idata['SCRIPTWITHFUNCTIONS_DATA'])>0:
281 __argumentsList.append(['Parameters',__idata['SCRIPTWITHFUNCTIONS_DATA']])
282 __arguments = ["%s = %s"%(k,repr(v)) for k,v in __argumentsList]
283 __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments)))
285 # ----------------------------------------------------------------------
286 __commands.sort() # Pour commencer par 'AlgorithmParameters'
287 __commands.append(__UserPostAnalysis)
290 class _DCTViewer(GenericCaseViewer):
292 Etablissement des commandes d'un cas DCT (Cas<->DCT)
294 def __init__(self, __name="", __objname="case", __content=None, __object=None):
295 "Initialisation et enregistrement de l'entete"
296 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
297 self._observerIndex = 0
298 self._addLine("# -*- coding: utf-8 -*-")
299 self._addLine("#\n# Python script for ADAO DCT\n#")
300 self._addLine("from numpy import array, matrix")
302 self._addLine("%s = {}"%__objname)
303 if self._content is not None:
304 for command in self._content:
305 self._append(*command)
306 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
307 "Transformation d'une commande individuelle en un enregistrement"
308 if __command is not None and __keys is not None and __local is not None:
310 if "execute" in __command: return
311 if "self" in __keys: __keys.remove("self")
312 if __command in ("set","get") and "Concept" in __keys:
313 __key = __local["Concept"]
314 __keys.remove("Concept")
316 __key = __command.replace("set","").replace("get","")
317 if "Observer" in __key and 'Variable' in __keys:
318 self._observerIndex += 1
319 __key += "_%i"%self._observerIndex
320 __text += "%s['%s'] = {"%(self._objname,str(__key))
323 if __v is None: continue
324 if k == "Checked" and not __v: continue
325 if k == "Stored" and not __v: continue
326 if k == "AvoidRC" and __v: continue
327 if k == "noDetails": continue
328 if isinstance(__v,Persistence.Persistence): __v = __v.values()
329 if callable(__v): __text = self._missing%__v.__name__+__text
330 if isinstance(__v,dict):
331 for val in __v.values():
332 if callable(val): __text = self._missing%val.__name__+__text
333 numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
334 __text += "'%s':%s, "%(k,repr(__v))
335 numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
336 __text.rstrip(", ").rstrip()
338 if __text[-2:] == "{}": return # Supprime les *Debug et les variables
339 self._addLine(__text)
340 def _extract(self, __multilines="", __object=None):
341 "Transformation un enregistrement en une commande individuelle"
343 __multilines = __multilines.replace("\r\n","\n")
346 __getlocals = locals()
347 for k in __getlocals:
349 if 'AlgorithmParameters' in __getlocals[k] and type(__getlocals[k]) is dict:
351 self._objdata = __getlocals[k]
354 if self._objdata is None:
355 raise ValueError("Impossible to load given content as a ADAO DCT one (no 'AlgorithmParameters' key found).")
356 for k in self._objdata:
358 __command = k.split('_',1)[0]
361 __arguments = ["%s = %s"%(k,repr(v)) for k,v in self._objdata[k].items()]
362 __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments)))
363 __commands.sort() # Pour commencer par 'AlgorithmParameters'
366 class _SCDViewer(GenericCaseViewer):
368 Etablissement des commandes d'un cas SCD (Study Config Dictionary/Cas->SCD)
370 def __init__(self, __name="", __objname="case", __content=None, __object=None):
371 "Initialisation et enregistrement de l'entete"
372 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
373 self._addLine("# -*- coding: utf-8 -*-")
374 self._addLine("#\n# Input for ADAO converter to YACS\n#")
375 self._addLine("from numpy import array, matrix")
377 self._addLine("study_config = {}")
378 self._addLine("study_config['StudyType'] = 'ASSIMILATION_STUDY'")
379 self._addLine("study_config['Name'] = '%s'"%self._name)
380 self._addLine("observers = {}")
381 self._addLine("study_config['Observers'] = observers")
383 self._addLine("inputvariables_config = {}")
384 self._addLine("inputvariables_config['Order'] =['adao_default']")
385 self._addLine("inputvariables_config['adao_default'] = -1")
386 self._addLine("study_config['InputVariables'] = inputvariables_config")
388 self._addLine("outputvariables_config = {}")
389 self._addLine("outputvariables_config['Order'] = ['adao_default']")
390 self._addLine("outputvariables_config['adao_default'] = -1")
391 self._addLine("study_config['OutputVariables'] = outputvariables_config")
392 if __content is not None:
393 for command in __content:
394 self._append(*command)
395 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
396 "Transformation d'une commande individuelle en un enregistrement"
397 if __command == "set": __command = __local["Concept"]
398 else: __command = __command.replace("set", "", 1)
401 if __command in (None, 'execute', 'executePythonScheme', 'executeYACSScheme', 'get', 'Name'):
403 elif __command in ['Debug', 'setDebug']:
404 __text = "#\nstudy_config['Debug'] = '1'"
405 elif __command in ['NoDebug', 'setNoDebug']:
406 __text = "#\nstudy_config['Debug'] = '0'"
407 elif __command in ['Observer', 'setObserver']:
408 __obs = __local['Variable']
409 self._numobservers += 1
411 __text += "observers['%s'] = {}\n"%__obs
412 if __local['String'] is not None:
413 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
414 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, __local['String'])
415 if __local['Script'] is not None:
416 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'Script')
417 __text += "observers['%s']['Script'] = \"%s\"\n"%(__obs, __local['Script'])
418 if __local['Template'] is not None and __local['Template'] in Templates.ObserverTemplates:
419 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
420 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, Templates.ObserverTemplates[__local['Template']])
421 if __local['Info'] is not None:
422 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __local['Info'])
424 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __obs)
425 __text += "observers['%s']['number'] = %s"%(__obs, self._numobservers)
426 elif __local is not None: # __keys is not None and
427 numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
429 __text += "%s_config = {}\n"%__command
430 if 'self' in __local: __local.pop('self')
432 for __k,__v in __local.items():
433 if __v is None: __to_be_removed.append(__k)
434 for __k in __to_be_removed:
436 for __k,__v in __local.items():
437 if __k == "Concept": continue
438 if __k in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix','OneFunction','ThreeFunctions'] and 'Script' in __local: continue
439 if __k == 'Algorithm':
440 __text += "study_config['Algorithm'] = %s\n"%(repr(__v))
441 elif __k == 'Script':
444 __v = "'"+repr(__v)+"'"
445 for __lk in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix']:
446 if __lk in __local and __local[__lk]: __k = __lk
447 if __command == "AlgorithmParameters": __k = "Dict"
448 if 'OneFunction' in __local and __local['OneFunction']:
449 __text += "%s_ScriptWithOneFunction = {}\n"%(__command,)
450 __text += "%s_ScriptWithOneFunction['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
451 __text += "%s_ScriptWithOneFunction['Script'] = {}\n"%(__command,)
452 __text += "%s_ScriptWithOneFunction['Script']['Direct'] = %s\n"%(__command,__v)
453 __text += "%s_ScriptWithOneFunction['Script']['Tangent'] = %s\n"%(__command,__v)
454 __text += "%s_ScriptWithOneFunction['Script']['Adjoint'] = %s\n"%(__command,__v)
455 __text += "%s_ScriptWithOneFunction['DifferentialIncrement'] = 1e-06\n"%(__command,)
456 __text += "%s_ScriptWithOneFunction['CenteredFiniteDifference'] = 0\n"%(__command,)
458 __f = 'ScriptWithOneFunction'
459 __v = '%s_ScriptWithOneFunction'%(__command,)
460 if 'ThreeFunctions' in __local and __local['ThreeFunctions']:
461 __text += "%s_ScriptWithFunctions = {}\n"%(__command,)
462 __text += "%s_ScriptWithFunctions['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
463 __text += "%s_ScriptWithFunctions['Script'] = {}\n"%(__command,)
464 __text += "%s_ScriptWithFunctions['Script']['Direct'] = %s\n"%(__command,__v)
465 __text += "%s_ScriptWithFunctions['Script']['Tangent'] = %s\n"%(__command,__v)
466 __text += "%s_ScriptWithFunctions['Script']['Adjoint'] = %s\n"%(__command,__v)
468 __f = 'ScriptWithFunctions'
469 __v = '%s_ScriptWithFunctions'%(__command,)
470 __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
471 __text += "%s_config['From'] = '%s'\n"%(__command,__f)
472 __text += "%s_config['Data'] = %s\n"%(__command,__v)
473 __text = __text.replace("''","'")
474 elif __k in ('Stored', 'Checked'):
476 __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
477 elif __k in ('AvoidRC', 'noDetails'):
479 __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
481 if __k == 'Parameters': __k = "Dict"
482 if isinstance(__v,Persistence.Persistence): __v = __v.values()
483 if callable(__v): __text = self._missing%__v.__name__+__text
484 if isinstance(__v,dict):
485 for val in __v.values():
486 if callable(val): __text = self._missing%val.__name__+__text
487 __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
488 __text += "%s_config['From'] = '%s'\n"%(__command,'String')
489 __text += "%s_config['Data'] = \"\"\"%s\"\"\"\n"%(__command,repr(__v))
490 __text += "study_config['%s'] = %s_config"%(__command,__command)
491 numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
493 self._switchoff = True
494 if __text is not None: self._addLine(__text)
496 self._switchoff = False
497 def _finalize(self, *__args):
498 self.__loadVariablesByScript()
500 self._addLine("Analysis_config = {}")
501 self._addLine("Analysis_config['From'] = 'String'")
502 self._addLine("Analysis_config['Data'] = \"\"\"import numpy")
503 self._addLine("xa=numpy.ravel(ADD.get('Analysis')[-1])")
504 self._addLine("print 'Analysis:',xa\"\"\"")
505 self._addLine("study_config['UserPostAnalysis'] = Analysis_config")
506 def __loadVariablesByScript(self):
507 __ExecVariables = {} # Necessaire pour recuperer la variable
508 exec("\n".join(self._lineSerie), __ExecVariables)
509 study_config = __ExecVariables['study_config']
510 # Pour Python 3 : self.__hasAlgorithm = bool(study_config['Algorithm'])
511 if 'Algorithm' in study_config:
512 self.__hasAlgorithm = True
514 self.__hasAlgorithm = False
515 if not self.__hasAlgorithm and \
516 "AlgorithmParameters" in study_config and \
517 isinstance(study_config['AlgorithmParameters'], dict) and \
518 "From" in study_config['AlgorithmParameters'] and \
519 "Data" in study_config['AlgorithmParameters'] and \
520 study_config['AlgorithmParameters']['From'] == 'Script':
521 __asScript = study_config['AlgorithmParameters']['Data']
522 __var = ImportFromScript(__asScript).getvalue( "Algorithm" )
523 __text = "#\nstudy_config['Algorithm'] = '%s'"%(__var,)
524 self._addLine(__text)
525 if self.__hasAlgorithm and \
526 "AlgorithmParameters" in study_config and \
527 isinstance(study_config['AlgorithmParameters'], dict) and \
528 "From" not in study_config['AlgorithmParameters'] and \
529 "Data" not in study_config['AlgorithmParameters']:
531 __text += "AlgorithmParameters_config['Type'] = 'Dict'\n"
532 __text += "AlgorithmParameters_config['From'] = 'String'\n"
533 __text += "AlgorithmParameters_config['Data'] = '{}'\n"
534 self._addLine(__text)
537 class _XMLViewer(GenericCaseViewer):
539 Etablissement des commandes d'un cas XML
541 def __init__(self, __name="", __objname="case", __content=None, __object=None):
542 "Initialisation et enregistrement de l'entete"
543 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
544 raise NotImplementedError()
546 class _YACSViewer(GenericCaseViewer):
548 Etablissement des commandes d'un cas YACS (Cas->SCD->YACS)
550 def __init__(self, __name="", __objname="case", __content=None, __object=None):
551 "Initialisation et enregistrement de l'entete"
552 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
553 self.__internalSCD = _SCDViewer(__name, __objname, __content, __object)
554 self._append = self.__internalSCD._append
555 def dump(self, __filename=None, __convertSCDinMemory=True):
556 "Restitution normalisée des commandes"
557 self.__internalSCD._finalize()
559 if __filename is None:
560 raise ValueError("A file name has to be given for YACS XML output.")
562 if not PlatformInfo.has_salome or \
563 not PlatformInfo.has_adao:
564 raise ImportError("\n\n"+\
565 "Unable to get SALOME or ADAO environnement variables.\n"+\
566 "Please load the right environnement before trying to use it.\n")
567 elif __convertSCDinMemory:
568 __file = os.path.abspath(__filename)
569 __SCDdump = self.__internalSCD.dump()
570 if os.path.isfile(__file) or os.path.islink(__file):
572 from daYacsSchemaCreator.run import create_schema_from_content
573 create_schema_from_content(__SCDdump, __file)
575 __file = os.path.abspath(__filename)
576 __SCDfile = __file[:__file.rfind(".")] + '_SCD.py'
577 __SCDdump = self.__internalSCD.dump(__SCDfile)
578 if os.path.isfile(__file) or os.path.islink(__file):
580 __converterExe = os.path.join(os.environ["ADAO_ROOT_DIR"], "bin/salome", "AdaoYacsSchemaCreator.py")
581 __args = ["python", __converterExe, __SCDfile, __file]
583 __p = subprocess.Popen(__args)
584 (__stdoutdata, __stderrdata) = __p.communicate()
588 if not os.path.exists(__file):
589 __msg = "An error occured during the ADAO YACS Schema build for\n"
590 __msg += "the target output file:\n"
591 __msg += " %s\n"%__file
592 __msg += "See errors details in your launching terminal log.\n"
593 raise ValueError(__msg)
595 __fid = open(__file,"r")
596 __text = __fid.read()
600 class ImportFromScript(object):
602 Obtention d'une variable nommee depuis un fichier script importe
604 def __init__(self, __filename=None):
605 "Verifie l'existence et importe le script"
606 if __filename is None:
607 raise ValueError("The name of the file, containing the variable to be read, has to be specified.")
608 if not os.path.isfile(__filename):
609 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\""%__filename)
610 if os.path.dirname(__filename) != '':
611 sys.path.insert(0, os.path.dirname(__filename))
612 __basename = os.path.basename(__filename).rstrip(".py")
614 __basename = __filename.rstrip(".py")
615 self.__basename = __basename
616 self.__scriptfile = __import__(__basename, globals(), locals(), [])
617 self.__scriptstring = open(__filename,'r').read()
618 def getvalue(self, __varname=None, __synonym=None ):
619 "Renvoie la variable demandee"
620 if __varname is None:
621 raise ValueError("The name of the variable to be read has to be specified. Please check the content of the file and the syntax.")
622 if not hasattr(self.__scriptfile, __varname):
623 if __synonym is None:
624 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))
625 elif not hasattr(self.__scriptfile, __synonym):
626 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))
628 return getattr(self.__scriptfile, __synonym)
630 return getattr(self.__scriptfile, __varname)
632 "Renvoie le script complet"
633 return self.__scriptstring
635 # ==============================================================================
636 if __name__ == "__main__":
637 print('\n AUTODIAGNOSTIC \n')