InterfaceQT4/eficas_go.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 # Copyright (C) 2007-2021   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
  22 # Modules Python
  23 from __future__ import absolute_import
  24 from __future__ import print_function
  25 try :
  26     from builtins import str
  27 except : pass
  28
  29 import sys,os
  30 repIni     = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),".."))
  31 ihmQTDir   = os.path.join(repIni,"UiQT5")
  32 editeurDir = os.path.join(repIni,"Editeur")
  33 ihmDir     = os.path.join(repIni,"InterfaceQT4")
  34
  35 if ihmDir     not in sys.path : sys.path.append(ihmDir)
  36 if ihmQTDir   not in sys.path : sys.path.append(ihmQTDir)
  37 if editeurDir not in sys.path : sys.path.append(editeurDir)
  38
  39 if sys.version_info[0] < 3:
  40     print("Must be using Python 3")
  41     sys.exit()
  42
  43 def lanceEficas(code=None, multi=False, langue='en', labelCode=None):
  44 #-------------------------------------------------------------------
  45     """
  46         Lance l'appli EFICAS avec Ihm
  47     """
  48     try :
  49         from PyQt5.QtWidgets import QApplication
  50     except :
  51         print('Please, set qt environment')
  52         return
  53
  54     from Editeur  import session
  55     options = session.parse(sys.argv)
  56     if options.code          != None : code=options.code
  57
  58     from InterfaceQT4.qtEficas import Appli
  59     app = QApplication(sys.argv)
  60
  61     Eficas=Appli(code=code,salome=0,multi=multi,langue=langue,labelCode=labelCode)
  62     Eficas.show()
  63
  64     res=app.exec_()
  65     sys.exit(res)
  66
  67 def getEficasSsIhm(code=None, multi=False, langue='en', ssCode=None, labelCode=None,forceXML=False, genereXSD=False, fichierCata=None):
  68 #-------------------------------------------------------------------------------------------------------------------------
  69     """
  70         Lance l'appli EFICAS sans Ihm
  71     """
  72     from Editeur  import session
  73     options = session.parse(sys.argv)
  74     if options.code   != None : code=options.code
  75     if forceXML : options.withXSD=True
  76
  77     from InterfaceQT4.qtEficasSsIhm import AppliSsIhm
  78     Eficas=AppliSsIhm(code=code, salome=0, multi=multi, langue=langue, ssCode=ssCode, labelCode=labelCode, genereXSD=genereXSD, fichierCata=fichierCata)
  79     return Eficas
  80
  81
  82
  83 def genereXSD(code=None):
  84 #------------------------
  85     from Editeur  import session
  86     options = session.parse(sys.argv)
  87     if code != None : options.code = code
  88     if options.fichierCata == None :
  89         print ('Use -c cata_name.py')
  90         return
  91
  92     monEficasSsIhm = getEficasSsIhm(code=options.code,genereXSD=True)
  93     monEditor=monEficasSsIhm.getEditor()
  94     #texteXSD=monEficasSsIhm.dumpXsd(avecEltAbstrait=options.avecEltAbstrait)
  95     texteXSD=monEditor.dumpXsd(avecEltAbstrait=options.avecEltAbstrait)
  96
  97     fichierCataTrunc=os.path.splitext(os.path.basename(options.fichierCata))[0]
  98     #if fichierCataTrunc[0:4] in ('cata','Cata'): fichierCataTrunc=fichierCataTrunc[4:]
  99     #if fichierCataTrunc[0] in ('_','-') : fichierCataTrunc=fichierCataTrunc[1:]
 100     fileXSD = fichierCataTrunc + '.xsd'
 101
 102     f = open( str(fileXSD), 'w')
 103     f.write(str(texteXSD))
 104
 105 def genereXML(code=None):
 106 #-----------------------
 107     from Editeur  import session
 108     options=session.parse(sys.argv)
 109     if code != None : options.code = code
 110     if options.fichierCata == None :
 111         print ('Use -c cata_name.py')
 112         return
 113     try    : fichier=options.comm[0]
 114     except : fichier=None
 115     if fichier==None :
 116         print ('comm file is needed')
 117         return
 118
 119     monEficasSsIhm = getEficasSsIhm(code=options.code, forceXML=True)
 120
 121     from .editorSsIhm import JDCEditorSsIhm
 122     monEditeur=JDCEditorSsIhm(monEficasSsIhm,fichier)
 123     if options.fichierXMLOut == None :
 124         fichierXMLOut=fichier[:fichier.rfind(".")]+'.xml'
 125     else :
 126         fichierXMLOut=options.fichierXMLOut
 127     if not(monEditeur.jdc.isValid()):
 128         print ('Fichier comm is not valid')
 129         return
 130     #print ('Fichier comm is not valid')
 131     monEditeur.XMLgenerator.gener(monEditeur.jdc)
 132     monEditeur.XMLgenerator.writeDefault(fichierXMLOut)
 133
 134 def genereStructure(code=None):
 135 #------------------------------
 136     from Editeur  import session
 137     options=session.parse(sys.argv)
 138     if code != None : options.code = code
 139     if options.fichierCata == None :
 140         print ('Use -c cata_name.py')
 141         return
 142
 143     monEficasSsIhm = getEficasSsIhm(code=options.code,genereXSD=True)
 144     monEditor=monEficasSsIhm.getEditor()
 145     texteStructure=monEditor.dumpStructure()
 146
 147     fichierCataTrunc=os.path.splitext(os.path.basename(options.fichierCata))[0]
 148     fileStructure = fichierCataTrunc + '.txt'
 149     f = open( str(fileStructure), 'w')
 150     f.write(str(texteStructure))
 151     f.close()
 152
 153
 154 def validateDataSet(code=None):
 155 #------------------------------
 156     from Editeur  import session
 157     options=session.parse(sys.argv)
 158     if code != None : options.code = code
 159     if options.fichierCata == None :
 160         print ('Use -c cata_name.py')
 161         return
 162     fichier=options.comm[0]
 163     if fichier==None :
 164         print ('comm file is needed')
 165         return
 166     from .editorSsIhm import JDCEditorSsIhm
 167     monEficasSsIhm = getEficasSsIhm(code=options.code)
 168     monEditeur=JDCEditorSsIhm(monEficasSsIhm,fichier)
 169     if not (monEditeur.jdc.isValid()) : print (monEditeur.getJdcRapport())
 170     else : print ('Jdc is valid')
 171     return monEditeur.jdc.isValid()
 172
 173 def validateFonction(laFonction, debug=False):
 174 #-------------------------------
 175     # ici un singleton pour avoir l editor, le catalogue et...
 176     monEficasSsIhm = getEficasSsIhm(code='Essai')
 177     monEditor=monEficasSsIhm.getEditor()
 178     print ('_______ validateFonction', laFonction,  laFonction.__name__)
 179     from functools  import wraps
 180     from collections  import OrderedDict
 181     from inspect  import getargspec
 182     @wraps(laFonction)
 183     def fonctionValidee(*args, **kwargs):
 184         laFonctionName = laFonction.__name__
 185         if debug : print('Appel {} avec args={} et kwargs={}'.format( laFonction.__name__, args, kwargs))
 186         laDefDeLaFonctionDansAccas = getattr(monEditor.readercata.cata,laFonctionName)
 187         objConstruit = laDefDeLaFonctionDansAccas.makeObjetPourVerifSignature(*args,**kwargs)
 188         if (objConstruit.isValid()) :
 189             ret = laFonction(*args, **kwargs)
 190             return ret
 191         else :
 192             print ('mauvais arguments')
 193             print (objConstruit.CR())
 194             return None
 195     return fonctionValidee
 196
 197         #maClasseAccas=getattr(self.cata,objEtape.monNomClasseAccas)
 198     return fonctionValidee
 199
 200
 201     return laFonction
 202
 203 def createFromDocumentAccas(fichierCata=None,fichier=None,code=None):
 204 #------------------------------------------------------------
 205     if fichier == None : print ('file is needed'); return None
 206     if fichierCata == None    : print ('cata file is needed'); return None
 207
 208     from Noyau.N_OBJECT import activeSurcharge
 209     activeSurcharge()
 210
 211     from .editorSsIhm import JDCEditorSsIhm
 212     monEficasSsIhm = getEficasSsIhm(code='Essai', fichierCata=fichierCata)
 213     monEditeur=JDCEditorSsIhm(monEficasSsIhm,fichier)
 214     return monEditeur.jdc
 215     #from Noyau
 216
 217
 218 # --------------------------- toutes les fonctions après sont obseletes
 219 def lanceEficas_ssIhm(code=None,fichier=None,ssCode=None,version=None,debug=False,langue='en'):
 220     """
 221         Lance l'appli EFICAS SsIhm
 222     """
 223     # Analyse des arguments de la ligne de commande
 224     print ('deprecated')
 225     from Editeur  import session
 226     options=session.parse(sys.argv)
 227     if version!=None and options.version == None : options.version=version
 228     if fichier == None : fichier=options.comm[0]
 229     if code    == None : code=options.code
 230
 231     from .qtEficas import Appli
 232     Eficas=Appli(code=code,salome=0,ssCode=ssCode,ssIhm=True,langue=langue)
 233
 234     from .ssIhm  import QWParentSSIhm
 235     parent=QWParentSSIhm(code,Eficas,version)
 236
 237     from . import readercata
 238     if not hasattr ( Eficas, 'readercata'):
 239         monreadercata  = readercata.ReaderCata( parent, Eficas )
 240         Eficas.readercata=monreadercata
 241
 242     from .editor import JDCEditor
 243     monEditeur=JDCEditor(Eficas,fichier)
 244     return monEditeur
 245
 246 def lanceEficas_ssIhm_chercheGroupes(code=None,fichier=None,ssCode=None,version=None):
 247     print ('deprecated')
 248     monEditeur=lanceEficas_ssIhm(code,fichier,ssCode,version)
 249     print((monEditeur.chercheGroupes()))
 250
 251 def lanceEficas_ssIhm_cherche_cr(code=None,fichier=None,ssCode=None,version=None):
 252     print ('deprecated')
 253     monEditeur=lanceEficas_ssIhm(code,fichier,ssCode,version)
 254     print((monEditeur.jdc.cr))
 255
 256 def lanceEficas_ssIhm_reecrit(code=None,fichier=None,ssCode=None,version=None,ou=None,cr=False,debug=False,leger=False,langue='ang'):
 257     print ('deprecated')
 258     #print 'lanceEficas_ssIhm_reecrit', fichier
 259     monEditeur=lanceEficas_ssIhm(code,fichier,ssCode,version,langue=langue)
 260     if ou == None :
 261         fileName=fichier.split(".")[0]+"_reecrit.comm"
 262         fn=fichier.split(".")[0]+"_cr.txt"
 263     else :
 264         f=fichier.split(".")[0]+"_reecrit.comm"
 265         f1=os.path.basename(f)
 266         fn=fichier.split(".")[0]+"_cr.txt"
 267         f2=os.path.basename(fn)
 268         fileName=os.path.join(ou,f1)
 269         fileCr=os.path.join(ou,f2)
 270     debut=False
 271     if debug :
 272         import cProfile, pstats, StringIO
 273         pr = cProfile.Profile()
 274         pr.enable()
 275         monEditeur.saveFileAs(fileName=fileName)
 276         pr.disable()
 277         s = StringIO.StringIO()
 278         sortby = 'cumulative'
 279         ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
 280         ps.print_stats()
 281         print (s.getValue())
 282
 283     elif not leger : monEditeur.saveFileAs(fileName=fileName)
 284     else : monEditeur.saveFileLegerAs(fileName=fileName)
 285     if cr:
 286         f = open(fileCr, 'w')
 287         f.write(str(monEditeur.jdc.report()))
 288         f.close()
 289
 290 def lanceEficas_param(code='Adao',fichier=None,version='V0',macro='ASSIMILATION_STUDY'):
 291     """
 292         Lance l'appli EFICAS pour trouver les noms des groupes
 293     """
 294     print ('deprecated')
 295     # Analyse des arguments de la ligne de commande
 296     from Editeur  import session
 297     options=session.parse(sys.argv)
 298
 299     from .qtEficas import Appli
 300
 301     from .ssIhm  import QWParentSSIhm
 302     Eficas=QWParentSSIhm(code,version)
 303
 304     from . import readercata
 305     if not hasattr ( Eficas, 'readercata'):
 306         monreadercata  = readercata.ReaderCata( parent, Eficas )
 307         Eficas.readercata=monreadercata
 308
 309     from .editor import JDCEditor
 310     monEditeur=JDCEditor(Eficas,fichier)
 311     texte=loadJDC(fichier)
 312     parameters=getJdcParameters(texte,macro)
 313     return parameters
 314
 315
 316 def getJdcParameters(jdc,macro):
 317     """
 318     This function converts the data from the specified macro of the
 319     specified jdc text to a python dictionnary whose keys are the
 320     names of the data of the macro.
 321     """
 322     print ('deprecated')
 323     context = {}
 324     source = "def args_to_dict(**kwargs): return kwargs \n"
 325     source+= "%s = _F = args_to_dict          \n"%macro
 326     source+= "parameters="+jdc+"                        \n"
 327     source+= "context['parameters'] = parameters         \n"
 328     code = compile(source, 'file.py', 'exec')
 329     eval(code)
 330     parameters = context['parameters']
 331     return parameters
 332
 333 def loadJDC(filename):
 334     """
 335     This function loads the text from the specified JdC file. A JdC
 336     file is the persistence file of Eficas (*.comm).
 337     """
 338     print ('deprecated')
 339     fcomm=open(filename,'r')
 340     jdc = ""
 341     for line in fcomm.readlines():
 342         if not (line[0]=='#'):
 343             jdc+="%s"%line
 344
 345     # Warning, we have to make sure that the jdc comes as a simple
 346     # string without any extra spaces/newlines
 347     return jdc.strip()
 348
 349 if __name__ == "__main__":
 350     import sys
 351     sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..')))
 352     lanceEficas(code=None,multi=True)