src/daComposant/daCore/Interfaces.py

   1 # -*- coding: utf-8 -*-
   2 #
   3 # Copyright (C) 2008-2018 EDF R&D
   4 #
   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.
   9 #
  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.
  14 #
  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
  18 #
  19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  20 #
  21 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
  22
  23 """
  24     Définit les outils d'interfaces normalisées de cas.
  25 """
  26 __author__ = "Jean-Philippe ARGAUD"
  27 __all__ = []
  28
  29 import os
  30 import sys
  31 import logging
  32 import copy
  33 import numpy
  34 from daCore import Persistence
  35 from daCore import PlatformInfo
  36 from daCore import Templates
  37
  38 # ==============================================================================
  39 class GenericCaseViewer(object):
  40     """
  41     Gestion des commandes de creation d'une vue de cas
  42     """
  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)
  47         self._lineSerie    = []
  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):
  68         return self._objname
  69     def dump(self, __filename=None, __upa=None):
  70         "Restitution normalisée des commandes"
  71         self._finalize(__upa)
  72         __text = "\n".join(self._lineSerie)
  73         __text +="\n"
  74         if __filename is not None:
  75             __file = os.path.abspath(__filename)
  76             __fid = open(__file,"w")
  77             __fid.write(__text)
  78             __fid.close()
  79         return __text
  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)
  88         else:
  89             pass # use "self._content" from initialization
  90         __commands = self._extract(self._content, self._object)
  91         return __commands
  92
  93 class _TUIViewer(GenericCaseViewer):
  94     """
  95     Etablissement des commandes d'un cas ADAO TUI (Cas<->TUI)
  96     """
  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:
 111             __text  = ""
 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")
 117             for k in __keys:
 118                 __v = __local[k]
 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)
 132             __text.rstrip(", ")
 133             __text += ")"
 134             self._addLine(__text)
 135     def _extract(self, __multilines="", __object=None):
 136         "Transformation un enregistrement en une commande individuelle"
 137         __is_case = False
 138         __commands = []
 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()
 143                 __is_case = True
 144                 logging.debug("TUI Extracting commands of '%s' object..."%(self._objname,))
 145             if not __is_case:
 146                 continue
 147             else:
 148                 if self._objname+".set" in line:
 149                     __commands.append( line.replace(self._objname+".","",1) )
 150                     logging.debug("TUI Extracted command: %s"%(__commands[-1],))
 151         return __commands
 152
 153 class _EPDViewer(GenericCaseViewer):
 154     """
 155     Etablissement des commandes d'un cas EPD (Eficas Python Dictionnary/Cas<-EPD)
 156     """
 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")
 164         self._addLine("#")
 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")
 173             exec(__multilines)
 174             self._objdata = None
 175             __getlocals = locals()
 176             for k in __getlocals:
 177                 try:
 178                     if type(__getlocals[k]) is dict:
 179                         if 'ASSIMILATION_STUDY' in __getlocals[k]:
 180                             self._objname = k
 181                             self._objdata = __getlocals[k]['ASSIMILATION_STUDY']
 182                         if 'CHECKING_STUDY' in __getlocals[k]:
 183                             self._objname = k
 184                             self._objdata = __getlocals[k]['CHECKING_STUDY']
 185                 except:
 186                     continue
 187         elif __multilines is None and __object is not None and type(__object) is dict:
 188             self._objname = "case"
 189             self._objdata = None
 190             if 'ASSIMILATION_STUDY' in __object:
 191                 self._objdata = __object['ASSIMILATION_STUDY']
 192             if 'CHECKING_STUDY' in __object:
 193                 self._objdata = __object['CHECKING_STUDY']
 194         else:
 195             self._objdata = None
 196         #
 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,))
 201         __commands = []
 202         __UserPostAnalysis = ""
 203         for k,r in self._objdata.items():
 204             __command = k
 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),) )
 210             #
 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:
 217                     # AnalysisPrinter...
 218                     __itempl = r['TEMPLATE_DATA']['Template']
 219                     __UserPostAnalysis = r['TEMPLATE_DATA'][__itempl]['ValueTemplate']
 220                 else:
 221                     __UserPostAnalysis = ""
 222                 __UserPostAnalysis = __UserPostAnalysis.replace("ADD",self._objname)
 223             #
 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'],)
 237                 else:
 238                     __parameters = ""
 239                 __commands.append( "set( Concept='AlgorithmParameters', Algorithm='%s'%s )"%(r['Algorithm'],__parameters) )
 240             #
 241             elif __command == "Observers" and type(r) is dict and 'SELECTION' in r:
 242                 if type(r['SELECTION']) is str:
 243                     __selection = (r['SELECTION'],)
 244                 else:
 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) )
 254             #
 255             # Background, ObservationError, ObservationOperator...
 256             elif type(r) is dict:
 257                 __argumentsList = []
 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)))
 284         #
 285         # ----------------------------------------------------------------------
 286         __commands.sort() # Pour commencer par 'AlgorithmParameters'
 287         __commands.append(__UserPostAnalysis)
 288         return __commands
 289
 290 class _DCTViewer(GenericCaseViewer):
 291     """
 292     Etablissement des commandes d'un cas DCT (Cas<->DCT)
 293     """
 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")
 301         self._addLine("#")
 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:
 309             __text  = ""
 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")
 315             else:
 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))
 321             for k in __keys:
 322                 __v = __local[k]
 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()
 337             __text += "}"
 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         __commands = []
 343         __multilines = __multilines.replace("\r\n","\n")
 344         exec(__multilines)
 345         self._objdata = None
 346         __getlocals = locals()
 347         for k in __getlocals:
 348             try:
 349                 if 'AlgorithmParameters' in __getlocals[k] and type(__getlocals[k]) is dict:
 350                     self._objname = k
 351                     self._objdata = __getlocals[k]
 352             except:
 353                 continue
 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:
 357             if 'Observer_' in k:
 358                 __command = k.split('_',1)[0]
 359             else:
 360                 __command = k
 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'
 364         return __commands
 365
 366 class _SCDViewer(GenericCaseViewer):
 367     """
 368     Etablissement des commandes d'un cas SCD (Study Config Dictionary/Cas->SCD)
 369     """
 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")
 376         self._addLine("#")
 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")
 382         self._addLine("#")
 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")
 387         self._addLine("#")
 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)
 399         #
 400         __text  = None
 401         if __command in (None, 'execute', 'executePythonScheme', 'executeYACSScheme', 'get', 'Name'):
 402             return
 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
 410             __text  = "#\n"
 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'])
 423             else:
 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)
 428             __text  = "#\n"
 429             __text += "%s_config = {}\n"%__command
 430             if 'self' in __local: __local.pop('self')
 431             __to_be_removed = []
 432             for __k,__v in __local.items():
 433                 if __v is None: __to_be_removed.append(__k)
 434             for __k in __to_be_removed:
 435                 __local.pop(__k)
 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':
 442                     __k = 'Vector'
 443                     __f = '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,)
 457                         __k = 'Function'
 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)
 467                         __k = 'Function'
 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'):
 475                     if bool(__v):
 476                         __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
 477                 elif __k in ('AvoidRC', 'noDetails'):
 478                     if not bool(__v):
 479                         __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
 480                 else:
 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)
 492             if __switchoff:
 493                 self._switchoff = True
 494         if __text is not None: self._addLine(__text)
 495         if not __switchoff:
 496             self._switchoff = False
 497     def _finalize(self, *__args):
 498         self.__loadVariablesByScript()
 499         self._addLine("#")
 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
 513         else:
 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']:
 530             __text  = "#\n"
 531             __text += "AlgorithmParameters_config['Type'] = 'Dict'\n"
 532             __text += "AlgorithmParameters_config['From'] = 'String'\n"
 533             __text += "AlgorithmParameters_config['Data'] = '{}'\n"
 534             self._addLine(__text)
 535         del study_config
 536
 537 class _XMLViewer(GenericCaseViewer):
 538     """
 539     Etablissement des commandes d'un cas XML
 540     """
 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()
 545
 546 class _YACSViewer(GenericCaseViewer):
 547     """
 548     Etablissement des commandes d'un cas YACS (Cas->SCD->YACS)
 549     """
 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()
 558         # -----
 559         if __filename is None:
 560             raise ValueError("A file name has to be given for YACS XML output.")
 561         # -----
 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):
 571                 os.remove(__file)
 572             from daYacsSchemaCreator.run import create_schema_from_content
 573             create_schema_from_content(__SCDdump, __file)
 574         else:
 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):
 579                 os.remove(__file)
 580             __converterExe = os.path.join(os.environ["ADAO_ROOT_DIR"], "bin/salome", "AdaoYacsSchemaCreator.py")
 581             __args = ["python", __converterExe, __SCDfile, __file]
 582             import subprocess
 583             __p = subprocess.Popen(__args)
 584             (__stdoutdata, __stderrdata) = __p.communicate()
 585             __p.terminate()
 586             os.remove(__SCDfile)
 587         # -----
 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)
 594         # -----
 595         __fid = open(__file,"r")
 596         __text = __fid.read()
 597         __fid.close()
 598         return __text
 599
 600 class ImportFromScript(object):
 601     """
 602     Obtention d'une variable nommee depuis un fichier script importe
 603     """
 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")
 613         else:
 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))
 627             else:
 628                 return getattr(self.__scriptfile, __synonym)
 629         else:
 630             return getattr(self.__scriptfile, __varname)
 631     def getstring(self):
 632         "Renvoie le script complet"
 633         return self.__scriptstring
 634
 635 # ==============================================================================
 636 if __name__ == "__main__":
 637     print('\n AUTODIAGNOSTIC \n')