Extensions/parametre.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2021   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 """
  21     Ce module contient la classe PARAMETRE qui sert a definir
  22     des objets parametres qui sont comprehensibles et donc affichables
  23     par EFICAS.
  24     Ces objets sont crees a partir de la modification du fichier de commandes
  25     de l'utilisateur par le parseur de fichiers Python
  26 """
  27
  28 # import de modules Python
  29 from __future__ import absolute_import
  30 from __future__ import print_function
  31 try :
  32     from builtins import str
  33     from builtins import object
  34 except : pass
  35
  36 import types
  37 from math import *
  38 import traceback
  39
  40 # import de modules Eficas
  41 from Noyau.N_CR import CR
  42 from Noyau.N_UserASSD import UserASSD
  43 from Noyau.N_UserASSDMultiple import UserASSDMultiple
  44 from Noyau import N_OBJECT
  45 from Ihm import I_OBJECT
  46 from .param2 import *
  47 from Ihm import CONNECTOR
  48 from Extensions.i18n import tr
  49
  50
  51 class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
  52     """
  53        Cette classe permet de creer des objets de type PARAMETRE
  54        cad des affectations directes dans le jeu de commandes (ex: a=10.)
  55        qui sont interpretees par le parseur de fichiers Python.
  56        Les objets ainsi crees constituent des parametres pour le jdc
  57     """
  58
  59     nature = 'PARAMETRE'
  60     idracine = 'param'
  61
  62     def __new__(cls,nom,valeur=None):
  63       # on est en relecture du .comm: l objet a ete detecte comme parametre par le parsing
  64       # mais il  s agit d une reference, une UserASDD
  65         if (issubclass(valeur.__class__, UserASSDMultiple)):
  66             valeur.initialiseNom(nom)
  67             return valeur
  68         if (issubclass(valeur.__class__, UserASSD)):
  69             valeur.initialiseNom(nom)
  70             return valeur
  71         try :
  72             return super(PARAMETRE, cls).__new__(cls,*args,**kwargs)
  73         except :
  74             return super(PARAMETRE, cls).__new__(cls)
  75
  76
  77     def __init__(self,nom,valeur=None):
  78       #print ('__init__ de parametre pour', nom,valeur)
  79         self.nom = nom
  80         # La classe PARAMETRE n'a pas de definition : on utilise self pour
  81         # completude
  82         self.definition=self
  83         # parent ne peut etre qu'un objet de type JDC
  84         self.jdc = self.parent = CONTEXT.getCurrentStep()
  85         self.niveau=self.parent.niveau
  86         self.actif=1
  87         self.state='undetermined'
  88         self.register()
  89         self.dict_valeur=[]
  90         #self.valeur = self.interpreteValeur(valeur)
  91         #self.val=valeur
  92         self.valeur = valeur
  93         self.val=repr(valeur)
  94         self.fenetreIhm=None
  95
  96     def interpreteValeur(self,val):
  97         """
  98         Essaie d'interpreter val (chaine de caracteres)comme :
  99         - un entier
 100         - un reel
 101         - une chaine de caracteres
 102         - une liste d'items d'un type qui precede
 103         Retourne la valeur interpretee
 104         """
 105         #if not val : return None
 106         valeur = None
 107
 108         if type(val) == list:
 109         # Un premier traitement a ete fait lors de la saisie
 110         # permet de tester les parametres qui sont des listes
 111             l_new_val = []
 112             for v in val :
 113                 try :
 114                     valeur=eval(str(v))
 115                     l_new_val.append(v)
 116                 except :
 117                     return None
 118             return l_new_val
 119
 120         if type(val) == bytes or  type(val) == str:
 121             # on tente l'evaluation dans un contexte fourni par le parent s'il existe
 122             if self.parent:
 123                 valeur=self.parent.evalInContext(val,self)
 124             else:
 125                 try :
 126                     valeur = eval(val)
 127                 except:
 128                     #traceback.print_exc()
 129                     pass
 130         #PN je n ose pas modifier je rajoute
 131         # refus des listes heterogenes : ne dvrait pas etre la
 132         if valeur != None :
 133             if type(valeur) == tuple:
 134                 l_new_val = []
 135                 typ = None
 136                 for v in valeur :
 137                     if not typ:
 138                         typ = type(v)
 139                     else:
 140                         if type(v) != typ :
 141                             # la liste est heterogene --> on refuse d'interpreter
 142                             #  self comme une liste
 143                             # on retourne la string initiale
 144                             print(('liste heterogene ',val))
 145                             return val
 146                     l_new_val.append(v)
 147                 return tuple(l_new_val)
 148
 149         if valeur != None :
 150             if type(valeur).__name__ == 'list':
 151                 self.dict_valeur=[]
 152                 for i in range(len(valeur)):
 153                     self.dict_valeur.append(valeur[i])
 154             return valeur
 155         # on retourne val comme une string car on n'a pas su l'interpreter
 156         return val
 157
 158     def getValeurs(self):
 159         valeurretour=[]
 160         if self.dict_valeur != []:
 161             for val in self.dict_valeur:
 162                 valeurretour.append(val)
 163         else:
 164             valeurretour.append(self.valeur)
 165         return valeurretour
 166
 167     def setValeur(self,new_valeur):
 168         """
 169         Remplace la valeur de self par new_valeur interpretee
 170         """
 171         self.valeur = self.interpreteValeur(new_valeur)
 172         self.val=repr(self.valeur)
 173         self.parent.updateConceptAfterEtape(self,self)
 174         self.initModif()
 175
 176     def setNom(self,new_nom):
 177         """
 178         Change le nom du parametre
 179         """
 180         self.initModif()
 181         self.nom=new_nom
 182         self.finModif()
 183
 184     def initModif(self):
 185         """
 186         Methode qui declare l'objet courant comme modifie et propage
 187         cet etat modifie a ses ascendants
 188         """
 189         self.state = 'modified'
 190         if self.parent:
 191             self.parent.initModif()
 192
 193     def getJdcRoot(self):
 194         if self.parent:
 195             return self.parent.getJdcRoot()
 196         else:
 197             return self
 198
 199     def register(self):
 200         """
 201         Enregistre le parametre dans la liste des etapes de son parent (JDC)
 202         """
 203         self.parent.registerParametre(self)
 204         self.parent.register(self)
 205
 206     def isValid(self,cr='non'):
 207         """
 208         Retourne 1 si self est valide, 0 sinon
 209         Un parametre est considere comme valide si :
 210           - il a un nom
 211           - il a une valeur
 212         """
 213         if self.nom == '' :
 214             if cr == 'oui':
 215                 self.cr.fatal(tr("Pas de nom donne au parametre "))
 216             return 0
 217         else:
 218             if self.valeur == None :
 219                 if cr == 'oui' :
 220                     self.cr.fatal(tr("Le parametre %s ne peut valoir None" , self.nom))
 221                 return 0
 222         return 1
 223
 224     def isOblig(self):
 225         """
 226         Indique si self est obligatoire ou non : retourne toujours 0
 227         """
 228         return 0
 229
 230     def isRepetable(self):
 231         """
 232         Indique si self est repetable ou non : retourne toujours 1
 233         """
 234         return 1
 235
 236     def listeMcPresents(self):
 237         return []
 238
 239     def supprime(self):
 240         """
 241         Methode qui supprime toutes les boucles de references afin que
 242         l'objet puisse etre correctement detruit par le garbage collector
 243         """
 244         self.parent = None
 245         self.jdc = None
 246         self.definition=None
 247         self.niveau=None
 248
 249     def active(self):
 250         """
 251         Rend l'etape courante active.
 252         Il faut ajouter le parametre au contexte global du JDC
 253         """
 254         self.actif = 1
 255         try:
 256             self.jdc.appendParam(self)
 257         except:
 258             pass
 259         CONNECTOR.Emit(self,"add",None)
 260         CONNECTOR.Emit(self,"valid")
 261
 262     def inactive(self):
 263         """
 264         Rend l'etape courante inactive
 265         Il faut supprimer le parametre du contexte global du JDC
 266         """
 267         self.actif = 0
 268         self.jdc.delParam(self)
 269         self.jdc.deleteConceptAfterEtape(self,self)
 270         CONNECTOR.Emit(self,"supp",None)
 271         CONNECTOR.Emit(self,"valid")
 272
 273     def isActif(self):
 274         """
 275         Booleenne qui retourne 1 si self est actif, 0 sinon
 276         """
 277         return self.actif
 278
 279     def setAttribut(self,nom_attr,new_valeur):
 280         """
 281         Remplace la valeur de self.nom_attr par new_valeur)
 282         """
 283         if hasattr(self,nom_attr):
 284             setattr(self,nom_attr,new_valeur)
 285             self.initModif()
 286
 287     def supprimeSdProds(self):
 288         """
 289         Il faut supprimer le parametre qui a ete entre dans la liste des
 290         parametres du JDC
 291         """
 292         self.jdc.deleteParam(self)
 293         self.parent.deleteConcept(self)
 294
 295     def updateContext(self,d):
 296         """
 297         Update le dictionnaire d avec le parametre que produit self
 298         """
 299         d[self.nom]=self
 300
 301     def __repr__(self):
 302         """
 303             Donne un echo de self sous la forme nom = valeur
 304         """
 305         if type(self.valeur) == bytes or  type(self.valeur) == str :
 306             if self.valeur.find('\n') == -1:
 307                 # pas de retour chariot, on utilise repr
 308                 return self.nom+' = '+ repr(self.valeur)
 309             elif self.valeur.find('"""') == -1:
 310                 # retour chariot mais pas de triple ", on formatte
 311                 return self.nom+' = """'+self.valeur+'"""'
 312             else:
 313                 return self.nom+' = '+ repr(self.valeur)
 314         else:
 315             if type(self.valeur) == list :
 316                 aRetourner=self.nom+' = ['
 317                 for l in self.valeur :
 318                     aRetourner=aRetourner+str(l) +","
 319                 aRetourner=aRetourner[0:-1]+']'
 320                 return aRetourner
 321             return self.nom+' = '+ str(self.valeur)
 322
 323     def __str__(self):
 324         """
 325             Retourne le nom du parametre comme representation de self
 326         """
 327         return self.nom
 328
 329     def getSdprods(self,nom_sd):
 330         """
 331             Retourne les concepts produits par la commande
 332         """
 333         return None
 334
 335     def report(self):
 336         """ Genere l'objet rapport (classe CR) """
 337         self.cr=CR()
 338         self.isValid(cr='oui')
 339         return self.cr
 340
 341     def ident(self):
 342         """
 343         Retourne le nom interne associe a self
 344         Ce nom n'est jamais vu par l'utilisateur dans EFICAS
 345         """
 346         return self.nom
 347
 348     def deleteConcept(self,sd):
 349         pass
 350
 351     def replaceConcept(self,old_sd,sd):
 352         pass
 353
 354     def verifConditionBloc(self):
 355         """
 356             Evalue les conditions de tous les blocs fils possibles
 357             (en fonction du catalogue donc de la definition) de self et
 358             retourne deux listes :
 359               - la premiere contient les noms des blocs a rajouter
 360               - la seconde contient les noms des blocs a supprimer
 361         """
 362         return [],[]
 363
 364     def verifConditionRegles(self,liste_presents):
 365         """
 366             Retourne la liste des mots-cles a rajouter pour satisfaire les regles
 367             en fonction de la liste des mots-cles presents
 368         """
 369         return []
 370
 371     def verifExistenceSd(self):
 372         pass
 373
 374     def controlSdprods(self,d):
 375         """sans objet """
 376         pass
 377
 378     def close(self):
 379         pass
 380
 381     def resetContext(self):
 382         pass
 383
 384     def eval(self):
 385         if isinstance(self.valeur,Formula):
 386             return self.valeur.eval()
 387         else:
 388             return self.valeur
 389
 390     def __adapt__(self,validator):
 391         return validator.adapt(self.eval())
 392
 393 class COMBI_PARAMETRE(object) :
 394     def __init__(self,chainevaleur,valeur):
 395         self.chainevaleur=chainevaleur
 396         self.valeur=valeur
 397
 398     def __repr__(self):
 399         return self.chainevaleur
 400
 401     def isValid(self):
 402         if self.valeur and self.chainevaleur:
 403             return 1
 404
 405 class ITEM_PARAMETRE(object) :
 406     def __init__(self,param_pere,item=None):
 407         self.param_pere = param_pere
 408         self.item = item
 409
 410
 411     def __repr__(self):
 412         return self.param_pere.nom+'['+str(self.item)+']'
 413
 414
 415     def isValid(self):
 416         isValid = 1
 417         if self.item < 0:
 418             isValid =  0
 419         try:
 420             longueur= len(self.param_pere.dict_valeur) - 1
 421         except:
 422             longueur=0
 423         if self.item > longueur :
 424             isValid= 0
 425         return isValid