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 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:
 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 _COMViewer(GenericCaseViewer):
 154     """
 155     Etablissement des commandes d'un cas COMM (Eficas Native Format/Cas<-COM)
 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 using ADAO COMM\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("ASSIMILATION_STUDY","dict")
 173             __multilines = __multilines.replace("CHECKING_STUDY",    "dict")
 174             __multilines = __multilines.replace("_F(",               "dict(")
 175             __multilines = __multilines.replace(",),);",             ",),)")
 176         __fulllines = ""
 177         for line in __multilines.split("\n"):
 178             if len(line) < 1: continue
 179             __fulllines += line + "\n"
 180         __multilines = __fulllines
 181         self._objname = "case"
 182         self._objdata = None
 183         exec("self._objdata = "+__multilines)
 184         #
 185         if self._objdata is None or not(type(self._objdata) is dict) or not('AlgorithmParameters' in self._objdata):
 186             raise ValueError("Impossible to load given content as an ADAO COMM one (no dictionnary or no 'AlgorithmParameters' key found).")
 187         # ----------------------------------------------------------------------
 188         logging.debug("COMM Extracting commands of '%s' object..."%(self._objname,))
 189         __commands = []
 190         __UserPostAnalysis = ""
 191         for k,r in self._objdata.items():
 192             __command = k
 193             logging.debug("COMM Extracted command: %s:%s"%(k, r))
 194             if   __command == "StudyName" and len(str(r))>0:
 195                 __commands.append( "set( Concept='Name', String='%s')"%(str(r),) )
 196             elif   __command == "StudyRepertory":
 197                 __commands.append( "set( Concept='Directory', String='%s')"%(str(r),) )
 198             #
 199             elif __command == "UserPostAnalysis" and type(r) is dict:
 200                 if 'STRING' in r:
 201                     __UserPostAnalysis = r['STRING']
 202                 elif 'SCRIPT_FILE' in r and os.path.exists(r['SCRIPT_FILE']):
 203                     __UserPostAnalysis = open(r['SCRIPT_FILE'],'r').read()
 204                 elif 'Template' in r and 'ValueTemplate' in r:
 205                     # AnalysisPrinter...
 206                     __UserPostAnalysis = r['ValueTemplate']
 207                 else:
 208                     __UserPostAnalysis = ""
 209                 __UserPostAnalysis = __UserPostAnalysis.replace("ADD",self._objname)
 210             #
 211             elif __command == "AlgorithmParameters" and type(r) is dict and 'Algorithm' in r:
 212                 if 'data' in r and r['Parameters'] == 'Dict':
 213                     __from = r['data']
 214                     if 'STRING' in __from:
 215                         __parameters = ", Parameters=%s"%(repr(eval(__from['STRING'])),)
 216                     elif 'SCRIPT_FILE' in __from and os.path.exists(__from['SCRIPT_FILE']):
 217                         __parameters = ", Script='%s'"%(__from['SCRIPT_FILE'],)
 218                 else: # if 'Parameters' in r and r['Parameters'] == 'Defaults':
 219                     __Dict = copy.deepcopy(r)
 220                     __Dict.pop('Algorithm','')
 221                     __Dict.pop('Parameters','')
 222                     if 'SetSeed' in __Dict:__Dict['SetSeed'] = int(__Dict['SetSeed'])
 223                     if 'BoxBounds' in __Dict and type(__Dict['BoxBounds']) is str:
 224                         __Dict['BoxBounds'] = eval(__Dict['BoxBounds'])
 225                     if len(__Dict) > 0:
 226                         __parameters = ', Parameters=%s'%(repr(__Dict),)
 227                     else:
 228                         __parameters = ""
 229                 __commands.append( "set( Concept='AlgorithmParameters', Algorithm='%s'%s )"%(r['Algorithm'],__parameters) )
 230             #
 231             elif __command == "Observers" and type(r) is dict and 'SELECTION' in r:
 232                 if type(r['SELECTION']) is str:
 233                     __selection = (r['SELECTION'],)
 234                 else:
 235                     __selection = tuple(r['SELECTION'])
 236                 for sk in __selection:
 237                     __idata = r['%s_data'%sk]
 238                     if __idata['NodeType'] == 'Template' and 'Template' in __idata:
 239                         __template = __idata['Template']
 240                         if 'Info' in __idata:
 241                             __info = ", Info='%s'"%(__idata['Info'],)
 242                         else:
 243                             __info = ""
 244                         __commands.append( "set( Concept='Observer', Variable='%s', Template='%s'%s )"%(sk,__template,__info) )
 245                     if __idata['NodeType'] == 'String' and 'Value' in __idata:
 246                         __value =__idata['Value']
 247                         __commands.append( "set( Concept='Observer', Variable='%s', String='%s' )"%(sk,__value) )
 248             #
 249             # Background, ObservationError, ObservationOperator...
 250             elif type(r) is dict:
 251                 __argumentsList = []
 252                 if 'Stored' in r and bool(r['Stored']):
 253                     __argumentsList.append(['Stored',True])
 254                 if 'INPUT_TYPE' in r and 'data' in r:
 255                     # Vector, Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Function
 256                     __itype = r['INPUT_TYPE']
 257                     __idata = r['data']
 258                     if 'FROM' in __idata:
 259                         # String, Script, Template, ScriptWithOneFunction, ScriptWithFunctions
 260                         __ifrom = __idata['FROM']
 261                         __idata.pop('FROM','')
 262                         if __ifrom == 'String' or __ifrom == 'Template':
 263                             __argumentsList.append([__itype,__idata['STRING']])
 264                         if __ifrom == 'Script':
 265                             __argumentsList.append([__itype,True])
 266                             __argumentsList.append(['Script',__idata['SCRIPT_FILE']])
 267                         if __ifrom == 'ScriptWithOneFunction':
 268                             __argumentsList.append(['OneFunction',True])
 269                             __argumentsList.append(['Script',__idata.pop('SCRIPTWITHONEFUNCTION_FILE')])
 270                             if len(__idata)>0:
 271                                 __argumentsList.append(['Parameters',__idata])
 272                         if __ifrom == 'ScriptWithFunctions':
 273                             __argumentsList.append(['ThreeFunctions',True])
 274                             __argumentsList.append(['Script',__idata.pop('SCRIPTWITHFUNCTIONS_FILE')])
 275                             if len(__idata)>0:
 276                                 __argumentsList.append(['Parameters',__idata])
 277                 __arguments = ["%s = %s"%(k,repr(v)) for k,v in __argumentsList]
 278                 __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments)))
 279         #
 280         # ----------------------------------------------------------------------
 281         __commands.sort() # Pour commencer par 'AlgorithmParameters'
 282         __commands.append(__UserPostAnalysis)
 283         return __commands
 284
 285 class _SCDViewer(GenericCaseViewer):
 286     """
 287     Etablissement des commandes d'un cas SCD (Study Config Dictionary/Cas->SCD)
 288     """
 289     def __init__(self, __name="", __objname="case", __content=None, __object=None):
 290         "Initialisation et enregistrement de l'entete"
 291         GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
 292         self._addLine("# -*- coding: utf-8 -*-")
 293         self._addLine("#\n# Input for ADAO converter to YACS\n#")
 294         self._addLine("from numpy import array, matrix")
 295         self._addLine("#")
 296         self._addLine("study_config = {}")
 297         self._addLine("study_config['StudyType'] = 'ASSIMILATION_STUDY'")
 298         self._addLine("study_config['Name'] = '%s'"%self._name)
 299         self._addLine("observers = {}")
 300         self._addLine("study_config['Observers'] = observers")
 301         self._addLine("#")
 302         self._addLine("inputvariables_config = {}")
 303         self._addLine("inputvariables_config['Order'] =['adao_default']")
 304         self._addLine("inputvariables_config['adao_default'] = -1")
 305         self._addLine("study_config['InputVariables'] = inputvariables_config")
 306         self._addLine("#")
 307         self._addLine("outputvariables_config = {}")
 308         self._addLine("outputvariables_config['Order'] = ['adao_default']")
 309         self._addLine("outputvariables_config['adao_default'] = -1")
 310         self._addLine("study_config['OutputVariables'] = outputvariables_config")
 311         if __content is not None:
 312             for command in __content:
 313                 self._append(*command)
 314     def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
 315         "Transformation d'une commande individuelle en un enregistrement"
 316         if __command == "set": __command = __local["Concept"]
 317         else:                  __command = __command.replace("set", "", 1)
 318         #
 319         __text  = None
 320         if __command in (None, 'execute', 'executePythonScheme', 'executeYACSScheme', 'get', 'Name'):
 321             return
 322         elif __command in ['Debug', 'setDebug']:
 323             __text  = "#\nstudy_config['Debug'] = '1'"
 324         elif __command in ['NoDebug', 'setNoDebug']:
 325             __text  = "#\nstudy_config['Debug'] = '0'"
 326         elif __command in ['Observer', 'setObserver']:
 327             __obs   = __local['Variable']
 328             self._numobservers += 1
 329             __text  = "#\n"
 330             __text += "observers['%s'] = {}\n"%__obs
 331             if __local['String'] is not None:
 332                 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
 333                 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, __local['String'])
 334             if __local['Script'] is not None:
 335                 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'Script')
 336                 __text += "observers['%s']['Script'] = \"%s\"\n"%(__obs, __local['Script'])
 337             if __local['Template'] is not None and __local['Template'] in Templates.ObserverTemplates:
 338                 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
 339                 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, Templates.ObserverTemplates[__local['Template']])
 340             if __local['Info'] is not None:
 341                 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __local['Info'])
 342             else:
 343                 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __obs)
 344             __text += "observers['%s']['number'] = %s"%(__obs, self._numobservers)
 345         elif __local is not None: # __keys is not None and
 346             numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
 347             __text  = "#\n"
 348             __text += "%s_config = {}\n"%__command
 349             __local.pop('self','')
 350             __to_be_removed = []
 351             for __k,__v in __local.items():
 352                 if __v is None: __to_be_removed.append(__k)
 353             for __k in __to_be_removed:
 354                 __local.pop(__k)
 355             for __k,__v in __local.items():
 356                 if __k == "Concept": continue
 357                 if __k in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix','OneFunction','ThreeFunctions'] and 'Script' in __local: continue
 358                 if __k == 'Algorithm':
 359                     __text += "study_config['Algorithm'] = %s\n"%(repr(__v))
 360                 elif __k == 'Script':
 361                     __k = 'Vector'
 362                     __f = 'Script'
 363                     __v = "'"+repr(__v)+"'"
 364                     for __lk in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix']:
 365                         if __lk in __local and __local[__lk]: __k = __lk
 366                     if __command == "AlgorithmParameters": __k = "Dict"
 367                     if 'OneFunction' in __local and __local['OneFunction']:
 368                         __text += "%s_ScriptWithOneFunction = {}\n"%(__command,)
 369                         __text += "%s_ScriptWithOneFunction['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
 370                         __text += "%s_ScriptWithOneFunction['Script'] = {}\n"%(__command,)
 371                         __text += "%s_ScriptWithOneFunction['Script']['Direct'] = %s\n"%(__command,__v)
 372                         __text += "%s_ScriptWithOneFunction['Script']['Tangent'] = %s\n"%(__command,__v)
 373                         __text += "%s_ScriptWithOneFunction['Script']['Adjoint'] = %s\n"%(__command,__v)
 374                         __text += "%s_ScriptWithOneFunction['DifferentialIncrement'] = 1e-06\n"%(__command,)
 375                         __text += "%s_ScriptWithOneFunction['CenteredFiniteDifference'] = 0\n"%(__command,)
 376                         __k = 'Function'
 377                         __f = 'ScriptWithOneFunction'
 378                         __v = '%s_ScriptWithOneFunction'%(__command,)
 379                     if 'ThreeFunctions' in __local and __local['ThreeFunctions']:
 380                         __text += "%s_ScriptWithFunctions = {}\n"%(__command,)
 381                         __text += "%s_ScriptWithFunctions['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
 382                         __text += "%s_ScriptWithFunctions['Script'] = {}\n"%(__command,)
 383                         __text += "%s_ScriptWithFunctions['Script']['Direct'] = %s\n"%(__command,__v)
 384                         __text += "%s_ScriptWithFunctions['Script']['Tangent'] = %s\n"%(__command,__v)
 385                         __text += "%s_ScriptWithFunctions['Script']['Adjoint'] = %s\n"%(__command,__v)
 386                         __k = 'Function'
 387                         __f = 'ScriptWithFunctions'
 388                         __v = '%s_ScriptWithFunctions'%(__command,)
 389                     __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
 390                     __text += "%s_config['From'] = '%s'\n"%(__command,__f)
 391                     __text += "%s_config['Data'] = %s\n"%(__command,__v)
 392                     __text = __text.replace("''","'")
 393                 elif __k in ('Stored', 'Checked'):
 394                     if bool(__v):
 395                         __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
 396                 elif __k in ('AvoidRC', 'noDetails'):
 397                     if not bool(__v):
 398                         __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
 399                 else:
 400                     if __k == 'Parameters': __k = "Dict"
 401                     if isinstance(__v,Persistence.Persistence): __v = __v.values()
 402                     if callable(__v): __text = self._missing%__v.__name__+__text
 403                     if isinstance(__v,dict):
 404                         for val in __v.values():
 405                             if callable(val): __text = self._missing%val.__name__+__text
 406                     __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
 407                     __text += "%s_config['From'] = '%s'\n"%(__command,'String')
 408                     __text += "%s_config['Data'] = \"\"\"%s\"\"\"\n"%(__command,repr(__v))
 409             __text += "study_config['%s'] = %s_config"%(__command,__command)
 410             numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
 411             if __switchoff:
 412                 self._switchoff = True
 413         if __text is not None: self._addLine(__text)
 414         if not __switchoff:
 415             self._switchoff = False
 416     def _finalize(self, *__args):
 417         self.__loadVariablesByScript()
 418         self._addLine("#")
 419         self._addLine("Analysis_config = {}")
 420         self._addLine("Analysis_config['From'] = 'String'")
 421         self._addLine("Analysis_config['Data'] = \"\"\"import numpy")
 422         self._addLine("xa=numpy.ravel(ADD.get('Analysis')[-1])")
 423         self._addLine("print 'Analysis:',xa\"\"\"")
 424         self._addLine("study_config['UserPostAnalysis'] = Analysis_config")
 425     def __loadVariablesByScript(self):
 426         __ExecVariables = {} # Necessaire pour recuperer la variable
 427         exec("\n".join(self._lineSerie), __ExecVariables)
 428         study_config = __ExecVariables['study_config']
 429         # Pour Python 3 : self.__hasAlgorithm = bool(study_config['Algorithm'])
 430         if 'Algorithm' in study_config:
 431             self.__hasAlgorithm = True
 432         else:
 433             self.__hasAlgorithm = False
 434         if not self.__hasAlgorithm and \
 435                 "AlgorithmParameters" in study_config and \
 436                 isinstance(study_config['AlgorithmParameters'], dict) and \
 437                 "From" in study_config['AlgorithmParameters'] and \
 438                 "Data" in study_config['AlgorithmParameters'] and \
 439                 study_config['AlgorithmParameters']['From'] == 'Script':
 440             __asScript = study_config['AlgorithmParameters']['Data']
 441             __var = ImportFromScript(__asScript).getvalue( "Algorithm" )
 442             __text = "#\nstudy_config['Algorithm'] = '%s'"%(__var,)
 443             self._addLine(__text)
 444         if self.__hasAlgorithm and \
 445                 "AlgorithmParameters" in study_config and \
 446                 isinstance(study_config['AlgorithmParameters'], dict) and \
 447                 "From" not in study_config['AlgorithmParameters'] and \
 448                 "Data" not in study_config['AlgorithmParameters']:
 449             __text  = "#\n"
 450             __text += "AlgorithmParameters_config['Type'] = 'Dict'\n"
 451             __text += "AlgorithmParameters_config['From'] = 'String'\n"
 452             __text += "AlgorithmParameters_config['Data'] = '{}'\n"
 453             self._addLine(__text)
 454         del study_config
 455
 456 class _YACSViewer(GenericCaseViewer):
 457     """
 458     Etablissement des commandes d'un cas YACS (Cas->SCD->YACS)
 459     """
 460     def __init__(self, __name="", __objname="case", __content=None, __object=None):
 461         "Initialisation et enregistrement de l'entete"
 462         GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
 463         self.__internalSCD = _SCDViewer(__name, __objname, __content, __object)
 464         self._append       = self.__internalSCD._append
 465     def dump(self, __filename=None, __convertSCDinMemory=True):
 466         "Restitution normalisée des commandes"
 467         self.__internalSCD._finalize()
 468         # -----
 469         if __filename is None:
 470             raise ValueError("A file name has to be given for YACS XML output.")
 471         # -----
 472         if not PlatformInfo.has_salome or \
 473             not PlatformInfo.has_adao:
 474             raise ImportError(
 475                 "Unable to get SALOME or ADAO environnement variables for YACS conversion.\n"+\
 476                 "Please load the right environnement before trying to use it.")
 477         elif __convertSCDinMemory:
 478             __file    = os.path.abspath(__filename)
 479             __SCDdump = self.__internalSCD.dump()
 480             if os.path.isfile(__file) or os.path.islink(__file):
 481                 os.remove(__file)
 482             from daYacsSchemaCreator.run import create_schema_from_content
 483             create_schema_from_content(__SCDdump, __file)
 484         else:
 485             __file    = os.path.abspath(__filename)
 486             __SCDfile = __file[:__file.rfind(".")] + '_SCD.py'
 487             __SCDdump = self.__internalSCD.dump(__SCDfile)
 488             if os.path.isfile(__file) or os.path.islink(__file):
 489                 os.remove(__file)
 490             __converterExe = os.path.join(os.environ["ADAO_ROOT_DIR"], "bin/salome", "AdaoYacsSchemaCreator.py")
 491             __args = ["python", __converterExe, __SCDfile, __file]
 492             import subprocess
 493             __p = subprocess.Popen(__args)
 494             (__stdoutdata, __stderrdata) = __p.communicate()
 495             __p.terminate()
 496             os.remove(__SCDfile)
 497         # -----
 498         if not os.path.exists(__file):
 499             __msg  = "An error occured during the ADAO YACS Schema build for\n"
 500             __msg += "the target output file:\n"
 501             __msg += "  %s\n"%__file
 502             __msg += "See errors details in your launching terminal log.\n"
 503             raise ValueError(__msg)
 504         # -----
 505         __fid = open(__file,"r")
 506         __text = __fid.read()
 507         __fid.close()
 508         return __text
 509
 510 class ImportFromScript(object):
 511     """
 512     Obtention d'une variable nommee depuis un fichier script importe
 513     """
 514     def __init__(self, __filename=None):
 515         "Verifie l'existence et importe le script"
 516         if __filename is None:
 517             raise ValueError("The name of the file, containing the variable to be read, has to be specified.")
 518         if not os.path.isfile(__filename):
 519             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)
 520         if os.path.dirname(__filename) != '':
 521             sys.path.insert(0, os.path.dirname(__filename))
 522             __basename = os.path.basename(__filename).rstrip(".py")
 523         else:
 524             __basename = __filename.rstrip(".py")
 525         self.__basename = __basename
 526         self.__scriptfile = __import__(__basename, globals(), locals(), [])
 527         self.__scriptstring = open(__filename,'r').read()
 528     def getvalue(self, __varname=None, __synonym=None ):
 529         "Renvoie la variable demandee"
 530         if __varname is None:
 531             raise ValueError("The name of the variable to be read has to be specified. Please check the content of the file and the syntax.")
 532         if not hasattr(self.__scriptfile, __varname):
 533             if __synonym is None:
 534                 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))
 535             elif not hasattr(self.__scriptfile, __synonym):
 536                 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))
 537             else:
 538                 return getattr(self.__scriptfile, __synonym)
 539         else:
 540             return getattr(self.__scriptfile, __varname)
 541     def getstring(self):
 542         "Renvoie le script complet"
 543         return self.__scriptstring
 544
 545 # ==============================================================================
 546 if __name__ == "__main__":
 547     print('\n AUTODIAGNOSTIC \n')