src/daComposant/daCore/PlatformInfo.py

   1 # -*- coding: utf-8 -*-
   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 daCore.version as dav
  56         return dav.name
  57
  58     def getVersion(self):
  59         "Retourne le numéro de la version"
  60         import daCore.version as dav
  61         return dav.version
  62
  63     def getDate(self):
  64         "Retourne la date de création de la version"
  65         import daCore.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         try:
  80             import scipy.version
  81             return scipy.version.version
  82         except ImportError:
  83             return "0.0.0"
  84
  85     def getMatplotlibVersion(self):
  86         "Retourne la version de matplotlib disponible"
  87         try:
  88             import matplotlib
  89             return matplotlib.__version__
  90         except ImportError:
  91             return "0.0.0"
  92
  93     def getGnuplotVersion(self):
  94         "Retourne la version de gnuplotpy disponible"
  95         try:
  96             import Gnuplot
  97             return Gnuplot.__version__
  98         except ImportError:
  99             return "0.0"
 100
 101     def getSphinxVersion(self):
 102         "Retourne la version de sphinx disponible"
 103         try:
 104             import sphinx
 105             return sphinx.__version__
 106         except ImportError:
 107             return "0.0.0"
 108
 109     def getNloptVersion(self):
 110         "Retourne la version de nlopt disponible"
 111         try:
 112             import nlopt
 113             return "%s.%s.%s"%(
 114                 nlopt.version_major(),
 115                 nlopt.version_minor(),
 116                 nlopt.version_bugfix(),
 117                 )
 118         except ImportError:
 119             return "0.0.0"
 120
 121     def getCurrentMemorySize(self):
 122         "Retourne la taille mémoire courante utilisée"
 123         return 1
 124
 125     def MaximumPrecision(self):
 126         "Retourne la precision maximale flottante pour Numpy"
 127         import numpy
 128         try:
 129             x = numpy.array([1.,], dtype='float128')
 130             mfp = 'float128'
 131         except:
 132             mfp = 'float64'
 133         return mfp
 134
 135     def MachinePrecision(self):
 136         # Alternative sans module :
 137         # eps = 2.38
 138         # while eps > 0:
 139         #     old_eps = eps
 140         #     eps = (1.0 + eps/2) - 1.0
 141         return sys.float_info.epsilon
 142
 143     def __str__(self):
 144         import daCore.version as dav
 145         return "%s %s (%s)"%(dav.name,dav.version,dav.date)
 146
 147 # ==============================================================================
 148 try:
 149     import scipy
 150     import scipy.optimize
 151     has_scipy = True
 152 except ImportError:
 153     has_scipy = False
 154
 155 try:
 156     import matplotlib
 157     has_matplotlib = True
 158 except ImportError:
 159     has_matplotlib = False
 160
 161 try:
 162     import Gnuplot
 163     has_gnuplot = True
 164 except ImportError:
 165     has_gnuplot = False
 166
 167 try:
 168     import sphinx
 169     has_sphinx = True
 170 except ImportError:
 171     has_sphinx = False
 172
 173 try:
 174     import nlopt
 175     has_nlopt = True
 176 except ImportError:
 177     has_nlopt = False
 178
 179 # ==============================================================================
 180 def uniq(sequence):
 181     """
 182     Fonction pour rendre unique chaque élément d'une liste, en préservant l'ordre
 183     """
 184     __seen = set()
 185     return [x for x in sequence if x not in __seen and not __seen.add(x)]
 186
 187 # ==============================================================================
 188 class PathManagement(object):
 189     """
 190     Mise à jour du path système pour les répertoires d'outils
 191     """
 192     def __init__(self):
 193         "Déclaration des répertoires statiques"
 194         parent = os.path.abspath(os.path.join(os.path.dirname(__file__),".."))
 195         self.__paths = {}
 196         self.__paths["daExternals"] = os.path.join(parent,"daExternals")
 197         self.__paths["daMatrices"]  = os.path.join(parent,"daMatrices")
 198         self.__paths["daNumerics"]  = os.path.join(parent,"daNumerics")
 199         #
 200         for v in self.__paths.values():
 201             sys.path.insert(0, v )
 202         #
 203         # Conserve en unique exemplaire chaque chemin
 204         sys.path = uniq( sys.path )
 205         del parent
 206
 207     def getpaths(self):
 208         """
 209         Renvoie le dictionnaire des chemins ajoutés
 210         """
 211         return self.__paths
 212
 213 # ==============================================================================
 214 class SystemUsage(object):
 215     """
 216     Permet de récupérer les différentes tailles mémoires du process courant
 217     """
 218     #
 219     # Le module resource renvoie 0 pour les tailles mémoire. On utilise donc
 220     # plutôt : http://code.activestate.com/recipes/286222/ et Wikipedia
 221     #
 222     _proc_status = '/proc/%d/status' % os.getpid()
 223     _memo_status = '/proc/meminfo'
 224     _scale = {
 225         'o'  : 1.0,     # Multiples SI de l'octet
 226         'ko' : 1.e3,
 227         'Mo' : 1.e6,
 228         'Go' : 1.e9,
 229         'kio': 1024.0,  # Multiples binaires de l'octet
 230         'Mio': 1024.0*1024.0,
 231         'Gio': 1024.0*1024.0*1024.0,
 232         'B':     1.0,   # Multiples binaires du byte=octet
 233         'kB' : 1024.0,
 234         'MB' : 1024.0*1024.0,
 235         'GB' : 1024.0*1024.0*1024.0,
 236         }
 237     #
 238     def __init__(self):
 239         "Sans effet"
 240         pass
 241     #
 242     def _VmA(self, VmKey, unit):
 243         "Lecture des paramètres mémoire de la machine"
 244         try:
 245             t = open(self._memo_status)
 246             v = t.read()
 247             t.close()
 248         except IOError:
 249             return 0.0           # non-Linux?
 250         i = v.index(VmKey)       # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
 251         v = v[i:].split(None, 3) # whitespace
 252         if len(v) < 3:
 253             return 0.0           # invalid format?
 254         # convert Vm value to bytes
 255         mem = float(v[1]) * self._scale[v[2]]
 256         return mem / self._scale[unit]
 257     #
 258     def getAvailablePhysicalMemory(self, unit="o"):
 259         "Renvoie la mémoire physique utilisable en octets"
 260         return self._VmA('MemTotal:', unit)
 261     #
 262     def getAvailableSwapMemory(self, unit="o"):
 263         "Renvoie la mémoire swap utilisable en octets"
 264         return self._VmA('SwapTotal:', unit)
 265     #
 266     def getAvailableMemory(self, unit="o"):
 267         "Renvoie la mémoire totale (physique+swap) utilisable en octets"
 268         return self._VmA('MemTotal:', unit) + self._VmA('SwapTotal:', unit)
 269     #
 270     def getUsableMemory(self, unit="o"):
 271         """Renvoie la mémoire utilisable en octets
 272         Rq : il n'est pas sûr que ce décompte soit juste...
 273         """
 274         return self._VmA('MemFree:', unit) + self._VmA('SwapFree:', unit) + \
 275                self._VmA('Cached:', unit) + self._VmA('SwapCached:', unit)
 276     #
 277     def _VmB(self, VmKey, unit):
 278         "Lecture des paramètres mémoire du processus"
 279         try:
 280             t = open(self._proc_status)
 281             v = t.read()
 282             t.close()
 283         except IOError:
 284             return 0.0           # non-Linux?
 285         i = v.index(VmKey)       # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
 286         v = v[i:].split(None, 3) # whitespace
 287         if len(v) < 3:
 288             return 0.0           # invalid format?
 289         # convert Vm value to bytes
 290         mem = float(v[1]) * self._scale[v[2]]
 291         return mem / self._scale[unit]
 292     #
 293     def getUsedMemory(self, unit="o"):
 294         "Renvoie la mémoire résidente utilisée en octets"
 295         return self._VmB('VmRSS:', unit)
 296     #
 297     def getVirtualMemory(self, unit="o"):
 298         "Renvoie la mémoire totale utilisée en octets"
 299         return self._VmB('VmSize:', unit)
 300     #
 301     def getUsedStacksize(self, unit="o"):
 302         "Renvoie la taille du stack utilisé en octets"
 303         return self._VmB('VmStk:', unit)
 304     #
 305     def getMaxUsedMemory(self, unit="o"):
 306         "Renvoie la mémoire résidente maximale mesurée"
 307         return self._VmB('VmHWM:', unit)
 308     #
 309     def getMaxVirtualMemory(self, unit="o"):
 310         "Renvoie la mémoire totale maximale mesurée"
 311         return self._VmB('VmPeak:', unit)
 312
 313 # ==============================================================================
 314 if __name__ == "__main__":
 315     print('\n AUTODIAGNOSTIC \n')