sauveVP

[tools/eficas.git] / Noyau / N_VALIDATOR.py

diff --git a/Noyau/N_VALIDATOR.py b/Noyau/N_VALIDATOR.py
index e03363fede65b824e1ed52317a190e9e9f143d87..88ecd075f1203482ec0cf815fc1e7b62de8161de 100644 (file)
--- a/Noyau/N_VALIDATOR.py
+++ b/Noyau/N_VALIDATOR.py
@@ -1,5 +1,5 @@
 # coding=utf-8
 # coding=utf-8

-# Copyright (C) 2007-2013   EDF R&D
+# Copyright (C) 2007-2015   EDF R&D

 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public


@@ -16,23 +16,31 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com

+#
+
+# ======================================================================

 
 """
    Ce module contient toutes les classes necessaires pour
    implanter le concept de validateur dans Accas
 """
 
 """
    Ce module contient toutes les classes necessaires pour
    implanter le concept de validateur dans Accas
 """

+from __future__ import absolute_import
+from __future__ import print_function
+try :
+   from builtins import str
+   from builtins import range
+   from builtins import object
+except : pass
+   

 import types
 import traceback
 import re
 import types
 import traceback
 import re

-from N_ASSD import ASSD
-from N_types import is_int, is_float_or_int, is_complex, is_number, is_str, is_sequence
-from strfunc import convert, ufmt
+from .N_ASSD import ASSD
+from .N_types import is_int, is_float_or_int, is_complex, is_number, is_str, is_sequence
+from Extensions.i18n import tr
+import six
+from six.moves import range

 
 

-try :
-  from Extensions.i18n import tr
-except :
-  def tr(txt):
-    return txt

 
 
 class ValError(Exception):
 
 
 class ValError(Exception):


@@ -48,7 +56,7 @@ def cls_mro(cls):
     return mro
 
 
     return mro
 
 

-class Protocol:
+class Protocol(object):

 
     def __init__(self, name):
         self.registry = {}
 
     def __init__(self, name):
         self.registry = {}


@@ -151,49 +159,58 @@ class TypeProtocol(PProtocol):
                 if self.is_complexe(obj):
                     return obj
             elif type_permis == 'TXM':
                 if self.is_complexe(obj):
                     return obj
             elif type_permis == 'TXM':

-                if is_str(obj):
-                    return obj
+                if is_str(obj): 
+                   return obj

             elif type_permis == 'shell':
                 if is_str(obj):
                     return obj
             elif type_permis == 'Fichier':
                 import os
             elif type_permis == 'shell':
                 if is_str(obj):
                     return obj
             elif type_permis == 'Fichier':
                 import os

-                if (len(typ) > 2 and typ[2] == "Sauvegarde") or os.path.isfile(obj):
-                    return obj
-                else:
-                    raise ValError(
-                        ufmt(_(tr(u"%s n'est pas un fichier valide")), repr(obj)))
+                try :
+                   if (len(typ) > 2 and typ[2] == "Sauvegarde") or os.path.isfile(obj):
+                      return obj
+                   else:
+                    raise ValError( "%s n'est pas un fichier valide" % repr(obj))
+                except : 
+                    raise ValError( "%s n'est pas un fichier valide" % repr(obj))
+

             elif type_permis == 'FichierNoAbs':
                 import os
                 if (len(typ) > 2 and typ[2] == "Sauvegarde") or isinstance(obj, type("")):
                     return obj
                 else:
             elif type_permis == 'FichierNoAbs':
                 import os
                 if (len(typ) > 2 and typ[2] == "Sauvegarde") or isinstance(obj, type("")):
                     return obj
                 else:

-                    raise ValError(
-                        ufmt(_(tr(u"%s n'est pas un fichier valide")), repr(obj)))
+                    raise ValError( "%s n'est pas un fichier valide" % repr(obj))
+

             elif type_permis == 'Repertoire':
                 import os
             elif type_permis == 'Repertoire':
                 import os

-                if os.path.isdir(obj):
-                    return obj
-                else:
-                    raise ValError(
-                        ufmt(_(tr(u"%s n'est pas un répertoire valide")), repr(obj)))
-            elif type(type_permis) == types.ClassType or isinstance(type_permis, type):
+                try : 
+                  if os.path.isdir(obj): return obj
+                  else: raise ValError( "%s n'est pas un repertoire valide" % repr(obj))
+                except :
+                  raise ValError( "%s n'est pas un repertoire valide" % repr(obj))
+            elif type_permis == 'FichierOuRepertoire':
+                import os
+                try : 
+                  if os.path.isdir(obj) or os.path.isfile(obj): return obj
+                  else: raise ValError( "%s n'est pas un fichier ou un repertoire valide" % repr(obj))
+                except :
+                  raise ValError( "%s n'est pas un fichier ou un repertoire valide" % repr(obj))
+            elif type(type_permis) == type or isinstance(type_permis, type):

                 try:
                     if self.is_object_from(obj, type_permis):
                         return obj
                 try:
                     if self.is_object_from(obj, type_permis):
                         return obj

-                except Exception, err:
+                except Exception as err:

                     pass
             elif type(type_permis) == types.InstanceType or isinstance(type_permis, object):
                 try:
                     if type_permis.__convert__(obj):
                         return obj
                     pass
             elif type(type_permis) == types.InstanceType or isinstance(type_permis, object):
                 try:
                     if type_permis.__convert__(obj):
                         return obj

-                except Exception, err:
+                except Exception as err:

                     pass
             else:
                     pass
             else:

-                print convert(ufmt(_(u"Type non encore géré %s"), `type_permis`))
+                print(("Type non encore gere %s" %type_permis))

         raise ValError(
         raise ValError(

-            ufmt(_(u"%s (de type %s) n'est pas d'un type autorisé: %s %s"),
-                 repr(obj), type(obj), typ, unicode(err)))
+            tr("%s (de type %s) n'est pas d'un type autorise: %s %s") % (repr(obj), type(obj), typ, err))

 
     def is_complexe(self, valeur):
         """ Retourne 1 si valeur est un complexe, 0 sinon """
 
     def is_complexe(self, valeur):
         """ Retourne 1 si valeur est un complexe, 0 sinon """


@@ -228,7 +245,7 @@ class TypeProtocol(PProtocol):
             try:
                 v = convert(objet)
                 return v is not None
             try:
                 v = convert(objet)
                 return v is not None

-            except ValueError, err:
+            except ValueError as err:

                 raise
             except:
                 return 0
                 raise
             except:
                 return 0


@@ -249,11 +266,9 @@ class CardProtocol(PProtocol):
 
     def default(self, obj, min, max):
         length = len(obj)
 
     def default(self, obj, min, max):
         length = len(obj)

-        if length < min or length > max:
+        if (length < min) or( length > max):

             raise ValError(
             raise ValError(

-                ufmt(
-                    _(tr(u"Nombre d'arguments de %s incorrect (min = %s, max = %s)")),
-                    repr(obj), min, max))
+                "Nombre d'arguments de %s incorrect (min = %s, max = %s)" % (repr(obj), min, max))

         return obj
 
 
         return obj
 
 


@@ -263,19 +278,21 @@ class IntoProtocol(PProtocol):
     # pas de registre par instance. Registre unique pour toutes les instances
     registry = {}
 
     # pas de registre par instance. Registre unique pour toutes les instances
     registry = {}
 

-    def __init__(self, name, into=None, val_min='**', val_max='**'):
+    def __init__(self, name, into=None, val_min=float('-inf'), val_max=float('inf')):
+     

         PProtocol.__init__(
             self, name, into=into, val_min=val_min, val_max=val_max)
         self.val_min = val_min
         self.val_max = val_max
 
     def default(self, obj, into, val_min, val_max):
         PProtocol.__init__(
             self, name, into=into, val_min=val_min, val_max=val_max)
         self.val_min = val_min
         self.val_max = val_max
 
     def default(self, obj, into, val_min, val_max):

+        if type(into)  ==types.FunctionType : 
+               maListeDeValeur=into()
+               into=maListeDeValeur

         if into:
             if obj not in into:
                 raise ValError(
         if into:
             if obj not in into:
                 raise ValError(

-                    ufmt(
-                        _(tr(u"La valeur : %s  ne fait pas partie des choix possibles %s")),
-                        repr(obj), into))
+                        tr("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)
         else:
             # on est dans le cas d'un ensemble continu de valeurs possibles
             # (intervalle)


@@ -286,13 +303,11 @@ class IntoProtocol(PProtocol):
                     val_max = obj + 1
                 if obj < val_min or obj > val_max:
                     raise ValError(
                     val_max = obj + 1
                 if obj < val_min or obj > val_max:
                     raise ValError(

-                        ufmt(
-                            _(tr(u"La valeur : %s est en dehors du domaine de validité [ %s , %s ]")),
-                            repr(obj), self.val_min, self.val_max))
+                     tr("La valeur : %s est en dehors du domaine de validite [ %s , %s ]") %(repr(obj), self.val_min, self.val_max))

         return obj
 
 
         return obj
 
 

-class MinStr:
+class MinStr(object):

     # exemple de classe pour verificateur de type
     # on utilise des instances de classe comme type (typ=MinStr(3,6), par
     # exemple)
     # exemple de classe pour verificateur de type
     # on utilise des instances de classe comme type (typ=MinStr(3,6), par
     # exemple)


@@ -302,15 +317,12 @@ class MinStr:
         self.max = max
 
     def __convert__(self, valeur):
         self.max = max
 
     def __convert__(self, valeur):

-        if is_str(valeur) and self.min <= len(valeur) <= self.max:
-            return valeur
+        if is_str(valeur) and self.min <= len(valeur) <= self.max: return valeur

         raise ValError(
         raise ValError(

-            ufmt(
-                _tr((u"%s n'est pas une chaine de longueur comprise entre %s et %s")),
-                valeur, self.min, self.max))
+            "%s n'est pas une chaine de longueur comprise entre %s et %s" % (valeur, self.min, self.max))

 
     def __repr__(self):
 
     def __repr__(self):

-        return ufmt(_(u"TXM de longueur entre %s et %s"), self.min, self.max)
+        return tr("TXM de longueur entre %s et %s" % (self.min, self.max))

 
 
 class Valid(PProtocol):
 
 
 class Valid(PProtocol):


@@ -322,7 +334,7 @@ class Valid(PProtocol):
          fonctionnement et dans certains cas leur comportement par défaut.
 
          @ivar cata_info: raison de la validite ou de l'invalidite du validateur meme
          fonctionnement et dans certains cas leur comportement par défaut.
 
          @ivar cata_info: raison de la validite ou de l'invalidite du validateur meme

-         @type cata_info: C{string}
+         @type cata_info: C{}

     """
     registry = {}
 
     """
     registry = {}
 


@@ -335,7 +347,7 @@ class Valid(PProtocol):
            la validation demandée par le validateur. Elle est utilisée
            pour produire le compte-rendu de validité du mot clé associé.
         """
            la validation demandée par le validateur. Elle est utilisée
            pour produire le compte-rendu de validité du mot clé associé.
         """

-        return _(u"valeur valide")
+        return "valeur valide"

 
     def aide(self):
         """
 
     def aide(self):
         """


@@ -514,7 +526,6 @@ class ListVal(Valid):
 
 
 class Compulsory(ListVal):
 
 
 class Compulsory(ListVal):

-

     """
         Validateur operationnel
         Verification de la présence obligatoire d'un élément dans une liste
     """
         Validateur operationnel
         Verification de la présence obligatoire d'un élément dans une liste


@@ -529,7 +540,7 @@ class Compulsory(ListVal):
         self.cata_info = ""
 
     def info(self):
         self.cata_info = ""
 
     def info(self):

-        return ufmt(_(u"valeur %s obligatoire"), `self.elem`)
+        return (tr(u"valeur %s obligatoire") % self.elem)

 
     def default(self, valeur, elem):
         return valeur
 
     def default(self, valeur, elem):
         return valeur


@@ -545,8 +556,7 @@ class Compulsory(ListVal):
                 elem.remove(v)
         if elem:
             raise ValError(
                 elem.remove(v)
         if elem:
             raise ValError(

-                ufmt(_tr((u"%s ne contient pas les elements obligatoires : %s ")),
-                     valeur, elem))
+                tr("%s ne contient pas les elements obligatoires : %s ") % (valeur, elem))

         return valeur
 
     def has_into(self):
         return valeur
 
     def has_into(self):


@@ -563,29 +573,126 @@ class Compulsory(ListVal):
         return 1
 
     def info_erreur_item(self):
         return 1
 
     def info_erreur_item(self):

-        return _(u"La valeur n'est pas dans la liste des choix possibles")
+        return tr("La valeur n'est pas dans la liste des choix possibles")

 
 
 
 

-class NoRepeat(ListVal):
+class Together(ListVal):
+    """
+        Validateur operationnel
+        si un des éléments est présent les autres doivent aussi l'être
+    """
+    registry = {}
+
+    def __init__(self, elem=()):
+        if not is_sequence(elem):
+            elem = (elem,)
+        Valid.__init__(self, elem=elem)
+        self.elem = elem
+        self.cata_info = ""
+
+    def info(self):
+        return (tr("%s present ensemble") % self.elem)

 
 

+    def default(self, valeur, elem):
+        return valeur
+
+    def verif_item(self, valeur):
+        return 1
+
+    def convert(self, valeur):
+        elem = list(self.elem)
+        for val in valeur:
+            v = self.adapt(val)
+            if v in elem: elem.remove(v)
+        if ( len(elem) == 0 ): return valeur
+        if len(elem) != len(list(self.elem)) :
+            raise ValError(tr("%s ne contient pas les elements devant etre presents ensemble: %s ") %( valeur, elem))
+        return valeur
+
+    def has_into(self):
+        return 1
+
+    def verif(self, valeur):
+        if not is_sequence(valeur):
+            liste = list(valeur)
+        else:
+            liste = valeur
+        compte = 0
+        for val in self.elem:
+            if val in liste: compte += 1
+        if ( compte == 0 ): return 1
+        if ( compte != len( list(self.elem) ) ): return 0
+        return 1
+
+    def info_erreur_item(self):
+        return tr("La valeur n'est pas dans la liste des choix possibles")
+
+
+class Absent(ListVal):

     """
         Validateur operationnel
     """
         Validateur operationnel

-        Verification d'absence de doublons dans la liste.
+        si un des éléments est présent non valide

     """
     """

+    registry = {}
+
+    def __init__(self, elem=()):
+        if not is_sequence(elem):
+            elem = (elem,)
+        Valid.__init__(self, elem=elem)
+        self.elem = elem
+        self.cata_info = ""
+
+    def info(self):
+        return (tr("%s absent") % self.elem)
+
+    def default(self, valeur, elem):
+        return valeur
+
+    def verif_item(self, valeur):
+        return 1
+
+    def convert(self, valeur):
+        elem = list(self.elem)
+        for val in valeur:
+            v = self.adapt(val)
+            if v in elem:
+                raise ValError(tr("%s n'est pas autorise : %s ")% (v, elem))
+        return valeur
+
+    def has_into(self):
+        return 1
+
+    def verif(self, valeur):
+        if not is_sequence(valeur):
+            liste = list(valeur)
+        else:
+            liste = valeur
+        for val in self.elem:
+            if val in liste: return 0
+        return 1
+
+    def info_erreur_item(self):
+        return tr("La valeur n'est pas dans la liste des choix possibles")

 
 

+
+class NoRepeat(ListVal):
+    """
+        Validateur operationnel
+        Verification d'absence de doublons dans la liste.
+    """

     def __init__(self):
         Valid.__init__(self)
         self.cata_info = ""
 
     def info(self):
     def __init__(self):
         Valid.__init__(self)
         self.cata_info = ""
 
     def info(self):

-        return _(tr(u": pas de présence de doublon dans la liste"))
+        return tr("Pas de doublon dans la liste")

 
     def info_erreur_liste(self):
 
     def info_erreur_liste(self):

-        return _(tr(u"Les doublons ne sont pas permis"))
+        return tr("Les doublons ne sont pas permis")

 
     def default(self, valeur):
         if valeur in self.liste:
 
     def default(self, valeur):
         if valeur in self.liste:

-            raise ValError(ufmt(_tr((u"%s est un doublon")), valeur))
+            raise ValError( tr("%s est un doublon") % valeur)

         return valeur
 
     def convert(self, valeur):
         return valeur
 
     def convert(self, valeur):


@@ -641,10 +748,10 @@ class LongStr(ListVal):
         self.cata_info = ""
 
     def info(self):
         self.cata_info = ""
 
     def info(self):

-        return ufmt(_(u"longueur de la chaine entre %s et %s"), self.low, self.high)
+        return (tr("longueur de la chaine entre %s et %s") %( self.low, self.high))

 
     def info_erreur_item(self):
 
     def info_erreur_item(self):

-        return _(u"Longueur de la chaine incorrecte")
+        return tr("Longueur de la chaine incorrecte")

 
     def convert(self, valeur):
         for val in valeur:
 
     def convert(self, valeur):
         for val in valeur:


@@ -660,13 +767,13 @@ class LongStr(ListVal):
 
     def default(self, valeur, low, high):
         if not is_str(valeur):
 
     def default(self, valeur, low, high):
         if not is_str(valeur):

-            raise ValError(ufmt(_tr((u"%s n'est pas une chaine")), repr(valeur)))
+            raise ValError ("%s n'est pas une chaine" % repr(valeur))

         if valeur[0] == "'" and valeur[-1] == "'":
             low = low + 2
             high = high + 2
         if len(valeur) < low or len(valeur) > high:
             raise ValError(
         if valeur[0] == "'" and valeur[-1] == "'":
             low = low + 2
             high = high + 2
         if len(valeur) < low or len(valeur) > high:
             raise ValError(

-                ufmt(_(tr(u"%s n'est pas de la bonne longueur")), repr(valeur)))
+                "%s n'est pas de la bonne longueur" % repr(valeur))

         return valeur
 
 
         return valeur
 
 


@@ -682,10 +789,10 @@ class OnlyStr(ListVal):
         self.cata_info = ""
 
     def info(self):
         self.cata_info = ""
 
     def info(self):

-        return _(u"regarde si c'est une chaine")
+        return tr("regarde si c'est une chaine")

 
     def info_erreur_item(self):
 
     def info_erreur_item(self):

-        return _(u"Ce n'est pas une chaine")
+        return tr("Ce n'est pas une chaine")

 
     def convert(self, valeur):
         for val in valeur:
 
     def convert(self, valeur):
         for val in valeur:


@@ -701,7 +808,7 @@ class OnlyStr(ListVal):
 
     def default(self, valeur):
         if not is_str(valeur):
 
     def default(self, valeur):
         if not is_str(valeur):

-            raise ValError(ufmt(_tr((u"%s n'est pas une chaine")), repr(valeur)))
+            raise ValError (tr("%s n'est pas une chaine") % repr(valeur))

         return valeur
 
 
         return valeur
 
 


@@ -718,10 +825,10 @@ class OrdList(ListVal):
         self.cata_info = ""
 
     def info(self):
         self.cata_info = ""
 
     def info(self):

-        return ufmt(_(u"liste %s"), self.ord)
+        return ("liste %s" % self.ord)

 
     def info_erreur_liste(self):
 
     def info_erreur_liste(self):

-        return ufmt(_(u"La liste doit etre en ordre %s"), self.ord)
+        return (tr("La liste doit etre en ordre %s") % self.ord)

 
     def convert(self, valeur):
         self.val = None
 
     def convert(self, valeur):
         self.val = None


@@ -734,11 +841,11 @@ class OrdList(ListVal):
         if self.ord == 'croissant':
             if self.val is not None and valeur < self.val:
                 raise ValError(
         if self.ord == 'croissant':
             if self.val is not None and valeur < self.val:
                 raise ValError(

-                    ufmt(_tr((u"%s n'est pas par valeurs croissantes")), repr(self.liste)))
+                    (tr("%s n'est pas par valeurs croissantes") % repr(self.liste)))

         elif self.ord == 'decroissant':
             if self.val is not None and valeur > self.val:
                 raise ValError(
         elif self.ord == 'decroissant':
             if self.val is not None and valeur > self.val:
                 raise ValError(

-                    ufmt(_tr((u"%s n'est pas par valeurs decroissantes")), repr(self.liste)))
+                    (tr("%s n'est pas par valeurs decroissantes") % repr(self.liste)))

         self.val = valeur
         return valeur
 
         self.val = valeur
         return valeur
 


@@ -796,7 +903,7 @@ class OrVal(Valid):
                 return validator.convert(valeur)
             except:
                 pass
                 return validator.convert(valeur)
             except:
                 pass

-        raise ValError(ufmt(_tr((u"%s n'est pas du bon type")), repr(valeur)))
+        raise ValError(tr("%s n'est pas du bon type")% repr(valeur))

 
     def info_erreur_item(self):
         l = []
 
     def info_erreur_item(self):
         l = []


@@ -943,6 +1050,7 @@ class AndVal(Valid):
         return chaine
 
     def info_erreur_liste(self):
         return chaine
 
     def info_erreur_liste(self):

+        chaine=""

         a = 1
         for v in self.validators:
             if v.info_erreur_liste() != " ":
         a = 1
         for v in self.validators:
             if v.info_erreur_liste() != " ":


@@ -1085,22 +1193,22 @@ class RangeVal(ListVal):
     def __init__(self, low, high):
         self.low = low
         self.high = high
     def __init__(self, low, high):
         self.low = low
         self.high = high

-        self.cata_info = ufmt(_(tr(u"%s doit être inférieur a %s")), low, high)
+        self.cata_info = (tr("%s doit etre inferieur a %s") % (low, high))

 
     def info(self):
 
     def info(self):

-        return ufmt(_(tr(u"valeur dans l'intervalle %s , %s")), self.low, self.high)
+        return (tr("valeur dans l'intervalle %s , %s") %( self.low, self.high))

 
     def convert_item(self, valeur):
         if valeur > self.low and valeur < self.high:
             return valeur
 
     def convert_item(self, valeur):
         if valeur > self.low and valeur < self.high:
             return valeur

-        raise ValError(ufmt(_(tr(u"%s devrait être comprise entre %s et %s")),
-                            valeur, self.low, self.high))
+        raise ValError(tr("%s devrait etre comprise entre %s et %s") % (valeur, self.low, self.high))

 
     def verif_item(self, valeur):
         return valeur > self.low and valeur < self.high
 
     def info_erreur_item(self):
 
     def verif_item(self, valeur):
         return valeur > self.low and valeur < self.high
 
     def info_erreur_item(self):

-        return ufmt(_(tr(u"La valeur doit etre comprise entre %s et %s")), self.low, self.high)
+        return (tr("la valeur %s doit etre comprise entre %s et %s") % (valeur, self.low, self.high))
+

 
     def verif_cata(self):
         if self.low > self.high:
 
     def verif_cata(self):
         if self.low > self.high:


@@ -1118,18 +1226,16 @@ class CardVal(Valid):
         catalogues
     """
 
         catalogues
     """
 

-    def __init__(self, min='**', max='**'):
+    def __init__(self, min=float('-inf'), max=float('inf')):

         self.min = min
         self.max = max
         self.min = min
         self.max = max

-        self.cata_info = ufmt(_(tr(u"%s doit etre inferieur a %s")), min, max)
+        self.cata_info = (tr("%s doit etre inferieur a %s") %(min, max))

 
     def info(self):
 
     def info(self):

-        return ufmt(_(tr(u"longueur de liste comprise entre  %s et %s")), self.min, self.max)
+        return (tr("longueur de liste comprise entre  %s et %s") %(self.min, self.max))

 
     def info_erreur_liste(self):
 
     def info_erreur_liste(self):

-        return ufmt(
-            _(tr(u"Le cardinal de la liste doit etre compris entre %s et %s")),
-            self.min, self.max)
+        return (tr("Le cardinal de la liste doit etre compris entre %s et %s") % (self.min, self.max))

 
     def is_list(self):
         return self.max == '**' or self.max > 1
 
     def is_list(self):
         return self.max == '**' or self.max > 1


@@ -1155,10 +1261,10 @@ class CardVal(Valid):
             l = 1
         if self.max != '**' and l > self.max:
             raise ValError(
             l = 1
         if self.max != '**' and l > self.max:
             raise ValError(

-                ufmt(_(tr(u"%s devrait etre de longueur inferieure a %s")), valeur, self.max))
+                tr("%s devrait etre de longueur inferieure a %s") % (valeur, self.max))

         if self.min != '**' and l < self.min:
             raise ValError(
         if self.min != '**' and l < self.min:
             raise ValError(

-                ufmt(_(tr(u"%s devrait etre de longueur superieure a %s")), valeur, self.min))
+                tr("%s devrait etre de longueur superieure a %s") % (valeur, self.min))

         return valeur
 
     def verif_item(self, valeur):
         return valeur
 
     def verif_item(self, valeur):


@@ -1208,21 +1314,21 @@ class PairVal(ListVal):
         return _(u"valeur paire")
 
     def info_erreur_item(self):
         return _(u"valeur paire")
 
     def info_erreur_item(self):

-        return _(tr(u"La valeur saisie doit etre paire"))
+        return tr("La valeur saisie doit etre paire")

 
     def convert(self, valeur):
         for val in valeur:
             v = self.adapt(val)
             if v % 2 != 0:
                 raise ValError(
 
     def convert(self, valeur):
         for val in valeur:
             v = self.adapt(val)
             if v % 2 != 0:
                 raise ValError(

-                    ufmt(_(tr(u"%s contient des valeurs non paires")), repr(valeur)))
+                    tr("%s contient des valeurs non paires") % repr(valeur))

         return valeur
 
     def default(self, valeur):
         return valeur
 
     def verif_item(self, valeur):
         return valeur
 
     def default(self, valeur):
         return valeur
 
     def verif_item(self, valeur):

-        if type(valeur) not in (int, long):
+        if type(valeur) not in six.integer_types:

             return 0
         return valeur % 2 == 0
 
             return 0
         return valeur % 2 == 0
 


@@ -1253,14 +1359,13 @@ class EnumVal(ListVal):
         self.cata_info = ""
 
     def info(self):
         self.cata_info = ""
 
     def info(self):

-        return "valeur dans %s" % `self.into`
+        return ("valeur dans %s" % self.into)

 
     def convert_item(self, valeur):
         if valeur in self.into:
             return valeur
         raise ValError(
 
     def convert_item(self, valeur):
         if valeur in self.into:
             return valeur
         raise ValError(

-            ufmt(_(tr(u"%s contient des valeurs hors des choix possibles: %s ")),
-                 valeur, self.into))
+            tr("%s contient des valeurs hors des choix possibles: %s ") % (valeur, self.into))

 
     def verif_item(self, valeur):
         if valeur not in self.into:
 
     def verif_item(self, valeur):
         if valeur not in self.into:


@@ -1281,7 +1386,7 @@ class EnumVal(ListVal):
         return liste_choix
 
     def info_erreur_item(self):
         return liste_choix
 
     def info_erreur_item(self):

-        return _(tr(u"La valeur n'est pas dans la liste des choix possibles"))
+        return tr("La valeur n'est pas dans la liste des choix possibles")

 
 
 def ImpairVal(valeur):
 
 
 def ImpairVal(valeur):


@@ -1300,7 +1405,7 @@ def ImpairVal(valeur):
             return 0
         return 1
 
             return 0
         return 1
 

-ImpairVal.info = tr("valeur impaire")
+ImpairVal.info = "valeur impaire"

 
 
 class F1Val(Valid):
 
 
 class F1Val(Valid):


@@ -1317,22 +1422,22 @@ class F1Val(Valid):
         self.cata_info = ""
 
     def info(self):
         self.cata_info = ""
 
     def info(self):

-        return ufmt(_(u"valeur %s pour la somme des cles A et B "), self.somme)
+        return (tr("valeur %s pour la somme des cles A et B ") % self.somme)

 
     def verif(self, valeur):
         if is_sequence(valeur):
             for val in valeur:
 
     def verif(self, valeur):
         if is_sequence(valeur):
             for val in valeur:

-                if not val.has_key("A"):
+                if not "A" in val:

                     return 0
                     return 0

-                if not val.has_key("B"):
+                if not "B" in val:

                     return 0
                 if val["A"] + val["B"] != self.somme:
                     return 0
             return 1
         else:
                     return 0
                 if val["A"] + val["B"] != self.somme:
                     return 0
             return 1
         else:

-            if not valeur.has_key("A"):
+            if not "A" in valeur:

                 return 0
                 return 0

-            if not valeur.has_key("B"):
+            if not "B" in valeur:

                 return 0
             if valeur["A"] + valeur["B"] != self.somme:
                 return 0
                 return 0
             if valeur["A"] + valeur["B"] != self.somme:
                 return 0


@@ -1352,17 +1457,29 @@ class FunctionVal(Valid):
     def info(self):
         return self.function.info
 
     def info(self):
         return self.function.info
 

+    def info_erreur_item(self):
+        return self.function.info
+

     def verif(self, valeur):
         return self.function(valeur)
 
     def verif(self, valeur):
         return self.function(valeur)
 

+    def verif_item(self, valeur):
+        return self.function(valeur)
+
+    def convert(self, valeur):
+        return valeur
+

 # MC ca ne devrait plus servir !
 # MC ca ne devrait plus servir !

-CoercableFuncs = {types.IntType:     int,
-                  types.LongType:    long,
-                  types.FloatType:   float,
-                  types.ComplexType: complex,
-                  types.UnicodeType: unicode}
+CoercableFuncs = {int:     int,
+                  int:    int,
+                  float:   float,
+                  complex: complex,
+                  str: six.text_type}

 
 
 
 

+#class FunctionValObjet(FunctionVal):
+#OOOOOOOOOOOOOOo
+

 class TypeVal(ListVal):
 
     """
 class TypeVal(ListVal):
 
     """


@@ -1377,7 +1494,7 @@ class TypeVal(ListVal):
     def __init__(self, aType):
         # Si aType n'est pas un type, on le retrouve a l'aide de la fonction type
         # type(1) == int;type(0.2)==float;etc.
     def __init__(self, aType):
         # Si aType n'est pas un type, on le retrouve a l'aide de la fonction type
         # type(1) == int;type(0.2)==float;etc.

-        if type(aType) != types.TypeType:
+        if type(aType) != type:

             aType = type(aType)
         self.aType = aType
         try:
             aType = type(aType)
         self.aType = aType
         try:


@@ -1386,7 +1503,7 @@ class TypeVal(ListVal):
             self.coerce = self.identity
 
     def info(self):
             self.coerce = self.identity
 
     def info(self):

-        return ufmt(_(u"valeur de %s"), self.aType)
+        return (tr("valeur de %s") % self.aType)

 
     def identity(self, value):
         if type(value) == self.aType:
 
     def identity(self, value):
         if type(value) == self.aType:


@@ -1419,7 +1536,7 @@ class InstanceVal(ListVal):
         if type(aClass) == types.InstanceType:
             # instance ancienne mode
             aClass = aClass.__class__
         if type(aClass) == types.InstanceType:
             # instance ancienne mode
             aClass = aClass.__class__

-        elif type(aClass) == types.ClassType:
+        elif type(aClass) == type:

             # classe ancienne mode
             aClass = aClass
         elif type(aClass) == type:
             # classe ancienne mode
             aClass = aClass
         elif type(aClass) == type:


@@ -1429,12 +1546,12 @@ class InstanceVal(ListVal):
             # instance nouvelle mode
             aClass = type(aClass)
         else:
             # instance nouvelle mode
             aClass = type(aClass)
         else:

-            raise ValError(_(u"type non supporté"))
+            raise ValError(tr("type non supporté"))

 
         self.aClass = aClass
 
     def info(self):
 
         self.aClass = aClass
 
     def info(self):

-        return ufmt(_(u"valeur d'instance de %s"), self.aClass.__name__)
+        return (tr("valeur d'instance de %s") % self.aClass.__name__)

 
     def verif_item(self, valeur):
         if not isinstance(valeur, self.aClass):
 
     def verif_item(self, valeur):
         if not isinstance(valeur, self.aClass):


@@ -1442,7 +1559,7 @@ class InstanceVal(ListVal):
         return 1
 
 
         return 1
 
 

-class VerifTypeTuple(Valid, ListVal):
+class VerifTypeTuple(ListVal):

 
     def __init__(self, typeDesTuples):
         self.typeDesTuples = typeDesTuples
 
     def __init__(self, typeDesTuples):
         self.typeDesTuples = typeDesTuples


@@ -1450,10 +1567,10 @@ class VerifTypeTuple(Valid, ListVal):
         self.cata_info = ""
 
     def info(self):
         self.cata_info = ""
 
     def info(self):

-        return _(u"tuple de la forme :")+str(self.typeDesTuples)
+        return tr(": verifie les types dans un tuple")

 
     def info_erreur_liste(self):
 
     def info_erreur_liste(self):

-        return _(u"Les types ne sont pas : ") +str(self.typeDesTuples)
+        return tr("Les types entres ne sont pas permis")

 
     def default(self, valeur):
         return valeur
 
     def default(self, valeur):
         return valeur


@@ -1464,12 +1581,12 @@ class VerifTypeTuple(Valid, ListVal):
     def convert_item(self, valeur):
         if len(valeur) != len(self.typeDesTuples):
             raise ValError(
     def convert_item(self, valeur):
         if len(valeur) != len(self.typeDesTuples):
             raise ValError(

-                ufmt(_(u"%s devrait etre de type  %s "), valeur, self.typeDesTuples))
+                tr("%s devrait etre de type  %s ") %( valeur, self.typeDesTuples))

         for i in range(len(valeur)):
             ok = self.verifType(valeur[i], self.typeDesTuples[i])
             if ok != 1:
                 raise ValError(
         for i in range(len(valeur)):
             ok = self.verifType(valeur[i], self.typeDesTuples[i])
             if ok != 1:
                 raise ValError(

-                    ufmt(_(u"%s devrait etre de type  %s "), valeur, self.typeDesTuples))
+                    tr("%s devrait etre de type  %s ") % (valeur, self.typeDesTuples))

         return valeur
 
     def verif_item(self, valeur):
         return valeur
 
     def verif_item(self, valeur):


@@ -1486,21 +1603,23 @@ class VerifTypeTuple(Valid, ListVal):
 
     def verifType(self, valeur, type_permis):
         if type_permis == 'R':
 
     def verifType(self, valeur, type_permis):
         if type_permis == 'R':

-            if type(valeur) in (types.IntType, types.FloatType, types.LongType):
+            if type(valeur) in (int, float, int):

                 return 1
         elif type_permis == 'I':
                 return 1
         elif type_permis == 'I':

-            if type(valeur) in (types.IntType, types.LongType):
+            if type(valeur) in (int, int):

                 return 1
         elif type_permis == 'C':
             if self.is_complexe(valeur):
                 return 1
         elif type_permis == 'TXM':
                 return 1
         elif type_permis == 'C':
             if self.is_complexe(valeur):
                 return 1
         elif type_permis == 'TXM':

-            if type(valeur) == types.StringType:
+            if type(valeur) == bytes:
+                return 1
+        elif isinstance(valeur, type_permis):

                 return 1
         return 0
 
     def verif(self, valeur):
                 return 1
         return 0
 
     def verif(self, valeur):

-        if type(valeur) in (types.ListType, types.TupleType):
+        if type(valeur) in (list, tuple):

             liste = list(valeur)
             for val in liste:
                 if self.verif_item(val) != 1:
             liste = list(valeur)
             for val in liste:
                 if self.verif_item(val) != 1:


@@ -1562,7 +1681,7 @@ class VerifExiste(ListVal):
         if valeur in self.listeDesFreres:
             return valeur
         raise ValError(
         if valeur in self.listeDesFreres:
             return valeur
         raise ValError(

-            ufmt(_(u"%s n'est pas dans %s"), valeur, self.listeDesFreres))
+            tr("%s n'est pas dans %s") % (valeur, self.listeDesFreres))

 
 
 class RegExpVal(ListVal):
 
 
 class RegExpVal(ListVal):


@@ -1571,14 +1690,17 @@ class RegExpVal(ListVal):
     Vérifie qu'une chaîne de caractère corresponde à l'expression régulière 'pattern'
     """
 
     Vérifie qu'une chaîne de caractère corresponde à l'expression régulière 'pattern'
     """
 

-    errormsg = u'La chaîne "%(value)s" ne correspond pas au motif "%(pattern)s"'
+    errormsg = 'La chaîne "%(value)s" ne correspond pas au motif "%(pattern)s"'

 
     def __init__(self, pattern):
         self.pattern = pattern
         self.compiled_regexp = re.compile(pattern)
 
     def info(self):
 
     def __init__(self, pattern):
         self.pattern = pattern
         self.compiled_regexp = re.compile(pattern)
 
     def info(self):

-        return u'Une chaîne correspondant au motif "%s" est attendue.' % self.pattern
+        return tr('Une chaîne correspondant au motif ') + str(self.pattern) + tr(" est attendue")
+
+    def info_erreur_item(self):
+        return tr('Une chaîne correspondant au motif ') + str(self.pattern) + tr(" est attendue")

 
     def verif_item(self, valeur):
         if self.compiled_regexp.match(valeur):
 
     def verif_item(self, valeur):
         if self.compiled_regexp.match(valeur):


@@ -1602,9 +1724,57 @@ class FileExtVal(RegExpVal):
 
     def __init__(self, ext):
         self.ext = ext
 
     def __init__(self, ext):
         self.ext = ext

-        self.errormsg = u'"%%(value)s" n\'est pas un nom de fichier %(ext)s valide' % {
+        self.errormsg = '"%%(value)s" n\'est pas un nom de fichier %(ext)s valide' % {

             "ext": ext}
             "ext": ext}

-        RegExpVal.__init__(self, "^[\w\-]+\.%s$" % self.ext)
+        #PNPN Modif pour Adao
+        RegExpVal.__init__(self, "^\S+\.%s$" % self.ext)
+

 
     def info(self):
 
     def info(self):

-        return u'Un nom de fichier se terminant par ".%s" est attendu.' % self.ext
+        return ('Un nom de fichier se terminant par ".%s" est attendu.' % self.ext)
+
+    def info_erreur_item(self):
+        return ('Un nom de fichier se terminant par ".%s" est attendu.' % self.ext)
+
+class CreeMotClef(object):
+    def __init__(self,MotClef ):
+        self.MotClef=MotClef
+        self.MCSimp=None
+         
+    def convert(self, lval):
+        try : valeur=lval[0]
+        except  : return lval
+
+        parent= self.MCSimp.parent
+        if hasattr(parent, 'inhibeValidator') and parent.inhibeValidator: return lval
+
+
+        if parent.get_child(self.MotClef) == None : longueur=0
+        else : longueur=len(parent.get_child(self.MotClef))
+
+        pos=parent.get_index_child(self.MCSimp.nom)+1
+        while longueur < valeur : 
+           parent.inhibeValidator=1
+           parent.addentite(self.MotClef,pos)
+           pos=pos+1
+           parent.inhibeValidator=0
+           longueur=len(parent.get_child(self.MotClef))
+
+        if longueur > valeur : 
+           parent.inhibeValide=1
+           parentObj=parent.get_child(self.MotClef)
+           obj=parent.get_child(self.MotClef)[-1]
+           parentObj.suppentite(obj)
+           longueur=len(parent.get_child(self.MotClef))
+           parent.inhibeValide=0
+        return lval
+
+    def info(self):
+        return "Cree le bon nombre de Mot %s"  % self.MotClef
+
+    def verif_item(self, valeur):
+        return 1
+
+    def set_MCSimp(self, MCSimp):
+        #print "dans set_MCSimp"
+        self.MCSimp=MCSimp