1 #@ MODIF N_VALIDATOR Noyau DATE 09/09/2003 AUTEUR DURAND C.DURAND
2 # CONFIGURATION MANAGEMENT OF EDF VERSION
3 # ======================================================================
4 # COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG
5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
8 # (AT YOUR OPTION) ANY LATER VERSION.
10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
17 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
18 # ======================================================================
20 Ce module contient toutes les classes necessaires pour
21 implanter le concept de validateur dans Accas
23 import types,exceptions
25 class ValError ( exceptions.Exception ):
30 Cette classe est la classe mere des validateurs Accas
31 Elle doit etre derivee
32 Elle ne presente que la signature des methodes
33 indispensables pour son bon fonctionnement
35 @ivar cata_info: raison de la validite ou de l'invalidite du validateur meme
36 @type cata_info: C{string}
38 def __init__(self,*tup,**args):
40 Cette methode sert a initialiser les attributs du validateur
43 raise "Must be implemented"
46 return "valeur valide"
48 def verif(self,valeur):
50 Cette methode sert a verifier si la valeur passee en argument est consideree
51 comme valide ou non par le validateur. Dans le premier cas le validateur retourne 1
52 (valide) sinon 0 (invalide).
54 @type valeur: tout type python
55 @param valeur: valeur du mot cle a valider
57 @return: indicateur de validite 1 (valide) ou 0 (invalide)
59 raise "Must be implemented"
61 def error(self,valeur):
66 Cette methode sert a realiser des verifications du validateur lui meme.
67 Elle est facultative et retourne 1 (valide) par defaut.
68 Elle retourne 0 si le validateur est lui meme invalide si par exemple ses
69 parametres de definition ne sont pas corrects.
70 La raison de l'invalidite est stockee dans l'attribut cata_info.
73 @return: indicateur de validite 1 (valide) ou 0 (invalide)
77 class RangeVal(Valid):
79 Exemple de classe validateur : verification qu'une valeur
80 est dans un intervalle.
81 Pour une liste on verifie que tous les elements sont
83 Susceptible de remplacer les attributs "vale_min" "vale_max"
86 def __init__(self,low,high):
89 self.cata_info="%s doit etre inferieur a %s" %(low,high)
92 return "valeur dans l'intervalle %s , %s" %(self.low,self.high)
94 def verif(self,valeur):
95 if type(valeur) in (types.ListType,types.TupleType):
97 if val < self.low :return 0
98 if val > self.high:return 0
101 if valeur < self.low :return 0
102 if valeur > self.high:return 0
105 def verif_cata(self):
106 if self.low > self.high : return 0
109 class CardVal(Valid):
111 Exemple de classe validateur : verification qu'une liste est
112 d'une longueur superieur a un minimum (min) et inferieure
114 Susceptible de remplacer les attributs "min" "max" dans les
117 def __init__(self,min='**',max='**'):
120 self.cata_info="%s doit etre inferieur a %s" % (min,max)
123 return "longueur comprise entre %s et %s" % (self.min,self.max)
125 def verif(self,valeur):
126 if type(valeur) in (types.ListType,types.TupleType):
127 if self.max != '**' and len(valeur) > self.max:return 0
128 if self.min != '**' and len(valeur) < self.min:return 0
131 if self.max != '**' and 1 > self.max:return 0
132 if self.min != '**' and 1 < self.min:return 0
135 def verif_cata(self):
136 if self.min != '**' and self.max != '**' and self.min > self.max : return 0
139 class PairVal(Valid):
141 Exemple de classe validateur : verification qu'une valeur
143 Pour une liste on verifie que tous les elements sont
150 return "valeur paire"
152 def verif(self,valeur):
153 if type(valeur) in (types.ListType,types.TupleType):
155 if val % 2 != 0:return 0
158 if valeur % 2 != 0:return 0
161 class EnumVal(Valid):
163 Exemple de classe validateur : verification qu'une valeur
164 est prise dans une liste de valeurs.
165 Susceptible de remplacer l attribut "into" dans les catalogues
167 def __init__(self,into=()):
168 if type(into) not in (types.ListType,types.TupleType): into=(into,)
173 return "valeur dans %s" % `self.into`
175 def verif(self,valeur):
176 if type(valeur) in (types.ListType,types.TupleType):
178 if val not in self.into:return 0
181 if valeur not in self.into:return 0
184 class NoRepeat(Valid):
186 Verification d'absence de doublons dans la liste.
192 return ": présence de doublon dans la liste"
194 def verif(self,valeur):
195 if type(valeur) in (types.ListType,types.TupleType):
198 if liste.count(val)!=1 : return 0
203 class LongStr(Valid):
205 Verification de la longueur d une chaine
207 def __init__(self,low,high):
213 return "longueur de la chaine entre %s et %s" %(self.low,self.high)
215 def verif(self,valeur):
216 if type(valeur) in (types.ListType,types.TupleType):
218 if len(val) < self.low :return 0
219 if len(val) > self.high:return 0
222 if len(valeur) < self.low :return 0
223 if len(valeur) > self.high:return 0
226 class OrdList(Valid):
228 Verification qu'une liste est croissante ou decroissante
230 def __init__(self,ord):
235 return "liste %s" % self.ord
237 def verif(self,valeur):
238 if type(valeur) in (types.ListType,types.TupleType):
239 if self.ord=='croissant':
241 for val in valeur[1:]:
245 elif self.ord=='decroissant':
247 for val in valeur[1:]:
255 CoercableFuncs = { types.IntType: int,
256 types.LongType: long,
257 types.FloatType: float,
258 types.ComplexType: complex,
259 types.UnicodeType: unicode }
261 class TypeVal(Valid):
263 Cette classe est un validateur qui controle qu'une valeur
264 est bien du type Python attendu.
265 Pour une liste on verifie que tous les elements sont du bon type.
267 def __init__(self, aType):
268 if type(aType) != types.TypeType:
272 self.coerce=CoercableFuncs[ aType ]
274 self.coerce = self.identity
277 return "valeur de %s" % self.aType
279 def identity ( self, value ):
280 if type( value ) == self.aType:
284 def verif(self,valeur):
285 if type(valeur) in (types.ListType,types.TupleType):
299 class InstanceVal(Valid):
301 Cette classe est un validateur qui controle qu'une valeur est
302 bien une instance (au sens Python) d'une classe
303 Pour une liste on verifie chaque element de la liste
305 def __init__(self,aClass):
306 if type(aClass) == types.InstanceType:
307 aClass=aClass.__class__
311 return "valeur d'instance de %s" % self.aClass.__name__
313 def verif(self,valeur):
314 if type(valeur) in (types.ListType,types.TupleType):
316 if not isinstance(val,self.aClass): return 0
318 if not isinstance(valeur,self.aClass): return 0
321 def ImpairVal(valeur):
323 Cette fonction est un validateur. Elle verifie que la valeur passee
324 est bien un nombre impair.
326 if type(valeur) in (types.ListType,types.TupleType):
328 if val % 2 != 1:return 0
331 if valeur % 2 != 1:return 0
334 ImpairVal.info="valeur impaire"
338 Cette classe est un validateur de dictionnaire (mot cle facteur ?). Elle verifie
339 que la somme des cles A et B vaut une valeur donnee
340 en parametre du validateur
342 def __init__(self,somme=10):
347 return "valeur %s pour la somme des cles A et B " % self.somme
349 def verif(self,valeur):
350 if type(valeur) in (types.ListType,types.TupleType):
352 if not val.has_key("A"):return 0
353 if not val.has_key("B"):return 0
354 if val["A"]+val["B"] != self.somme:return 0
357 if not valeur.has_key("A"):return 0
358 if not valeur.has_key("B"):return 0
359 if valeur["A"]+valeur["B"] != self.somme:return 0
362 class FunctionVal(Valid):
364 Cette classe est un validateur qui est initialise avec une fonction
366 def __init__(self,function):
367 self.function=function
370 return self.function.info
372 def verif(self,valeur):
373 return self.function(valeur)
377 Cette classe est un validateur qui controle une liste de validateurs
378 Elle verifie qu'au moins un des validateurs de la liste a valide la valeur
380 def __init__(self,validators=()):
381 if type(validators) not in (types.ListType,types.TupleType): validators=(validators,)
383 for validator in validators:
384 if type(validator) == types.FunctionType:
385 self.validators.append(FunctionVal(validator))
387 self.validators.append(validator)
391 return "\n ou ".join([v.info() for v in self.validators])
393 def verif(self,valeur):
394 for validator in self.validators:
395 v=validator.verif(valeur)
400 def verif_cata(self):
402 for validator in self.validators:
403 v=validator.verif_cata()
404 if not v :infos.append(validator.cata_info)
406 self.cata_info="\n".join(infos)
413 Cette classe est un validateur qui controle une liste de validateurs
414 Elle verifie que tous les validateurs de la liste sont positifs
416 def __init__(self,validators=()):
417 if type(validators) not in (types.ListType,types.TupleType): validators=(validators,)
419 for validator in validators:
420 if type(validator) == types.FunctionType:
421 self.validators.append(FunctionVal(validator))
423 self.validators.append(validator)
427 return " et ".join([v.info() for v in self.validators])
429 def verif(self,valeur):
430 for validator in self.validators:
431 v=validator.verif(valeur)
433 self.local_info=validator.info()
437 def verif_cata(self):
439 for validator in self.validators:
440 v=validator.verif_cata()
441 if not v :infos.append(validator.cata_info)
443 self.cata_info="\n".join(infos)
448 def do_liste(validators):
450 Convertit une arborescence de validateurs en OrVal ou AndVal
451 validators est une liste de validateurs ou de listes ou de tuples
454 for validator in validators:
455 if type(validator) == types.FunctionType:
456 valids.append(FunctionVal(validator))
457 elif type(validator) == types.TupleType:
458 valids.append(OrVal(do_liste(validator)))
459 elif type(validator) == types.ListType:
460 valids.append(AndVal(do_liste(validator)))
462 valids.append(validator)
465 def validatorFactory(validator):
466 if type(validator) == types.FunctionType:
467 return FunctionVal(validator)
468 elif type(validator) == types.TupleType:
469 return OrVal(do_liste(validator))
470 elif type(validator) == types.ListType:
471 return AndVal(do_liste(validator))