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