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 _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 using 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 an 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 _COMViewer(GenericCaseViewer):
 291     """
 292     Etablissement des commandes d'un cas COMM (Eficas Native Format/Cas<-COM)
 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 using ADAO COMM\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 _extract(self, __multilines=None, __object=None):
 307         "Transformation un enregistrement en une commande individuelle"
 308         if __multilines is not None:
 309             __multilines = __multilines.replace("ASSIMILATION_STUDY","dict")
 310             __multilines = __multilines.replace("CHECKING_STUDY",    "dict")
 311             __multilines = __multilines.replace("_F(",               "dict(")
 312             __multilines = __multilines.replace(",),);",             ",),)")
 313         self._objname = "case"
 314         self._objdata = None
 315         exec("self._objdata = "+__multilines)
 316         #
 317         if self._objdata is None or not(type(self._objdata) is dict) or not('AlgorithmParameters' in self._objdata):
 318             raise ValueError("Impossible to load given content as an ADAO COMM one (no dictionnary or no 'AlgorithmParameters' key found).")
 319         # ----------------------------------------------------------------------
 320         logging.debug("COMM Extracting commands of '%s' object..."%(self._objname,))
 321         __commands = []
 322         __UserPostAnalysis = ""
 323         for k,r in self._objdata.items():
 324             __command = k
 325             logging.debug("COMM Extracted command: %s:%s"%(k, r))
 326             if   __command == "StudyName" and len(str(r))>0:
 327                 __commands.append( "set( Concept='Name', String='%s')"%(str(r),) )
 328             elif   __command == "StudyRepertory":
 329                 __commands.append( "set( Concept='Directory', String='%s')"%(str(r),) )
 330             #
 331             elif __command == "UserPostAnalysis" and type(r) is dict:
 332                 if 'STRING' in r:
 333                     __UserPostAnalysis = r['STRING']
 334                 elif 'SCRIPT_FILE' in r and os.path.exists(r['SCRIPT_FILE']):
 335                     __UserPostAnalysis = open(r['SCRIPT_FILE'],'r').read()
 336                 elif 'Template' in r and 'ValueTemplate' in r:
 337                     # AnalysisPrinter...
 338                     __UserPostAnalysis = r['ValueTemplate']
 339                 else:
 340                     __UserPostAnalysis = ""
 341                 __UserPostAnalysis = __UserPostAnalysis.replace("ADD",self._objname)
 342             #
 343             elif __command == "AlgorithmParameters" and type(r) is dict and 'Algorithm' in r:
 344                 if 'Parameters' in r and r['Parameters'] == 'Defaults':
 345                     __Dict = copy.deepcopy(r)
 346                     __Dict.pop('Algorithm')
 347                     if 'SetSeed' in __Dict:__Dict['SetSeed'] = int(__Dict['SetSeed'])
 348                     if 'BoxBounds' in __Dict and type(__Dict['BoxBounds']) is str:
 349                         __Dict['BoxBounds'] = eval(__Dict['BoxBounds'])
 350                     __parameters = ', Parameters=%s'%(repr(__Dict),)
 351                 elif 'data' in r and r['Parameters'] == 'Dict':
 352                     __from = r['data']
 353                     if 'STRING' in __from:
 354                         __parameters = ", Parameters=%s"%(repr(eval(__from['STRING'])),)
 355                     elif 'SCRIPT_FILE' in __from and os.path.exists(__from['SCRIPT_FILE']):
 356                         __parameters = ", Script='%s'"%(__from['SCRIPT_FILE'],)
 357                 else:
 358                     __parameters = ""
 359                 __commands.append( "set( Concept='AlgorithmParameters', Algorithm='%s'%s )"%(r['Algorithm'],__parameters) )
 360             #
 361             elif __command == "Observers" and type(r) is dict and 'SELECTION' in r:
 362                 if type(r['SELECTION']) is str:
 363                     __selection = (r['SELECTION'],)
 364                 else:
 365                     __selection = tuple(r['SELECTION'])
 366                 for sk in __selection:
 367                     __idata = r['%s_data'%sk]
 368                     if __idata['NodeType'] == 'Template' and 'Template' in __idata:
 369                         __template = __idata['Template']
 370                         if 'Info' in __idata:
 371                             __info = ", Info='%s'"%(__idata['Info'],)
 372                         else:
 373                             __info = ""
 374                         __commands.append( "set( Concept='Observer', Variable='%s', Template='%s'%s )"%(sk,__template,__info) )
 375                     if __idata['NodeType'] == 'String' and 'Value' in __idata:
 376                         __value =__idata['Value']
 377                         __commands.append( "set( Concept='Observer', Variable='%s', String='%s' )"%(sk,__value) )
 378             #
 379             # Background, ObservationError, ObservationOperator...
 380             elif type(r) is dict:
 381                 __argumentsList = []
 382                 if 'Stored' in r and bool(r['Stored']):
 383                     __argumentsList.append(['Stored',True])
 384                 if 'INPUT_TYPE' in r and 'data' in r:
 385                     # Vector, Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Function
 386                     __itype = r['INPUT_TYPE']
 387                     __idata = r['data']
 388                     if 'FROM' in __idata:
 389                         # String, Script, Template, ScriptWithOneFunction, ScriptWithFunctions
 390                         __ifrom = __idata['FROM']
 391                         if __ifrom == 'String' or __ifrom == 'Template':
 392                             __argumentsList.append([__itype,__idata['STRING']])
 393                         if __ifrom == 'Script':
 394                             __argumentsList.append([__itype,True])
 395                             __argumentsList.append(['Script',__idata['SCRIPT_FILE']])
 396                         if __ifrom == 'ScriptWithOneFunction':
 397                             __argumentsList.append(['OneFunction',True])
 398                             __argumentsList.append(['Script',__idata.pop('SCRIPTWITHONEFUNCTION_FILE')])
 399                             if len(__idata)>0:
 400                                 __argumentsList.append(['Parameters',__idata])
 401                         if __ifrom == 'ScriptWithFunctions':
 402                             __argumentsList.append(['ThreeFunctions',True])
 403                             __argumentsList.append(['Script',__idata.pop('SCRIPTWITHFUNCTIONS_FILE')])
 404                             if len(__idata)>0:
 405                                 __argumentsList.append(['Parameters',__idata])
 406                 __arguments = ["%s = %s"%(k,repr(v)) for k,v in __argumentsList]
 407                 __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments)))
 408         #
 409         # ----------------------------------------------------------------------
 410         __commands.sort() # Pour commencer par 'AlgorithmParameters'
 411         __commands.append(__UserPostAnalysis)
 412         return __commands
 413
 414 class _DCTViewer(GenericCaseViewer):
 415     """
 416     Etablissement des commandes d'un cas DCT (Cas<->DCT)
 417     """
 418     def __init__(self, __name="", __objname="case", __content=None, __object=None):
 419         "Initialisation et enregistrement de l'entete"
 420         GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
 421         self._observerIndex = 0
 422         self._addLine("# -*- coding: utf-8 -*-")
 423         self._addLine("#\n# Python script using ADAO DCT\n#")
 424         self._addLine("from numpy import array, matrix")
 425         self._addLine("#")
 426         self._addLine("%s = {}"%__objname)
 427         if self._content is not None:
 428             for command in self._content:
 429                 self._append(*command)
 430     def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
 431         "Transformation d'une commande individuelle en un enregistrement"
 432         if __command is not None and __keys is not None and __local is not None:
 433             __text  = ""
 434             if "execute" in __command: return
 435             if "self" in __keys: __keys.remove("self")
 436             if __command in ("set","get") and "Concept" in __keys:
 437                 __key = __local["Concept"]
 438                 __keys.remove("Concept")
 439             else:
 440                 __key = __command.replace("set","").replace("get","")
 441             if "Observer" in __key and 'Variable' in __keys:
 442                 self._observerIndex += 1
 443                 __key += "_%i"%self._observerIndex
 444             __text += "%s['%s'] = {"%(self._objname,str(__key))
 445             for k in __keys:
 446                 __v = __local[k]
 447                 if __v is None: continue
 448                 if   k == "Checked" and not __v: continue
 449                 if   k == "Stored"  and not __v: continue
 450                 if   k == "AvoidRC" and __v: continue
 451                 if   k == "noDetails": continue
 452                 if isinstance(__v,Persistence.Persistence): __v = __v.values()
 453                 if callable(__v): __text = self._missing%__v.__name__+__text
 454                 if isinstance(__v,dict):
 455                     for val in __v.values():
 456                         if callable(val): __text = self._missing%val.__name__+__text
 457                 numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
 458                 __text += "'%s':%s, "%(k,repr(__v))
 459                 numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
 460             __text.rstrip(", ").rstrip()
 461             __text += "}"
 462             if __text[-2:] == "{}": return # Supprime les *Debug et les variables
 463             self._addLine(__text)
 464     def _extract(self, __multilines="", __object=None):
 465         "Transformation un enregistrement en une commande individuelle"
 466         __multilines = __multilines.replace("\r\n","\n")
 467         exec(__multilines)
 468         self._objdata = None
 469         __getlocals = locals()
 470         for k in __getlocals:
 471             try:
 472                 if 'AlgorithmParameters' in __getlocals[k] and type(__getlocals[k]) is dict:
 473                     self._objname = k
 474                     self._objdata = __getlocals[k]
 475             except:
 476                 continue
 477         if self._objdata is None:
 478             raise ValueError("Impossible to load given content as an ADAO DCT one (no 'AlgorithmParameters' key found).")
 479         # ----------------------------------------------------------------------
 480         logging.debug("DCT Extracting commands of '%s' object..."%(self._objname,))
 481         __commands = []
 482         for k in self._objdata:
 483             if 'Observer_' in k:
 484                 __command = k.split('_',1)[0]
 485             else:
 486                 __command = k
 487             __arguments = ["%s = %s"%(k,repr(v)) for k,v in self._objdata[k].items()]
 488             __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments)))
 489         __commands.sort() # Pour commencer par 'AlgorithmParameters'
 490         return __commands
 491
 492 class _SCDViewer(GenericCaseViewer):
 493     """
 494     Etablissement des commandes d'un cas SCD (Study Config Dictionary/Cas->SCD)
 495     """
 496     def __init__(self, __name="", __objname="case", __content=None, __object=None):
 497         "Initialisation et enregistrement de l'entete"
 498         GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
 499         self._addLine("# -*- coding: utf-8 -*-")
 500         self._addLine("#\n# Input for ADAO converter to YACS\n#")
 501         self._addLine("from numpy import array, matrix")
 502         self._addLine("#")
 503         self._addLine("study_config = {}")
 504         self._addLine("study_config['StudyType'] = 'ASSIMILATION_STUDY'")
 505         self._addLine("study_config['Name'] = '%s'"%self._name)
 506         self._addLine("observers = {}")
 507         self._addLine("study_config['Observers'] = observers")
 508         self._addLine("#")
 509         self._addLine("inputvariables_config = {}")
 510         self._addLine("inputvariables_config['Order'] =['adao_default']")
 511         self._addLine("inputvariables_config['adao_default'] = -1")
 512         self._addLine("study_config['InputVariables'] = inputvariables_config")
 513         self._addLine("#")
 514         self._addLine("outputvariables_config = {}")
 515         self._addLine("outputvariables_config['Order'] = ['adao_default']")
 516         self._addLine("outputvariables_config['adao_default'] = -1")
 517         self._addLine("study_config['OutputVariables'] = outputvariables_config")
 518         if __content is not None:
 519             for command in __content:
 520                 self._append(*command)
 521     def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
 522         "Transformation d'une commande individuelle en un enregistrement"
 523         if __command == "set": __command = __local["Concept"]
 524         else:                  __command = __command.replace("set", "", 1)
 525         #
 526         __text  = None
 527         if __command in (None, 'execute', 'executePythonScheme', 'executeYACSScheme', 'get', 'Name'):
 528             return
 529         elif __command in ['Debug', 'setDebug']:
 530             __text  = "#\nstudy_config['Debug'] = '1'"
 531         elif __command in ['NoDebug', 'setNoDebug']:
 532             __text  = "#\nstudy_config['Debug'] = '0'"
 533         elif __command in ['Observer', 'setObserver']:
 534             __obs   = __local['Variable']
 535             self._numobservers += 1
 536             __text  = "#\n"
 537             __text += "observers['%s'] = {}\n"%__obs
 538             if __local['String'] is not None:
 539                 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
 540                 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, __local['String'])
 541             if __local['Script'] is not None:
 542                 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'Script')
 543                 __text += "observers['%s']['Script'] = \"%s\"\n"%(__obs, __local['Script'])
 544             if __local['Template'] is not None and __local['Template'] in Templates.ObserverTemplates:
 545                 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
 546                 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, Templates.ObserverTemplates[__local['Template']])
 547             if __local['Info'] is not None:
 548                 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __local['Info'])
 549             else:
 550                 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __obs)
 551             __text += "observers['%s']['number'] = %s"%(__obs, self._numobservers)
 552         elif __local is not None: # __keys is not None and
 553             numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
 554             __text  = "#\n"
 555             __text += "%s_config = {}\n"%__command
 556             if 'self' in __local: __local.pop('self')
 557             __to_be_removed = []
 558             for __k,__v in __local.items():
 559                 if __v is None: __to_be_removed.append(__k)
 560             for __k in __to_be_removed:
 561                 __local.pop(__k)
 562             for __k,__v in __local.items():
 563                 if __k == "Concept": continue
 564                 if __k in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix','OneFunction','ThreeFunctions'] and 'Script' in __local: continue
 565                 if __k == 'Algorithm':
 566                     __text += "study_config['Algorithm'] = %s\n"%(repr(__v))
 567                 elif __k == 'Script':
 568                     __k = 'Vector'
 569                     __f = 'Script'
 570                     __v = "'"+repr(__v)+"'"
 571                     for __lk in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix']:
 572                         if __lk in __local and __local[__lk]: __k = __lk
 573                     if __command == "AlgorithmParameters": __k = "Dict"
 574                     if 'OneFunction' in __local and __local['OneFunction']:
 575                         __text += "%s_ScriptWithOneFunction = {}\n"%(__command,)
 576                         __text += "%s_ScriptWithOneFunction['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
 577                         __text += "%s_ScriptWithOneFunction['Script'] = {}\n"%(__command,)
 578                         __text += "%s_ScriptWithOneFunction['Script']['Direct'] = %s\n"%(__command,__v)
 579                         __text += "%s_ScriptWithOneFunction['Script']['Tangent'] = %s\n"%(__command,__v)
 580                         __text += "%s_ScriptWithOneFunction['Script']['Adjoint'] = %s\n"%(__command,__v)
 581                         __text += "%s_ScriptWithOneFunction['DifferentialIncrement'] = 1e-06\n"%(__command,)
 582                         __text += "%s_ScriptWithOneFunction['CenteredFiniteDifference'] = 0\n"%(__command,)
 583                         __k = 'Function'
 584                         __f = 'ScriptWithOneFunction'
 585                         __v = '%s_ScriptWithOneFunction'%(__command,)
 586                     if 'ThreeFunctions' in __local and __local['ThreeFunctions']:
 587                         __text += "%s_ScriptWithFunctions = {}\n"%(__command,)
 588                         __text += "%s_ScriptWithFunctions['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
 589                         __text += "%s_ScriptWithFunctions['Script'] = {}\n"%(__command,)
 590                         __text += "%s_ScriptWithFunctions['Script']['Direct'] = %s\n"%(__command,__v)
 591                         __text += "%s_ScriptWithFunctions['Script']['Tangent'] = %s\n"%(__command,__v)
 592                         __text += "%s_ScriptWithFunctions['Script']['Adjoint'] = %s\n"%(__command,__v)
 593                         __k = 'Function'
 594                         __f = 'ScriptWithFunctions'
 595                         __v = '%s_ScriptWithFunctions'%(__command,)
 596                     __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
 597                     __text += "%s_config['From'] = '%s'\n"%(__command,__f)
 598                     __text += "%s_config['Data'] = %s\n"%(__command,__v)
 599                     __text = __text.replace("''","'")
 600                 elif __k in ('Stored', 'Checked'):
 601                     if bool(__v):
 602                         __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
 603                 elif __k in ('AvoidRC', 'noDetails'):
 604                     if not bool(__v):
 605                         __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
 606                 else:
 607                     if __k == 'Parameters': __k = "Dict"
 608                     if isinstance(__v,Persistence.Persistence): __v = __v.values()
 609                     if callable(__v): __text = self._missing%__v.__name__+__text
 610                     if isinstance(__v,dict):
 611                         for val in __v.values():
 612                             if callable(val): __text = self._missing%val.__name__+__text
 613                     __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
 614                     __text += "%s_config['From'] = '%s'\n"%(__command,'String')
 615                     __text += "%s_config['Data'] = \"\"\"%s\"\"\"\n"%(__command,repr(__v))
 616             __text += "study_config['%s'] = %s_config"%(__command,__command)
 617             numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
 618             if __switchoff:
 619                 self._switchoff = True
 620         if __text is not None: self._addLine(__text)
 621         if not __switchoff:
 622             self._switchoff = False
 623     def _finalize(self, *__args):
 624         self.__loadVariablesByScript()
 625         self._addLine("#")
 626         self._addLine("Analysis_config = {}")
 627         self._addLine("Analysis_config['From'] = 'String'")
 628         self._addLine("Analysis_config['Data'] = \"\"\"import numpy")
 629         self._addLine("xa=numpy.ravel(ADD.get('Analysis')[-1])")
 630         self._addLine("print 'Analysis:',xa\"\"\"")
 631         self._addLine("study_config['UserPostAnalysis'] = Analysis_config")
 632     def __loadVariablesByScript(self):
 633         __ExecVariables = {} # Necessaire pour recuperer la variable
 634         exec("\n".join(self._lineSerie), __ExecVariables)
 635         study_config = __ExecVariables['study_config']
 636         # Pour Python 3 : self.__hasAlgorithm = bool(study_config['Algorithm'])
 637         if 'Algorithm' in study_config:
 638             self.__hasAlgorithm = True
 639         else:
 640             self.__hasAlgorithm = False
 641         if not self.__hasAlgorithm and \
 642                 "AlgorithmParameters" in study_config and \
 643                 isinstance(study_config['AlgorithmParameters'], dict) and \
 644                 "From" in study_config['AlgorithmParameters'] and \
 645                 "Data" in study_config['AlgorithmParameters'] and \
 646                 study_config['AlgorithmParameters']['From'] == 'Script':
 647             __asScript = study_config['AlgorithmParameters']['Data']
 648             __var = ImportFromScript(__asScript).getvalue( "Algorithm" )
 649             __text = "#\nstudy_config['Algorithm'] = '%s'"%(__var,)
 650             self._addLine(__text)
 651         if self.__hasAlgorithm and \
 652                 "AlgorithmParameters" in study_config and \
 653                 isinstance(study_config['AlgorithmParameters'], dict) and \
 654                 "From" not in study_config['AlgorithmParameters'] and \
 655                 "Data" not in study_config['AlgorithmParameters']:
 656             __text  = "#\n"
 657             __text += "AlgorithmParameters_config['Type'] = 'Dict'\n"
 658             __text += "AlgorithmParameters_config['From'] = 'String'\n"
 659             __text += "AlgorithmParameters_config['Data'] = '{}'\n"
 660             self._addLine(__text)
 661         del study_config
 662
 663 class _XMLViewer(GenericCaseViewer):
 664     """
 665     Etablissement des commandes d'un cas XML
 666     """
 667     def __init__(self, __name="", __objname="case", __content=None, __object=None):
 668         "Initialisation et enregistrement de l'entete"
 669         GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
 670         raise NotImplementedError()
 671
 672 class _YACSViewer(GenericCaseViewer):
 673     """
 674     Etablissement des commandes d'un cas YACS (Cas->SCD->YACS)
 675     """
 676     def __init__(self, __name="", __objname="case", __content=None, __object=None):
 677         "Initialisation et enregistrement de l'entete"
 678         GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
 679         self.__internalSCD = _SCDViewer(__name, __objname, __content, __object)
 680         self._append       = self.__internalSCD._append
 681     def dump(self, __filename=None, __convertSCDinMemory=True):
 682         "Restitution normalisée des commandes"
 683         self.__internalSCD._finalize()
 684         # -----
 685         if __filename is None:
 686             raise ValueError("A file name has to be given for YACS XML output.")
 687         # -----
 688         if not PlatformInfo.has_salome or \
 689             not PlatformInfo.has_adao:
 690             raise ImportError("\n\n"+\
 691                 "Unable to get SALOME or ADAO environnement variables.\n"+\
 692                 "Please load the right environnement before trying to use it.\n")
 693         elif __convertSCDinMemory:
 694             __file    = os.path.abspath(__filename)
 695             __SCDdump = self.__internalSCD.dump()
 696             if os.path.isfile(__file) or os.path.islink(__file):
 697                 os.remove(__file)
 698             from daYacsSchemaCreator.run import create_schema_from_content
 699             create_schema_from_content(__SCDdump, __file)
 700         else:
 701             __file    = os.path.abspath(__filename)
 702             __SCDfile = __file[:__file.rfind(".")] + '_SCD.py'
 703             __SCDdump = self.__internalSCD.dump(__SCDfile)
 704             if os.path.isfile(__file) or os.path.islink(__file):
 705                 os.remove(__file)
 706             __converterExe = os.path.join(os.environ["ADAO_ROOT_DIR"], "bin/salome", "AdaoYacsSchemaCreator.py")
 707             __args = ["python", __converterExe, __SCDfile, __file]
 708             import subprocess
 709             __p = subprocess.Popen(__args)
 710             (__stdoutdata, __stderrdata) = __p.communicate()
 711             __p.terminate()
 712             os.remove(__SCDfile)
 713         # -----
 714         if not os.path.exists(__file):
 715             __msg  = "An error occured during the ADAO YACS Schema build for\n"
 716             __msg += "the target output file:\n"
 717             __msg += "  %s\n"%__file
 718             __msg += "See errors details in your launching terminal log.\n"
 719             raise ValueError(__msg)
 720         # -----
 721         __fid = open(__file,"r")
 722         __text = __fid.read()
 723         __fid.close()
 724         return __text
 725
 726 class ImportFromScript(object):
 727     """
 728     Obtention d'une variable nommee depuis un fichier script importe
 729     """
 730     def __init__(self, __filename=None):
 731         "Verifie l'existence et importe le script"
 732         if __filename is None:
 733             raise ValueError("The name of the file, containing the variable to be read, has to be specified.")
 734         if not os.path.isfile(__filename):
 735             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)
 736         if os.path.dirname(__filename) != '':
 737             sys.path.insert(0, os.path.dirname(__filename))
 738             __basename = os.path.basename(__filename).rstrip(".py")
 739         else:
 740             __basename = __filename.rstrip(".py")
 741         self.__basename = __basename
 742         self.__scriptfile = __import__(__basename, globals(), locals(), [])
 743         self.__scriptstring = open(__filename,'r').read()
 744     def getvalue(self, __varname=None, __synonym=None ):
 745         "Renvoie la variable demandee"
 746         if __varname is None:
 747             raise ValueError("The name of the variable to be read has to be specified. Please check the content of the file and the syntax.")
 748         if not hasattr(self.__scriptfile, __varname):
 749             if __synonym is None:
 750                 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))
 751             elif not hasattr(self.__scriptfile, __synonym):
 752                 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))
 753             else:
 754                 return getattr(self.__scriptfile, __synonym)
 755         else:
 756             return getattr(self.__scriptfile, __varname)
 757     def getstring(self):
 758         "Renvoie le script complet"
 759         return self.__scriptstring
 760
 761 # ==============================================================================
 762 if __name__ == "__main__":
 763     print('\n AUTODIAGNOSTIC \n')