src/daComposant/daCore/PlatformInfo.py

   1 #-*-coding:iso-8859-1-*-
   2 #
   3 # Copyright (C) 2008-2017 EDF R&D
   4 #
   5 # This library is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU Lesser General Public
   7 # License as published by the Free Software Foundation; either
   8 # version 2.1 of the License.
   9 #
  10 # This library is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 # Lesser General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU Lesser General Public
  16 # License along with this library; if not, write to the Free Software
  17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18 #
  19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  20 #
  21 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
  22
  23 """
  24     Informations sur le code et la plateforme, et mise à jour des chemins
  25
  26     La classe "PlatformInfo" permet de récupérer les informations générales sur
  27     le code et la plateforme sous forme de strings, ou d'afficher directement
  28     les informations disponibles par les méthodes. L'impression directe d'un
  29     objet de cette classe affiche les informations minimales. Par exemple :
  30         print PlatformInfo()
  31         print PlatformInfo().getVersion()
  32         created = PlatformInfo().getDate()
  33
  34     La classe "PathManagement" permet de mettre à jour les chemins système pour
  35     ajouter les outils numériques, matrices... On l'utilise en instanciant
  36     simplement cette classe, sans meme récupérer d'objet :
  37         PathManagement()
  38 """
  39 __author__ = "Jean-Philippe ARGAUD"
  40 __all__ = []
  41
  42 import os, sys
  43
  44 # ==============================================================================
  45 class PlatformInfo(object):
  46     """
  47     Rassemblement des informations sur le code et la plateforme
  48     """
  49     def __init__(self):
  50         "Sans effet"
  51         pass
  52
  53     def getName(self):
  54         "Retourne le nom de l'application"
  55         import version as dav
  56         return dav.name
  57
  58     def getVersion(self):
  59         "Retourne le numéro de la version"
  60         import version as dav
  61         return dav.version
  62
  63     def getDate(self):
  64         "Retourne la date de création de la version"
  65         import version as dav
  66         return dav.date
  67
  68     def getPythonVersion(self):
  69         "Retourne la version de python disponible"
  70         return ".".join([str(x) for x in sys.version_info[0:3]]) # map(str,sys.version_info[0:3]))
  71
  72     def getNumpyVersion(self):
  73         "Retourne la version de numpy disponible"
  74         import numpy.version
  75         return numpy.version.version
  76
  77     def getScipyVersion(self):
  78         "Retourne la version de scipy disponible"
  79         import scipy.version
  80         return scipy.version.version
  81
  82     def getMatplotlibVersion(self):
  83         "Retourne la version de matplotlib disponible"
  84         try:
  85             import matplotlib
  86             return matplotlib.__version__
  87         except ImportError:
  88             return "0.0.0"
  89
  90     def getGnuplotVersion(self):
  91         "Retourne la version de gnuplotpy disponible"
  92         try:
  93             import Gnuplot
  94             return Gnuplot.__version__
  95         except ImportError:
  96             return "0.0"
  97
  98     def getSphinxVersion(self):
  99         "Retourne la version de sphinx disponible"
 100         try:
 101             import sphinx
 102             return sphinx.__version__
 103         except ImportError:
 104             return "0.0.0"
 105
 106     def getNloptVersion(self):
 107         "Retourne la version de nlopt disponible"
 108         try:
 109             import nlopt
 110             return "%s.%s.%s"%(
 111                 nlopt.version_major(),
 112                 nlopt.version_minor(),
 113                 nlopt.version_bugfix(),
 114                 )
 115         except ImportError:
 116             return "0.0.0"
 117
 118     def getCurrentMemorySize(self):
 119         "Retourne la taille mémoire courante utilisée"
 120         return 1
 121
 122     def MaximumPrecision(self):
 123         "Retourne la precision maximale flottante pour Numpy"
 124         import numpy
 125         try:
 126             x = numpy.array([1.,], dtype='float128')
 127             mfp = 'float128'
 128         except:
 129             mfp = 'float64'
 130         return mfp
 131
 132     def MachinePrecision(self):
 133         # Alternative sans module :
 134         # eps = 2.38
 135         # while eps > 0:
 136         #     old_eps = eps
 137         #     eps = (1.0 + eps/2) - 1.0
 138         return sys.float_info.epsilon
 139
 140     def __str__(self):
 141         import version as dav
 142         return "%s %s (%s)"%(dav.name,dav.version,dav.date)
 143
 144 # ==============================================================================
 145 try:
 146     import matplotlib
 147     has_matplotlib = True
 148 except ImportError:
 149     has_matplotlib = False
 150
 151 try:
 152     import Gnuplot
 153     has_gnuplot = True
 154 except ImportError:
 155     has_gnuplot = False
 156
 157 try:
 158     import sphinx
 159     has_sphinx = True
 160 except ImportError:
 161     has_sphinx = False
 162
 163 try:
 164     import nlopt
 165     has_nlopt = True
 166 except ImportError:
 167     has_nlopt = False
 168
 169 # ==============================================================================
 170 def uniq(sequence):
 171     """
 172     Fonction pour rendre unique chaque élément d'une liste, en préservant l'ordre
 173     """
 174     __seen = set()
 175     return [x for x in sequence if x not in __seen and not __seen.add(x)]
 176
 177 # ==============================================================================
 178 class PathManagement(object):
 179     """
 180     Mise à jour du path système pour les répertoires d'outils
 181     """
 182     def __init__(self):
 183         "Déclaration des répertoires statiques"
 184         parent = os.path.abspath(os.path.join(os.path.dirname(__file__),".."))
 185         self.__paths = {}
 186         self.__paths["daExternals"] = os.path.join(parent,"daExternals")
 187         self.__paths["daMatrices"]  = os.path.join(parent,"daMatrices")
 188         self.__paths["daNumerics"]  = os.path.join(parent,"daNumerics")
 189         #
 190         for v in self.__paths.values():
 191             sys.path.insert(0, v )
 192         #
 193         # Conserve en unique exemplaire chaque chemin
 194         sys.path = uniq( sys.path )
 195         del parent
 196
 197     def getpaths(self):
 198         """
 199         Renvoie le dictionnaire des chemins ajoutés
 200         """
 201         return self.__paths
 202
 203 # ==============================================================================
 204 class SystemUsage(object):
 205     """
 206     Permet de récupérer les différentes tailles mémoires du process courant
 207     """
 208     #
 209     # Le module resource renvoie 0 pour les tailles mémoire. On utilise donc
 210     # plutôt : http://code.activestate.com/recipes/286222/ et Wikipedia
 211     #
 212     _proc_status = '/proc/%d/status' % os.getpid()
 213     _memo_status = '/proc/meminfo'
 214     _scale = {
 215         'o'  : 1.0,     # Multiples SI de l'octet
 216         'ko' : 1.e3,
 217         'Mo' : 1.e6,
 218         'Go' : 1.e9,
 219         'kio': 1024.0,  # Multiples binaires de l'octet
 220         'Mio': 1024.0*1024.0,
 221         'Gio': 1024.0*1024.0*1024.0,
 222         'B':     1.0,   # Multiples binaires du byte=octet
 223         'kB' : 1024.0,
 224         'MB' : 1024.0*1024.0,
 225         'GB' : 1024.0*1024.0*1024.0,
 226         }
 227     #
 228     def __init__(self):
 229         "Sans effet"
 230         pass
 231     #
 232     def _VmA(self, VmKey, unit):
 233         "Lecture des paramètres mémoire de la machine"
 234         try:
 235             t = open(self._memo_status)
 236             v = t.read()
 237             t.close()
 238         except IOError:
 239             return 0.0           # non-Linux?
 240         i = v.index(VmKey)       # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
 241         v = v[i:].split(None, 3) # whitespace
 242         if len(v) < 3:
 243             return 0.0           # invalid format?
 244         # convert Vm value to bytes
 245         mem = float(v[1]) * self._scale[v[2]]
 246         return mem / self._scale[unit]
 247     #
 248     def getAvailablePhysicalMemory(self, unit="o"):
 249         "Renvoie la mémoire physique utilisable en octets"
 250         return self._VmA('MemTotal:', unit)
 251     #
 252     def getAvailableSwapMemory(self, unit="o"):
 253         "Renvoie la mémoire swap utilisable en octets"
 254         return self._VmA('SwapTotal:', unit)
 255     #
 256     def getAvailableMemory(self, unit="o"):
 257         "Renvoie la mémoire totale (physique+swap) utilisable en octets"
 258         return self._VmA('MemTotal:', unit) + self._VmA('SwapTotal:', unit)
 259     #
 260     def getUsableMemory(self, unit="o"):
 261         """Renvoie la mémoire utilisable en octets
 262         Rq : il n'est pas sûr que ce décompte soit juste...
 263         """
 264         return self._VmA('MemFree:', unit) + self._VmA('SwapFree:', unit) + \
 265                self._VmA('Cached:', unit) + self._VmA('SwapCached:', unit)
 266     #
 267     def _VmB(self, VmKey, unit):
 268         "Lecture des paramètres mémoire du processus"
 269         try:
 270             t = open(self._proc_status)
 271             v = t.read()
 272             t.close()
 273         except IOError:
 274             return 0.0           # non-Linux?
 275         i = v.index(VmKey)       # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
 276         v = v[i:].split(None, 3) # whitespace
 277         if len(v) < 3:
 278             return 0.0           # invalid format?
 279         # convert Vm value to bytes
 280         mem = float(v[1]) * self._scale[v[2]]
 281         return mem / self._scale[unit]
 282     #
 283     def getUsedMemory(self, unit="o"):
 284         "Renvoie la mémoire résidente utilisée en octets"
 285         return self._VmB('VmRSS:', unit)
 286     #
 287     def getVirtualMemory(self, unit="o"):
 288         "Renvoie la mémoire totale utilisée en octets"
 289         return self._VmB('VmSize:', unit)
 290     #
 291     def getUsedStacksize(self, unit="o"):
 292         "Renvoie la taille du stack utilisé en octets"
 293         return self._VmB('VmStk:', unit)
 294     #
 295     def getMaxUsedMemory(self, unit="o"):
 296         "Renvoie la mémoire résidente maximale mesurée"
 297         return self._VmB('VmHWM:', unit)
 298     #
 299     def getMaxVirtualMemory(self, unit="o"):
 300         "Renvoie la mémoire totale maximale mesurée"
 301         return self._VmB('VmPeak:', unit)
 302
 303 # ==============================================================================
 304 if __name__ == "__main__":
 305     print '\n AUTODIAGNOSTIC \n'