Noyau/N_BLOC.py

   1 # coding=utf-8
   2 # Copyright (C) 2007-2013   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 """
  22     Ce module contient la classe de definition BLOC
  23     qui permet de spécifier les caractéristiques des blocs de mots clés
  24 """
  25
  26 from __future__ import absolute_import
  27 from __future__ import print_function
  28 import types
  29 import sys
  30 import traceback
  31
  32 from . import N_ENTITE
  33 from . import N_MCBLOC
  34 from .N_Exception import AsException
  35 from .N_types import force_list
  36
  37
  38 class BLOC(N_ENTITE.ENTITE):
  39
  40     """
  41      Classe pour definir un bloc de mots-cles
  42
  43      Cette classe a deux attributs de classe :
  44
  45        - class_instance qui indique la classe qui devra etre utilisée
  46          pour créer l'objet qui servira à controler la conformité d'un
  47          bloc de mots-clés avec sa définition
  48        - label qui indique la nature de l'objet de définition (ici, BLOC)
  49
  50     """
  51     class_instance = N_MCBLOC.MCBLOC
  52     label = 'BLOC'
  53
  54     def __init__(self, fr="", docu="", regles=(), statut='f', condition=None,ang="",
  55                  **args):
  56         """
  57             Un bloc est caractérisé par les attributs suivants :
  58
  59               - fr   : chaine de caractere commentaire pour aide en ligne (en francais)
  60               - regles : liste d'objets de type REGLE pour vérifier la cohérence des sous-objets
  61               - statut : obligatoire ('o') ou facultatif ('f')
  62               - condition : chaine de caractère evaluable par l'interpreteur Python
  63               - entites : dictionnaire contenant les sous-objets de self (mots-clés).
  64                 La clé du dictionnaire est le nom du mot-clé et la valeur l'objet de
  65                 définition correspondant. Cet attribut est initialisé avec l'argument
  66                 args de la méthode __init__
  67
  68         """
  69         # Initialisation des attributs
  70         self.fr = fr
  71         self.ang = ang
  72         self.docu = docu
  73         if type(regles) == tuple:
  74             self.regles = regles
  75         else:
  76             self.regles = (regles,)
  77         self.statut = statut
  78         self.condition = condition
  79         self.entites = args
  80         self.affecter_parente()
  81
  82     def __call__(self, val, nom, parent=None):
  83         """
  84             Construit un objet MCBLOC a partir de sa definition (self)
  85             de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
  86         """
  87         return self.class_instance(nom=nom, definition=self, val=val, parent=parent)
  88
  89     def verif_cata(self):
  90         """
  91            Cette méthode vérifie si les attributs de définition sont valides.
  92            Les éventuels messages d'erreur sont écrits dans l'objet compte-rendu (self.cr).
  93         """
  94         self.check_fr()
  95         self.check_docu()
  96         self.check_regles()
  97         self.check_statut(into=('f', 'o'))
  98         self.check_condition()
  99         self.verif_cata_regles()
 100
 101     def verif_presence(self, dict, globs):
 102         """
 103            Cette méthode vérifie si le dictionnaire passé en argument (dict)
 104            est susceptible de contenir un bloc de mots-clés conforme à la
 105            définition qu'il porte.
 106
 107            Si la réponse est oui, la méthode retourne 1
 108
 109            Si la réponse est non, la méthode retourne 0
 110
 111            Le dictionnaire dict a pour clés les noms des mots-clés et pour valeurs
 112            les valeurs des mots-clés
 113         """
 114         # On recopie le dictionnaire pour protéger l'original
 115         dico = bloc_utils()
 116         dico.update(dict)
 117         if self.condition != None:
 118             try:
 119                 test = eval(self.condition, globs, dico)
 120                 return test
 121             except NameError:
 122                 # erreur 'normale' : un mot-clé n'est pas présent et on veut
 123                 # l'évaluer dans la condition
 124                 if CONTEXT.debug:
 125                     l = traceback.format_exception(
 126                         sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
 127                     print(("WARNING : Erreur a l'evaluation de la condition " + ''.join(l)))
 128                 return 0
 129             except SyntaxError:
 130                 # le texte de la condition n'est pas du Python correct -->
 131                 # faute de catalogue
 132                 l = traceback.format_exception(
 133                     sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
 134                 raise AsException(
 135                     "Catalogue entite : ", self.nom, ", de pere : ", self.pere.nom,
 136                     '\n', "Erreur dans la condition : ", self.condition, ''.join(l))
 137             except:
 138                 l = traceback.format_exception(
 139                     sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
 140                 raise AsException(
 141                     "Catalogue entite : ", self.nom, ", de pere : ", self.pere.nom,
 142                     '\n', "Erreur dans la condition : ", self.condition, ''.join(l))
 143         else:
 144             return 0
 145
 146
 147 def bloc_utils():
 148     """Définit un ensemble de fonctions utilisables pour écrire les
 149     conditions de BLOC."""
 150     def au_moins_un(mcsimp, valeurs):
 151         """Valide si la (ou une) valeur de 'mcsimp' est au moins une fois dans
 152         la ou les 'valeurs'. Similaire à la règle AU_MOINS_UN, 'mcsimp' peut
 153         contenir plusieurs valeurs."""
 154         test = set(force_list(mcsimp))
 155         valeurs = set(force_list(valeurs))
 156         return not test.isdisjoint(valeurs)
 157
 158     def aucun(mcsimp, valeurs):
 159         """Valide si aucune des valeurs de 'mcsimp' n'est dans 'valeurs'."""
 160         return not au_moins_un(mcsimp, valeurs)
 161
 162     return locals()