src/daComposant/daCore/PlatformInfo.py

   1 #-*-coding:iso-8859-1-*-
   2 #
   3 #  Copyright (C) 2008-2015 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
  43
  44 # ==============================================================================
  45 class PlatformInfo:
  46     """
  47     Rassemblement des informations sur le code et la plateforme
  48     """
  49     def getName(self):
  50         "Retourne le nom de l'application"
  51         import version
  52         return version.name
  53
  54     def getVersion(self):
  55         "Retourne le numéro de la version"
  56         import version
  57         return version.version
  58
  59     def getDate(self):
  60         "Retourne la date de création de la version"
  61         import version
  62         return version.date
  63
  64     def getPythonVersion(self):
  65         "Retourne la version de python utilisée"
  66         import sys
  67         return ".".join(map(str,sys.version_info[0:3]))
  68
  69     def getNumpyVersion(self):
  70         "Retourne la version de numpy utilisée"
  71         import numpy.version
  72         return numpy.version.version
  73
  74     def getScipyVersion(self):
  75         "Retourne la version de scipy utilisée"
  76         import scipy.version
  77         return scipy.version.version
  78
  79     def getMatplotlibVersion(self):
  80         "Retourne la version de matplotlib utilisée"
  81         try:
  82             import matplotlib
  83             return matplotlib.__version__
  84         except:
  85             return "0.0.0"
  86
  87     def getGnuplotVersion(self):
  88         "Retourne la version de gnuplotpy utilisée"
  89         try:
  90             import Gnuplot
  91             return Gnuplot.__version__
  92         except:
  93             return "0.0"
  94
  95     def getCurrentMemorySize(self):
  96         "Retourne la taille mémoire courante utilisée"
  97         return 1
  98
  99     def __str__(self):
 100         import version
 101         return "%s %s (%s)"%(version.name,version.version,version.date)
 102
 103 # ==============================================================================
 104 def uniq(sequence):
 105     """
 106     Fonction pour rendre unique chaque élément d'une liste, en préservant l'ordre
 107     """
 108     __seen = set()
 109     return [x for x in sequence if x not in __seen and not __seen.add(x)]
 110
 111 # ==============================================================================
 112 class PathManagement:
 113     """
 114     Mise à jour du path système pour les répertoires d'outils
 115     """
 116     def __init__(self):
 117         import sys
 118         parent = os.path.abspath(os.path.join(os.path.dirname(__file__),".."))
 119         self.__paths = {}
 120         self.__paths["daExternals"] = os.path.join(parent,"daExternals")
 121         self.__paths["daMatrices"]  = os.path.join(parent,"daMatrices")
 122         self.__paths["daNumerics"]  = os.path.join(parent,"daNumerics")
 123         #
 124         for v in self.__paths.values():
 125             sys.path.insert(0, v )
 126         #
 127         # Conserve en unique exemplaire chaque chemin
 128         sys.path = uniq( sys.path )
 129         del parent
 130
 131     def getpaths(self):
 132         """
 133         Renvoie le dictionnaire des chemins ajoutés
 134         """
 135         return self.__paths
 136
 137 # ==============================================================================
 138 class SystemUsage:
 139     """
 140     Permet de récupérer les différentes tailles mémoires du process courant
 141     """
 142     #
 143     # Le module resource renvoie 0 pour les tailles mémoire. On utilise donc
 144     # plutôt : http://code.activestate.com/recipes/286222/ et Wikipedia
 145     #
 146     _proc_status = '/proc/%d/status' % os.getpid()
 147     _memo_status = '/proc/meminfo'
 148     _scale = {
 149         'o':     1.0, 'ko' : 1.e3,   'Mo' : 1.e6,          'Go' : 1.e9,                 # Multiples SI de l'octet
 150                       'kio': 1024.0, 'Mio': 1024.0*1024.0, 'Gio': 1024.0*1024.0*1024.0, # Multiples binaires de l'octet
 151         'B':     1.0, 'kB' : 1024.0, 'MB' : 1024.0*1024.0, 'GB' : 1024.0*1024.0*1024.0, # Multiples binaires du byte=octet
 152              }
 153     #
 154     def _VmA(self, VmKey, unit):
 155         try:
 156             t = open(self._memo_status)
 157             v = t.read()
 158             t.close()
 159         except:
 160             return 0.0           # non-Linux?
 161         i = v.index(VmKey)       # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
 162         v = v[i:].split(None, 3) # whitespace
 163         if len(v) < 3:
 164             return 0.0           # invalid format?
 165         # convert Vm value to bytes
 166         mem = float(v[1]) * self._scale[v[2]]
 167         return mem / self._scale[unit]
 168     #
 169     def getAvailablePhysicalMemory(self, unit="o"):
 170         "Renvoie la mémoire physique utilisable en octets"
 171         return self._VmA('MemTotal:', unit)
 172     #
 173     def getAvailableSwapMemory(self, unit="o"):
 174         "Renvoie la mémoire swap utilisable en octets"
 175         return self._VmA('SwapTotal:', unit)
 176     #
 177     def getAvailableMemory(self, unit="o"):
 178         "Renvoie la mémoire totale (physique+swap) utilisable en octets"
 179         return self._VmA('MemTotal:', unit) + self._VmA('SwapTotal:', unit)
 180     #
 181     def getUsableMemory(self, unit="o"):
 182         """Renvoie la mémoire utilisable en octets
 183         Rq : il n'est pas sûr que ce décompte soit juste...
 184         """
 185         return self._VmA('MemFree:', unit) + self._VmA('SwapFree:', unit) + \
 186                self._VmA('Cached:', unit) + self._VmA('SwapCached:', unit)
 187     #
 188     def _VmB(self, VmKey, unit):
 189         try:
 190             t = open(self._proc_status)
 191             v = t.read()
 192             t.close()
 193         except:
 194             return 0.0           # non-Linux?
 195         i = v.index(VmKey)       # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
 196         v = v[i:].split(None, 3) # whitespace
 197         if len(v) < 3:
 198             return 0.0           # invalid format?
 199         # convert Vm value to bytes
 200         mem = float(v[1]) * self._scale[v[2]]
 201         return mem / self._scale[unit]
 202     #
 203     def getUsedMemory(self, unit="o"):
 204         "Renvoie la mémoire résidente utilisée en octets"
 205         return self._VmB('VmRSS:', unit)
 206     #
 207     def getVirtualMemory(self, unit="o"):
 208         "Renvoie la mémoire totale utilisée en octets"
 209         return self._VmB('VmSize:', unit)
 210     #
 211     def getUsedStacksize(self, unit="o"):
 212         "Renvoie la taille du stack utilisé en octets"
 213         return self._VmB('VmStk:', unit)
 214     #
 215     def getMaxUsedMemory(self, unit="o"):
 216         "Renvoie la mémoire résidente maximale mesurée"
 217         return self._VmB('VmHWM:', unit)
 218     #
 219     def getMaxVirtualMemory(self, unit="o"):
 220         "Renvoie la mémoire totale maximale mesurée"
 221         return self._VmB('VmPeak:', unit)
 222
 223 # ==============================================================================
 224 if __name__ == "__main__":
 225     print '\n AUTODIAGNOSTIC \n'