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 using 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 using 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 an 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 using 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"
342 __multilines = __multilines.replace("\r\n","\n")
345 __getlocals = locals()
346 for k in __getlocals:
348 if 'AlgorithmParameters' in __getlocals[k] and type(__getlocals[k]) is dict:
350 self._objdata = __getlocals[k]
353 if self._objdata is None:
354 raise ValueError("Impossible to load given content as an ADAO DCT one (no 'AlgorithmParameters' key found).")
355 # ----------------------------------------------------------------------
356 logging.debug("DCT Extracting commands of '%s' object..."%(self._objname,))
358 for k in self._objdata:
360 __command = k.split('_',1)[0]
363 __arguments = ["%s = %s"%(k,repr(v)) for k,v in self._objdata[k].items()]
364 __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments)))
365 __commands.sort() # Pour commencer par 'AlgorithmParameters'
368 class _SCDViewer(GenericCaseViewer):
370 Etablissement des commandes d'un cas SCD (Study Config Dictionary/Cas->SCD)
372 def __init__(self, __name="", __objname="case", __content=None, __object=None):
373 "Initialisation et enregistrement de l'entete"
374 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
375 self._addLine("# -*- coding: utf-8 -*-")
376 self._addLine("#\n# Input for ADAO converter to YACS\n#")
377 self._addLine("from numpy import array, matrix")
379 self._addLine("study_config = {}")
380 self._addLine("study_config['StudyType'] = 'ASSIMILATION_STUDY'")
381 self._addLine("study_config['Name'] = '%s'"%self._name)
382 self._addLine("observers = {}")
383 self._addLine("study_config['Observers'] = observers")
385 self._addLine("inputvariables_config = {}")
386 self._addLine("inputvariables_config['Order'] =['adao_default']")
387 self._addLine("inputvariables_config['adao_default'] = -1")
388 self._addLine("study_config['InputVariables'] = inputvariables_config")
390 self._addLine("outputvariables_config = {}")
391 self._addLine("outputvariables_config['Order'] = ['adao_default']")
392 self._addLine("outputvariables_config['adao_default'] = -1")
393 self._addLine("study_config['OutputVariables'] = outputvariables_config")
394 if __content is not None:
395 for command in __content:
396 self._append(*command)
397 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
398 "Transformation d'une commande individuelle en un enregistrement"
399 if __command == "set": __command = __local["Concept"]
400 else: __command = __command.replace("set", "", 1)
403 if __command in (None, 'execute', 'executePythonScheme', 'executeYACSScheme', 'get', 'Name'):
405 elif __command in ['Debug', 'setDebug']:
406 __text = "#\nstudy_config['Debug'] = '1'"
407 elif __command in ['NoDebug', 'setNoDebug']:
408 __text = "#\nstudy_config['Debug'] = '0'"
409 elif __command in ['Observer', 'setObserver']:
410 __obs = __local['Variable']
411 self._numobservers += 1
413 __text += "observers['%s'] = {}\n"%__obs
414 if __local['String'] is not None:
415 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
416 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, __local['String'])
417 if __local['Script'] is not None:
418 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'Script')
419 __text += "observers['%s']['Script'] = \"%s\"\n"%(__obs, __local['Script'])
420 if __local['Template'] is not None and __local['Template'] in Templates.ObserverTemplates:
421 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
422 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, Templates.ObserverTemplates[__local['Template']])
423 if __local['Info'] is not None:
424 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __local['Info'])
426 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __obs)
427 __text += "observers['%s']['number'] = %s"%(__obs, self._numobservers)
428 elif __local is not None: # __keys is not None and
429 numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
431 __text += "%s_config = {}\n"%__command
432 if 'self' in __local: __local.pop('self')
434 for __k,__v in __local.items():
435 if __v is None: __to_be_removed.append(__k)
436 for __k in __to_be_removed:
438 for __k,__v in __local.items():
439 if __k == "Concept": continue
440 if __k in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix','OneFunction','ThreeFunctions'] and 'Script' in __local: continue
441 if __k == 'Algorithm':
442 __text += "study_config['Algorithm'] = %s\n"%(repr(__v))
443 elif __k == 'Script':
446 __v = "'"+repr(__v)+"'"
447 for __lk in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix']:
448 if __lk in __local and __local[__lk]: __k = __lk
449 if __command == "AlgorithmParameters": __k = "Dict"
450 if 'OneFunction' in __local and __local['OneFunction']:
451 __text += "%s_ScriptWithOneFunction = {}\n"%(__command,)
452 __text += "%s_ScriptWithOneFunction['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
453 __text += "%s_ScriptWithOneFunction['Script'] = {}\n"%(__command,)
454 __text += "%s_ScriptWithOneFunction['Script']['Direct'] = %s\n"%(__command,__v)
455 __text += "%s_ScriptWithOneFunction['Script']['Tangent'] = %s\n"%(__command,__v)
456 __text += "%s_ScriptWithOneFunction['Script']['Adjoint'] = %s\n"%(__command,__v)
457 __text += "%s_ScriptWithOneFunction['DifferentialIncrement'] = 1e-06\n"%(__command,)
458 __text += "%s_ScriptWithOneFunction['CenteredFiniteDifference'] = 0\n"%(__command,)
460 __f = 'ScriptWithOneFunction'
461 __v = '%s_ScriptWithOneFunction'%(__command,)
462 if 'ThreeFunctions' in __local and __local['ThreeFunctions']:
463 __text += "%s_ScriptWithFunctions = {}\n"%(__command,)
464 __text += "%s_ScriptWithFunctions['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
465 __text += "%s_ScriptWithFunctions['Script'] = {}\n"%(__command,)
466 __text += "%s_ScriptWithFunctions['Script']['Direct'] = %s\n"%(__command,__v)
467 __text += "%s_ScriptWithFunctions['Script']['Tangent'] = %s\n"%(__command,__v)
468 __text += "%s_ScriptWithFunctions['Script']['Adjoint'] = %s\n"%(__command,__v)
470 __f = 'ScriptWithFunctions'
471 __v = '%s_ScriptWithFunctions'%(__command,)
472 __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
473 __text += "%s_config['From'] = '%s'\n"%(__command,__f)
474 __text += "%s_config['Data'] = %s\n"%(__command,__v)
475 __text = __text.replace("''","'")
476 elif __k in ('Stored', 'Checked'):
478 __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
479 elif __k in ('AvoidRC', 'noDetails'):
481 __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
483 if __k == 'Parameters': __k = "Dict"
484 if isinstance(__v,Persistence.Persistence): __v = __v.values()
485 if callable(__v): __text = self._missing%__v.__name__+__text
486 if isinstance(__v,dict):
487 for val in __v.values():
488 if callable(val): __text = self._missing%val.__name__+__text
489 __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
490 __text += "%s_config['From'] = '%s'\n"%(__command,'String')
491 __text += "%s_config['Data'] = \"\"\"%s\"\"\"\n"%(__command,repr(__v))
492 __text += "study_config['%s'] = %s_config"%(__command,__command)
493 numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
495 self._switchoff = True
496 if __text is not None: self._addLine(__text)
498 self._switchoff = False
499 def _finalize(self, *__args):
500 self.__loadVariablesByScript()
502 self._addLine("Analysis_config = {}")
503 self._addLine("Analysis_config['From'] = 'String'")
504 self._addLine("Analysis_config['Data'] = \"\"\"import numpy")
505 self._addLine("xa=numpy.ravel(ADD.get('Analysis')[-1])")
506 self._addLine("print 'Analysis:',xa\"\"\"")
507 self._addLine("study_config['UserPostAnalysis'] = Analysis_config")
508 def __loadVariablesByScript(self):
509 __ExecVariables = {} # Necessaire pour recuperer la variable
510 exec("\n".join(self._lineSerie), __ExecVariables)
511 study_config = __ExecVariables['study_config']
512 # Pour Python 3 : self.__hasAlgorithm = bool(study_config['Algorithm'])
513 if 'Algorithm' in study_config:
514 self.__hasAlgorithm = True
516 self.__hasAlgorithm = False
517 if not self.__hasAlgorithm and \
518 "AlgorithmParameters" in study_config and \
519 isinstance(study_config['AlgorithmParameters'], dict) and \
520 "From" in study_config['AlgorithmParameters'] and \
521 "Data" in study_config['AlgorithmParameters'] and \
522 study_config['AlgorithmParameters']['From'] == 'Script':
523 __asScript = study_config['AlgorithmParameters']['Data']
524 __var = ImportFromScript(__asScript).getvalue( "Algorithm" )
525 __text = "#\nstudy_config['Algorithm'] = '%s'"%(__var,)
526 self._addLine(__text)
527 if self.__hasAlgorithm and \
528 "AlgorithmParameters" in study_config and \
529 isinstance(study_config['AlgorithmParameters'], dict) and \
530 "From" not in study_config['AlgorithmParameters'] and \
531 "Data" not in study_config['AlgorithmParameters']:
533 __text += "AlgorithmParameters_config['Type'] = 'Dict'\n"
534 __text += "AlgorithmParameters_config['From'] = 'String'\n"
535 __text += "AlgorithmParameters_config['Data'] = '{}'\n"
536 self._addLine(__text)
539 class _XMLViewer(GenericCaseViewer):
541 Etablissement des commandes d'un cas XML
543 def __init__(self, __name="", __objname="case", __content=None, __object=None):
544 "Initialisation et enregistrement de l'entete"
545 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
546 raise NotImplementedError()
548 class _YACSViewer(GenericCaseViewer):
550 Etablissement des commandes d'un cas YACS (Cas->SCD->YACS)
552 def __init__(self, __name="", __objname="case", __content=None, __object=None):
553 "Initialisation et enregistrement de l'entete"
554 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
555 self.__internalSCD = _SCDViewer(__name, __objname, __content, __object)
556 self._append = self.__internalSCD._append
557 def dump(self, __filename=None, __convertSCDinMemory=True):
558 "Restitution normalisée des commandes"
559 self.__internalSCD._finalize()
561 if __filename is None:
562 raise ValueError("A file name has to be given for YACS XML output.")
564 if not PlatformInfo.has_salome or \
565 not PlatformInfo.has_adao:
566 raise ImportError("\n\n"+\
567 "Unable to get SALOME or ADAO environnement variables.\n"+\
568 "Please load the right environnement before trying to use it.\n")
569 elif __convertSCDinMemory:
570 __file = os.path.abspath(__filename)
571 __SCDdump = self.__internalSCD.dump()
572 if os.path.isfile(__file) or os.path.islink(__file):
574 from daYacsSchemaCreator.run import create_schema_from_content
575 create_schema_from_content(__SCDdump, __file)
577 __file = os.path.abspath(__filename)
578 __SCDfile = __file[:__file.rfind(".")] + '_SCD.py'
579 __SCDdump = self.__internalSCD.dump(__SCDfile)
580 if os.path.isfile(__file) or os.path.islink(__file):
582 __converterExe = os.path.join(os.environ["ADAO_ROOT_DIR"], "bin/salome", "AdaoYacsSchemaCreator.py")
583 __args = ["python", __converterExe, __SCDfile, __file]
585 __p = subprocess.Popen(__args)
586 (__stdoutdata, __stderrdata) = __p.communicate()
590 if not os.path.exists(__file):
591 __msg = "An error occured during the ADAO YACS Schema build for\n"
592 __msg += "the target output file:\n"
593 __msg += " %s\n"%__file
594 __msg += "See errors details in your launching terminal log.\n"
595 raise ValueError(__msg)
597 __fid = open(__file,"r")
598 __text = __fid.read()
602 class ImportFromScript(object):
604 Obtention d'une variable nommee depuis un fichier script importe
606 def __init__(self, __filename=None):
607 "Verifie l'existence et importe le script"
608 if __filename is None:
609 raise ValueError("The name of the file, containing the variable to be read, has to be specified.")
610 if not os.path.isfile(__filename):
611 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)
612 if os.path.dirname(__filename) != '':
613 sys.path.insert(0, os.path.dirname(__filename))
614 __basename = os.path.basename(__filename).rstrip(".py")
616 __basename = __filename.rstrip(".py")
617 self.__basename = __basename
618 self.__scriptfile = __import__(__basename, globals(), locals(), [])
619 self.__scriptstring = open(__filename,'r').read()
620 def getvalue(self, __varname=None, __synonym=None ):
621 "Renvoie la variable demandee"
622 if __varname is None:
623 raise ValueError("The name of the variable to be read has to be specified. Please check the content of the file and the syntax.")
624 if not hasattr(self.__scriptfile, __varname):
625 if __synonym is None:
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",__varname))
627 elif not hasattr(self.__scriptfile, __synonym):
628 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))
630 return getattr(self.__scriptfile, __synonym)
632 return getattr(self.__scriptfile, __varname)
634 "Renvoie le script complet"
635 return self.__scriptstring
637 # ==============================================================================
638 if __name__ == "__main__":
639 print('\n AUTODIAGNOSTIC \n')