-#@ MODIF N_CONVERT Noyau DATE 07/09/2009 AUTEUR COURTOIS M.COURTOIS
+#@ MODIF N_CONVERT Noyau DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS
# -*- coding: iso-8859-1 -*-
# RESPONSABLE COURTOIS M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
Module de conversion des valeurs saisies par l'utilisateur après vérification.
"""
-# -----------------------------------------------------------------------------
-def is_int(real):
+from N_types import is_int, is_float, is_enum
+
+
+def has_int_value(real):
"""Est-ce que 'real' a une valeur entière ?
"""
return abs(int(real) - real) < 1.e-12
-# -----------------------------------------------------------------------------
+
class Conversion:
"""Conversion de type.
"""
def convert(self, obj):
"""Filtre liste
"""
- in_type = type(obj)
- if in_type not in (list, tuple):
+ in_as_enum = is_enum(obj)
+ if not in_as_enum:
obj = (obj,)
result = []
for o in obj:
result.append(self.function(o))
- if in_type not in (list, tuple):
+ if not in_as_enum:
return result[0]
else:
# ne marche pas avec MACR_RECAL qui attend une liste et non un tuple
def function(self, o):
raise NotImplementedError, 'cette classe doit être dérivée'
-# -----------------------------------------------------------------------------
+
class TypeConversion(Conversion):
"""Conversion de type
"""
def __init__(self, typ):
Conversion.__init__(self, 'type', typ)
-# -----------------------------------------------------------------------------
+
class IntConversion(TypeConversion):
"""Conversion en entier
"""
TypeConversion.__init__(self, 'I')
def function(self, o):
- if type(o) is float and is_int(o):
+ if is_float(o) and has_int_value(o):
o = int(o)
return o
-# -----------------------------------------------------------------------------
+
class FloatConversion(TypeConversion):
"""Conversion de type
"""
TypeConversion.__init__(self, 'R')
def function(self, o):
- if type(o) in (int, float, long):
+ if is_float(o):
o = float(o)
return o
-# -----------------------------------------------------------------------------
+
_convertI = IntConversion()
_convertR = FloatConversion()
-#@ MODIF N_VALIDATOR Noyau DATE 09/10/2007 AUTEUR COURTOIS M.COURTOIS
+#@ MODIF N_VALIDATOR Noyau DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS
# -*- coding: iso-8859-1 -*-
+# RESPONSABLE COURTOIS M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG
implanter le concept de validateur dans Accas
"""
import types
-import string
import traceback
from N_ASSD import ASSD
+from N_types import is_int, is_float_or_int, is_complex, is_number, is_str, is_enum
+
class ValError(Exception):pass
class ListProtocol(Protocol):
"""Verificateur de protocole liste : convertit un objet quelconque en liste pour validation ultérieure"""
def default(self,obj):
- if type(obj) == types.TupleType :
+ if type(obj) is tuple:
if len(obj) > 0 and obj[0] in ('RI','MP'):
#il s'agit d'un complexe ancienne mode. La cardinalite vaut 1
return (obj,)
else:
return obj
- elif type(obj) == types.ListType :
+ elif type(obj) is list:
return obj
- elif obj == None :
+ elif obj == None:
# pas de valeur affecte. La cardinalite vaut 0
return obj
- elif type(obj) == types.StringType :
+ elif is_str(obj):
#il s'agit d'une chaine. La cardinalite vaut 1
return (obj,)
else:
listProto=ListProtocol("list")
+
class TypeProtocol(PProtocol):
"""Verificateur de type parmi une liste de types possibles"""
#pas de registre par instance. Registre unique pour toutes les instances de TypeProtocol
self.typ=typ
def default(self,obj,typ):
+ help = ""
for type_permis in typ:
if type_permis == 'R':
- if type(obj) in (types.IntType,types.FloatType,types.LongType):return obj
+ if is_float_or_int(obj): return obj
elif type_permis == 'I':
- if type(obj) in (types.IntType,types.LongType):return obj
+ if is_int(obj): return obj
elif type_permis == 'C':
- if self.is_complexe(obj):return obj
+ if self.is_complexe(obj): return obj
elif type_permis == 'TXM':
- if type(obj)==types.StringType:return obj
+ if is_str(obj): return obj
elif type_permis == 'shell':
- if type(obj)==types.StringType:return obj
+ if is_str(obj): return obj
elif type(type_permis) == types.ClassType or isinstance(type_permis,type):
- if self.is_object_from(obj,type_permis):return obj
- elif type_permis == 'Fichier' :
- import os
- if len(typ) > 2 and typ[2] == "Sauvegarde":
- if os.path.isdir(os.path.dirname(obj)):
- return obj
- else:
- raise ValError("%s n'est pas un répertoire valide" %
- os.path.dirname(obj))
- else:
- if os.path.isfile(obj):return obj
- else : raise ValError("%s n'est pas un fichier valide" % repr(obj))
+ try:
+ if self.is_object_from(obj,type_permis): return obj
+ except Exception, err:
+ help = str(err)
elif type(type_permis) == types.InstanceType or isinstance(type_permis,object):
try:
- if type_permis.__convert__(obj) : return obj
- except:
- pass
+ if type_permis.__convert__(obj): return obj
+ except Exception, err:
+ help = str(err)
else:
print "Type non encore géré %s" %`type_permis`
-
- raise ValError("%s (de type %s) n'est pas d'un type autorisé: %s" % (repr(obj),type(obj),typ))
+ raise ValError("%s (de type %s) n'est pas d'un type autorisé: %s %s" % (repr(obj),type(obj),typ, help))
def is_complexe(self,valeur):
""" Retourne 1 si valeur est un complexe, 0 sinon """
- if type(valeur) in (types.ComplexType,types.IntType,types.FloatType,types.LongType):
- # Pour permettre l'utilisation de complexes Python
+ if is_number(valeur):
+ # Pour permettre l'utilisation de complexes Python (accepte les entiers et réels)
return 1
- elif type(valeur) != types.TupleType :
+ elif type(valeur) != tuple :
# On n'autorise pas les listes pour les complexes
return 0
elif len(valeur) != 3:
else:
# Un complexe doit etre un tuple de longueur 3 avec 'RI' ou 'MP' comme premiere
# valeur suivie de 2 reels.
- if string.strip(valeur[0]) in ('RI','MP'):
+ if valeur[0].strip() in ('RI','MP'):
try:
v1=reelProto.adapt(valeur[1]),reelProto.adapt(valeur[2])
return 1
try:
v= convert(objet)
return v is not None
+ except ValueError, err:
+ raise
except:
return 0
# On accepte les instances de la classe et des classes derivees
raise ValError("La valeur : %s ne fait pas partie des choix possibles %s" % (repr(obj),into) )
else:
#on est dans le cas d'un ensemble continu de valeurs possibles (intervalle)
- if type(obj) in (types.IntType,types.FloatType,types.LongType) :
+ if is_float_or_int(obj):
if val_min == '**': val_min = obj -1
if val_max == '**': val_max = obj +1
if obj < val_min or obj > val_max :
self.max=max
def __convert__(self,valeur):
- if type(valeur) == types.StringType and self.min <= len(valeur) <= self.max:return valeur
+ if is_str(valeur) and self.min <= len(valeur) <= self.max:return valeur
raise ValError("%s n'est pas une chaine de longueur comprise entre %s et %s" % (valeur,self.min,self.max))
def __repr__(self):
fait appel à la méthode convert_item sur chaque élément de la
liste.
"""
- if type(valeur) in (types.ListType,types.TupleType):
+ if is_enum(valeur):
for val in valeur:
self.convert_item(val)
return valeur
liste. Si valeur est un paramètre, on utilise sa valeur effective
valeur.valeur.
"""
- if type(valeur) in (types.ListType,types.TupleType):
+ if is_enum(valeur):
for val in valeur:
if not self.verif_item(val):
return 0
"""
registry={}
def __init__(self,elem=()):
- if type(elem) not in (types.ListType,types.TupleType): elem=(elem,)
+ if not is_enum(elem): elem=(elem,)
Valid.__init__(self,elem=elem)
self.elem=elem
self.cata_info=""
return 1
def verif(self,valeur):
- if type(valeur) not in (types.ListType,types.TupleType):
+ if not is_enum(valeur):
liste=list(valeur)
else:
liste=valeur
return 1
def verif(self,valeur):
- if type(valeur) in (types.ListType,types.TupleType):
+ if is_enum(valeur):
liste=list(valeur)
for val in liste:
if liste.count(val)!=1 : return 0
return 0
def default(self,valeur,low,high):
- if type(valeur) != types.StringType :
+ if not is_str(valeur):
raise ValError("%s n'est pas une string" % repr(valeur))
if valeur[0]=="'" and valeur[-1]=="'" :
low=low+2
Elle verifie qu'au moins un des validateurs de la liste valide la valeur
"""
def __init__(self,validators=()):
- if type(validators) not in (types.ListType,types.TupleType):
+ if not is_enum(validators):
validators=(validators,)
self.validators=[]
for validator in validators:
Elle verifie que tous les validateurs de la liste valident la valeur
"""
def __init__(self,validators=()):
- if type(validators) not in (types.ListType,types.TupleType):
+ if not is_enum(validators):
validators=(validators,)
self.validators=[]
for validator in validators:
for validator in validators:
if type(validator) == types.FunctionType:
valids.append(FunctionVal(validator))
- elif type(validator) == types.TupleType:
+ elif type(validator) is tuple:
valids.append(OrVal(do_liste(validator)))
- elif type(validator) == types.ListType:
+ elif type(validator) is list:
valids.append(AndVal(do_liste(validator)))
else:
valids.append(validator)
def validatorFactory(validator):
if type(validator) == types.FunctionType:
return FunctionVal(validator)
- elif type(validator) == types.TupleType:
+ elif type(validator) is tuple:
return OrVal(do_liste(validator))
- elif type(validator) == types.ListType:
+ elif type(validator) is list:
return AndVal(do_liste(validator))
else:
return validator
return []
def convert(self,valeur):
- if type(valeur) in (types.ListType,types.TupleType):
+ if is_enum(valeur):
l=len(valeur)
elif valeur is None:
l=0
return 1
def verif(self,valeur):
- if type(valeur) in (types.ListType,types.TupleType):
+ if is_enum(valeur):
if self.max != '**' and len(valeur) > self.max:return 0
if self.min != '**' and len(valeur) < self.min:return 0
return 1
return valeur % 2 == 0
def verif(self,valeur):
- if type(valeur) in (types.ListType,types.TupleType):
+ if is_enum(valeur):
for val in valeur:
if val % 2 != 0:return 0
return 1
Susceptible de remplacer l attribut "into" dans les catalogues
"""
def __init__(self,into=()):
- if type(into) not in (types.ListType,types.TupleType): into=(into,)
+ if not is_enum(into):
+ into=(into,)
self.into=into
self.cata_info=""
Cette fonction est un validateur. Elle verifie que la valeur passee
est bien un nombre impair.
"""
- if type(valeur) in (types.ListType,types.TupleType):
+ if is_enum(valeur):
for val in valeur:
if val % 2 != 1:return 0
return 1
return "valeur %s pour la somme des cles A et B " % self.somme
def verif(self,valeur):
- if type(valeur) in (types.ListType,types.TupleType):
+ if is_enum(valeur):
for val in valeur:
if not val.has_key("A"):return 0
if not val.has_key("B"):return 0
--- /dev/null
+#@ MODIF N_types Noyau DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+
+"""
+ Ce module contient des fonctions utilitaires pour tester les types
+"""
+
+from N_ASSD import ASSD
+
+
+# use isinstance() instead of type() because objects returned from numpy arrays
+# inherit from python scalars but are numpy.float64 or numpy.int32...
+def is_int(obj):
+ return isinstance(obj, int) or type(obj) is long
+
+def is_float(obj):
+ return isinstance(obj, float)
+
+def is_complex(obj):
+ return isinstance(obj, complex)
+
+def is_float_or_int(obj):
+ return is_float(obj) or is_int(obj)
+
+def is_number(obj):
+ return is_float_or_int(obj) or is_complex(obj)
+
+def is_str(obj):
+ return type(obj) in (str, unicode)
+
+def is_list(obj):
+ return type(obj) is list
+
+def is_tuple(obj):
+ return type(obj) is tuple
+
+def is_enum(obj):
+ return is_list(obj) or is_tuple(obj)
+
+def is_assd(obj):
+ return isinstance(obj, ASSD)
+
+
