X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Noyau%2FN_utils.py;h=e53a885169b0ba3a8eeef81ba25ff08ea18333e2;hb=9f4ff7ed9afd87c96e11d61e442e39e5511f60d1;hp=7b909f18a4945787f42b603063a48cd396fbae3a;hpb=16d5922e798b1254eb558678612711d72ed38b32;p=tools%2Feficas.git

diff --git a/Noyau/N_utils.py b/Noyau/N_utils.py
index 7b909f18..e53a8851 100644
--- a/Noyau/N_utils.py
+++ b/Noyau/N_utils.py
@@ -1,4 +1,4 @@
-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
 # Copyright (C) 2007-2013   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
@@ -16,141 +16,146 @@
 # 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 des fonctions utilitaires
 """
 
 # Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+try :
+   from builtins import str
+   from builtins import object
+except :
+   pass
 import sys
 
 # Modules EFICAS
-from N_Exception import AsException
-from N_types     import is_int, is_float, is_complex, is_str, is_sequence, is_assd
-
-SEP='_'
-
-try:
-   # Si la version de Python possède la fonction _getframe
-   # on l'utilise.
-   cur_frame=sys._getframe
-except:
-   # Sinon on l'émule
-   def cur_frame(offset=0):
-     """ Retourne la frame d execution effective eventuellement en remontant
-         de offset niveaux dans la pile d execution
-         Si il y a moins de offset niveaux retourne None
-     """
-     try:1/0
-     except:
-       frame=sys.exc_info()[2].tb_frame.f_back
-     while offset > 0:
-       if frame == None:return None
-       frame=frame.f_back
-       offset=offset-1
-     return frame
+from .N_Exception import AsException
+from .N_types import is_int, is_float, is_complex, is_str, is_sequence, is_assd
+from .strfunc import get_encoding
+import six
 
+SEP = '_'
+
+try :
+  cur_frame = sys._getframe
+except :
+  print ('pb avec la version de python pour cur_frame = sys._getframe')
 
 def callee_where(niveau=4):
-   """
-      recupere la position de l appel
-   """
-   frame=cur_frame(niveau)
-   if frame == None: return 0,"inconnu",0,{}
-   try:
-     return frame.f_lineno,frame.f_code.co_filename,frame.f_code.co_firstlineno,frame.f_locals
-   except:
-     return 0,"inconnu",0,{}
+    """
+       recupere la position de l appel
+    """
+    frame = sys._getframe(niveau)
+    if frame == None:
+        return 0, "inconnu", 0, {}
+    try:
+        # Python 2.7 compile function does not accept unicode filename, so we encode it
+        # with the current locale encoding in order to have a correct traceback.
+        # Here, we convert it back to unicode.
+        filename = six.text_type(frame.f_code.co_filename, get_encoding())
+        return frame.f_lineno, filename, frame.f_code.co_firstlineno, frame.f_locals
+    except:
+        return 0, "inconnu", 0, {}
 
 
 def AsType(a):
-   """
-      Retourne le type d'un concept (a) à partir
-      des caractéristiques de l'objet Python
-   """
-   if is_sequence(a):
-       return AsType(a[0])
-   if is_assd(a):
-       return type(a)
-   if is_float(a):
-       return "R"
-   if is_int(a):
-       return "I"
-   if is_str(a):
-       return "TXM"
-   if a == None:
-       return None
-   raise AsException("type inconnu: %r %s" % (a, type(a)))
+    """
+       Retourne le type d'un concept (a) à partir
+       des caractéristiques de l'objet Python
+    """
+    if is_sequence(a):
+        return AsType(a[0])
+    if is_assd(a):
+        return type(a)
+    if is_float(a):
+        return "R"
+    if is_int(a):
+        return "I"
+    if is_str(a):
+        return "TXM"
+    if a == None:
+        return None
+    raise AsException("type inconnu: %r %s" % (a, type(a)))
 
 
 def prbanner(s):
-   print "*"*(len(s)+10)
-   print "*"*5 + s + "*"*5
-   print "*"*(len(s)+10)
+    print(("*" * (len(s) + 10)))
+    print(("*" * 5 + s + "*" * 5))
+    print(("*" * (len(s) + 10)))
 
 
 def repr_float(valeur):
-  """
-      Cette fonction représente le réel valeur comme une chaine de caractères
-      sous forme mantisse exposant si nécessaire cad si le nombre contient plus de
-      5 caractères
-      NB : valeur est un réel au format Python ou une chaine de caractères représentant un réel
-  """
-  if type(valeur) == str : valeur = eval(valeur)
-  if valeur == 0. : return '0.0'
-  if abs(valeur) > 1. :
-    if abs(valeur) < 10000. : return repr(valeur)
-  else :
-    if abs(valeur) > 0.01 : return repr(valeur)
-  t=repr(valeur)
-  if t.find('e') != -1 or t.find('E') != -1 :
-    # le réel est déjà sous forme mantisse exposant !
-    # --> on remplace e par E
-    t=t.replace('e','E')
-    # --> on doit encore vérifier que la mantisse contient bien un '.'
-    if t.find('.')!= -1:
-      return t
+    """
+        Cette fonction représente le réel valeur comme une chaine de caractères
+        sous forme mantisse exposant si nécessaire cad si le nombre contient plus de
+        5 caractères
+        NB : valeur est un réel au format Python ou une chaine de caractères représentant un réel
+    """
+    if type(valeur) == str:
+        valeur = eval(valeur)
+    if valeur == 0.:
+        return '0.0'
+    if abs(valeur) > 1.:
+        if abs(valeur) < 10000.:
+            return repr(valeur)
     else:
-      # -->il faut rajouter le point avant le E
-      t=t.replace('E','.E')
-      return t
-  s=''
-  neg = 0
-  if t[0]=='-':
-    s=s+t[0]
-    t=t[1:]
-  cpt = 0
-  if t[0].atof() == 0.:
-    # réel plus petit que 1
-    neg = 1
-    t=t[2:]
-    cpt=1
-    while t[0].atof() == 0. :
-      cpt = cpt+1
-      t=t[1:]
-    s=s+t[0]+'.'
-    for c in t[1:]:
-      s=s+c
-  else:
-    # réel plus grand que 1
-    s=s+t[0]+'.'
-    if t[1:].atof() == 0.:
-      l=t[1:].split('.')
-      cpt = len(l[0])
+        if abs(valeur) > 0.01:
+            return repr(valeur)
+    t = repr(valeur)
+    if t.find('e') != -1 or t.find('E') != -1:
+        # le réel est déjà sous forme mantisse exposant !
+        # --> on remplace e par E
+        t = t.replace('e', 'E')
+        # --> on doit encore vérifier que la mantisse contient bien un '.'
+        if t.find('.') != -1:
+            return t
+        else:
+            # -->il faut rajouter le point avant le E
+            t = t.replace('E', '.E')
+            return t
+    s = ''
+    neg = 0
+    if t[0] == '-':
+        s = s + t[0]
+        t = t[1:]
+    cpt = 0
+    if t[0].atof() == 0.:
+        # réel plus petit que 1
+        neg = 1
+        t = t[2:]
+        cpt = 1
+        while t[0].atof() == 0.:
+            cpt = cpt + 1
+            t = t[1:]
+        s = s + t[0] + '.'
+        for c in t[1:]:
+            s = s + c
     else:
-      r=0
-      pt=0
-      for c in t[1:]:
-        r=r+1
-        if c != '.' :
-          if pt != 1 : cpt = cpt + 1
-          s=s+c
+        # réel plus grand que 1
+        s = s + t[0] + '.'
+        if t[1:].atof() == 0.:
+            l = t[1:].split('.')
+            cpt = len(l[0])
         else:
-          pt = 1
-          if r+1 == len(t) or t[r+1:].atof() == 0.:break
-  s=s+'E'+neg*'-'+repr(cpt)
-  return s
+            r = 0
+            pt = 0
+            for c in t[1:]:
+                r = r + 1
+                if c != '.':
+                    if pt != 1:
+                        cpt = cpt + 1
+                    s = s + c
+                else:
+                    pt = 1
+                    if r + 1 == len(t) or t[r + 1:].atof() == 0.:
+                        break
+    s = s + 'E' + neg * '-' + repr(cpt)
+    return s
 
 
 def import_object(uri):
@@ -168,20 +173,24 @@ def import_object(uri):
     try:
         __import__(modname)
         mod = sys.modules[modname]
-    except ImportError, err:
-        raise ImportError(u"can not import module : %s (%s)" % (modname, str(err)))
+    except ImportError as err:
+        raise ImportError(
+            "can not import module : %s (%s)" % (modname, str(err)))
     try:
         object = getattr(mod, objname)
-    except AttributeError, err:
-        raise AttributeError(u"object (%s) not found in module '%s'. "
-            "Module content is: %s" % (objname, modname, tuple(dir(mod))))
+    except AttributeError as err:
+        raise AttributeError("object (%s) not found in module '%s'. "
+                             "Module content is: %s" % (objname, modname, tuple(dir(mod))))
     return object
 
 
 class Singleton(object):
+
     """Singleton implementation in python."""
-    # add _singleton_id attribute to the class to be independant of import path used
+    # add _singleton_id attribute to the class to be independant of import
+    # path used
     __inst = {}
+
     def __new__(cls, *args, **kargs):
         cls_id = getattr(cls, '_singleton_id', cls)
         if Singleton.__inst.get(cls_id) is None:
@@ -190,17 +199,19 @@ class Singleton(object):
 
 
 class Enum(object):
+
     """
     This class emulates a C-like enum for python. It is initialized with a list
     of strings to be used as the enum symbolic keys. The enum values are automatically
     generated as sequencing integer starting at 0.
     """
+
     def __init__(self, *keys):
         """Constructor"""
         self._dict_keys = {}
         for inum, key in enumerate(keys):
-            setattr(self, key, 2**inum)
-            self._dict_keys[2**inum] = key
+            setattr(self, key, 2 ** inum)
+            self._dict_keys[2 ** inum] = key
 
     def exists(self, value):
         """Tell if value is in the enumeration"""