Aster/Cata/cataSTA9/Macro/Sensibilite.py

   1 #@ MODIF Sensibilite Macro  DATE 19/11/2007   AUTEUR COURTOIS M.COURTOIS
   2 # -*- coding: iso-8859-1 -*-
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
   6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   9 # (AT YOUR OPTION) ANY LATER VERSION.
  10 #
  11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  15 #
  16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  18 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  19 # ======================================================================
  20
  21 """
  22 Module traite de la gestion des concepts sensibles :
  23    - classe permettant de stocker les noms des concepts et leurs dérivées
  24    - corps de la macro MEMO_NOM_SENSI
  25 """
  26
  27 # protection pour eficas
  28 try:
  29    import aster
  30    from Utilitai.Utmess import  UTMESS
  31 except:
  32    pass
  33
  34 _VIDE_ = '????????'
  35
  36 #-------------------------------------------------------------------------------
  37 def _force_list(obj):
  38    """Impose le type list."""
  39    if obj is not None and not type(obj) in (list, tuple):
  40       obj = (obj,)
  41    return obj
  42
  43
  44 #-------------------------------------------------------------------------------
  45 class MEMORISATION_SENSIBILITE:
  46    """Classe pour la mémorisation des concepts sensibles et leurs dérivées.
  47    """
  48    def __init__(self, debug=False):
  49       """Initialisation de la structure
  50       """
  51       self._debug = debug
  52       # dictionnaire de correspondance : ('nom concept', 'nom parasensi') : 'nom compose'
  53       self._corr = {}
  54       # idem que _corr mais, pour les commandes principales, on stocke sd elle-meme
  55       self._cosd = {}
  56       self._nsnp = {}   # l'inverse
  57       # dictionnaire donnant les 3 tuples de mots-clés, valeurs, mots-clés facteurs
  58       self._mcle = {}
  59
  60
  61    def key(self, nosimp, nopase):
  62       """Retourne la clé d'accès aux dictionnaires
  63       """
  64       if not type(nosimp) in (str, unicode) or not type(nopase) in (str, unicode) or \
  65          len(nosimp.strip()) > 8 or len(nopase.strip()) > 8:
  66             UTMESS('F', 'SENSIBILITE_57', valk=(nosimp, nopase))
  67       return nosimp.strip(), nopase.strip()
  68
  69
  70    def set(self, nosimp, nopase, nocomp=None, limocl=None, livale=None, limofa=None,
  71            verbose=False):
  72       """On renseigne la structure de mémorisation : CHOIX='E'
  73       """
  74       key = self.key(nosimp, nopase)
  75       if self._corr.has_key(key):
  76          UTMESS('F', 'SENSIBILITE_90', valk=(nosimp, nopase))
  77       limocl = _force_list(limocl) or ()
  78       livale = _force_list(livale) or ()
  79       limofa = _force_list(limofa) or ()
  80       if not (len(limocl) == len(livale) == len(limofa)):
  81          UTMESS('F', 'SENSIBILITE_97')
  82
  83       if nocomp is None:
  84          nocomp = aster.get_nom_concept_unique('S')
  85       # on ne conserve que le nom (au moins pour le moment)
  86       if type(nocomp) != str:
  87          sd = nocomp
  88          nocomp = nocomp.nom
  89       else:
  90          sd = None
  91       self._corr[key] = nocomp
  92       self._cosd[nocomp] = sd
  93       self._nsnp[nocomp] = key
  94       self._mcle[key] = (limocl, livale, limofa)
  95
  96       if verbose or self._debug:
  97          UTMESS('I', 'SENSIBILITE_58', valk=(nosimp, nopase, nocomp))
  98          if len(limocl) != 0:
  99             UTMESS('I', 'SENSIBILITE_59', valk=(str(limocl), str(livale), str(limofa)))
 100
 101
 102    def get_nocomp(self, nosimp, nopase):
 103       """On récupère le nom composé associé à un nom simple.
 104       """
 105       key = self.key(nosimp, nopase)
 106       nocomp = self._corr.get(key, _VIDE_)
 107       if self._debug:
 108          print '<DBG> memo_sensi.get_nocomp'
 109          print '      nosimp, nopase = "%s", "%s"' % (nosimp, nopase)
 110          print '      nom composé    = "%s"' % nocomp
 111       return nocomp
 112
 113
 114    def get_nsnp(self, nocomp):
 115       """On récupère le nom du concept et le parasensi associé au nom composé fourni.
 116       """
 117       key = self._nsnp.get(nocomp, (_VIDE_, _VIDE_))
 118       if self._debug:
 119          print '<DBG> memo_sensi.get_nsnp'
 120          print '      nom composé    = "%s"' % nocomp
 121          print '      nosimp, nopase = "%s", "%s"' % key
 122       return nocomp
 123
 124
 125    def get_mcle(self, nosimp, nopase):
 126       """On récupère les mots-clés associés à un couple ('nom concept', 'nom parasensi')
 127       """
 128       key = self.key(nosimp, nopase)
 129       tup3 = self._mcle.get(key, ((), (), ()) )
 130       if self._debug:
 131          print tup3
 132          print '<DBG> memo_sensi.get_mcle      nbmocl =',len(tup3[0])
 133          print '      nosimp, nopase = "%s", "%s"' % (nosimp, nopase)
 134          print '      mots-clés      = ', tup3
 135       return tup3
 136
 137
 138    def psinfo(self, nosimp):
 139       """Pendant de l'ex-routine psnosd : retour selon le type de `nosimp`.
 140       """
 141       # est-ce une structure dérivée ?
 142       if nosimp in self._nsnp.keys():
 143          t_couples = self._nsnp[nosimp]
 144          ideriv = 1
 145       else:
 146          t_couples = self.get_deriv(nosimp)
 147          ideriv = 0
 148       # on met le tuple des couples à plat : un tuple de longueur double
 149       l_res = []
 150       for coupl in t_couples:
 151          l_res.extend(coupl)
 152       t_res = tuple(l_res)
 153       if self._debug:
 154          print '<DBG> memo_sensi.psinfo'
 155          print '      nosimp = "%s"' % nosimp
 156          print '      ideriv = ', ideriv
 157          print '      result = ', t_res
 158       return ideriv, t_res
 159
 160
 161    def get_deriv(self, nosimp):
 162       """On récupère la liste des couples ('nom composé', 'nom parasensi') associé à
 163       un nom simple.
 164       """
 165       res = []
 166       # liste des clés d'accès concernant `nosimp`.
 167       l_key = [(ns, np) for ns, np in self._corr.keys() if ns == nosimp.strip()]
 168       for ns, np in l_key:
 169          res.append((self._corr[ns, np], np))
 170       return tuple(res)
 171
 172
 173    def get_nom_sd_princ(self):
 174       """Retourne la liste des noms des sd dérivées produites par les commandes principales.
 175       """
 176       return tuple(self._cosd.keys())
 177
 178
 179    def delete(self, nosimp, nopase):
 180       """On récupère les mots-clés associés à un couple ('nom concept', 'nom parasensi')
 181       """
 182       key = self.key(nosimp, nopase)
 183       nocomp = self.get_nocomp(nosimp, nopase)
 184       if nocomp != _VIDE_:
 185          del self._corr[key]
 186          del self._cosd[nocomp]
 187          del self._mcle[key]
 188          del self._nsnp[nocomp]
 189
 190
 191 #-------------------------------------------------------------------------------
 192 #-------------------------------------------------------------------------------
 193 def memo_nom_sensi_ops(self, NOM, **args):
 194    """Macro MEMO_NOM_SENSI.
 195    Transitoire : l'appel aux méthodes de MEMORISATION_SENSIBILITE devraient
 196       à terme etre fait directement sans introduire de commandes MEMO_NOM_SENSI.
 197
 198    Faut-il traiter les mots-clés NOM_ZERO et NOM_UN ?
 199    Il me semble que NOM_COMPOSE est toujours présent : obligatoire
 200    """
 201    import aster
 202
 203    ier=0
 204    # La macro compte pour 1 dans la numerotation des commandes
 205    self.set_icmd(1)
 206
 207    dNOM = NOM[0].cree_dict_valeurs(NOM[0].mc_liste)
 208
 209    nosimp = dNOM['NOM_SD']
 210    nopase = dNOM['PARA_SENSI'].nom
 211    nocomp = dNOM['NOM_COMPOSE']
 212
 213    self.jdc.memo_sensi.set(nosimp, nopase, nocomp,
 214                            dNOM['MOT_CLE'], dNOM['VALEUR'], dNOM['MOT_FACT'],
 215                            verbose=True)
 216
 217    # s'il faut déclarer le concept dérivé dans le jdc
 218    if dNOM['TYPE_SD_DERIV']:
 219       self.DeclareOut('nocomp', dNOM['NOM_COMPOSE'])
 220       # enregistrement dans le tableau des concepts jeveux
 221       icmdt = aster.co_register_jev(dNOM['NOM_COMPOSE'].nom, dNOM['TYPE_SD_DERIV'].upper(), 'MEMO_NOM_SENSI')
 222
 223    return ier
 224
 225
 226