src/daComposant/daCore/PlatformInfo.py

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