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