src/daComposant/daCore/PlatformInfo.py

   1 # -*- coding: utf-8 -*-
   2 #
   3 # Copyright (C) 2008-2018 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     La classe "SystemUsage" permet de  sous Unix les différentes tailles
  40     mémoires du process courant. Ces tailles peuvent être assez variables et
  41     dépendent de la fiabilité des informations du système dans le suivi des
  42     process.
  43 """
  44 __author__ = "Jean-Philippe ARGAUD"
  45 __all__ = []
  46
  47 import os
  48 import sys
  49 import platform
  50 import locale
  51
  52 # ==============================================================================
  53 class PlatformInfo(object):
  54     """
  55     Rassemblement des informations sur le code et la plateforme
  56     """
  57     def __init__(self):
  58         "Sans effet"
  59         pass
  60
  61     def getName(self):
  62         "Retourne le nom de l'application"
  63         import daCore.version as dav
  64         return dav.name
  65
  66     def getVersion(self):
  67         "Retourne le numéro de la version"
  68         import daCore.version as dav
  69         return dav.version
  70
  71     def getDate(self):
  72         "Retourne la date de création de la version"
  73         import daCore.version as dav
  74         return dav.date
  75
  76     def getYear(self):
  77         "Retourne l'année de création de la version"
  78         import daCore.version as dav
  79         return dav.year
  80
  81     def getSystemInformation(self, __prefix=""):
  82         __msg  = ""
  83         __msg += "\n%s%30s : %s" %(__prefix,"platform.system",platform.system())
  84         __msg += "\n%s%30s : %s" %(__prefix,"sys.platform",sys.platform)
  85         __msg += "\n%s%30s : %s" %(__prefix,"platform.version",platform.version())
  86         __msg += "\n%s%30s : %s" %(__prefix,"platform.platform",platform.platform())
  87         __msg += "\n%s%30s : %s" %(__prefix,"platform.machine",platform.machine())
  88         if sys.platform.startswith('linux'):
  89             if hasattr(platform, 'linux_distribution'):
  90                 __msg += "\n%s%30s : %s" %(__prefix,
  91                     "platform.linux_distribution",str(platform.linux_distribution()))
  92             else:
  93                 __msg += "\n%s%30s : %s" %(__prefix,"platform.dist",str(platform.dist()))
  94         elif os.name == 'nt':
  95             __msg += "\n%s%30s : %s" %(__prefix,"platform.win32_ver",platform.win32_ver()[1])
  96         #
  97         __msg += "\n"
  98         __msg += "\n%s%30s : %s" %(__prefix,"platform.python_implementation",platform.python_implementation())
  99         __msg += "\n%s%30s : %s" %(__prefix,"sys.executable",sys.executable)
 100         __msg += "\n%s%30s : %s" %(__prefix,"sys.version",sys.version.replace('\n',''))
 101         __msg += "\n%s%30s : %s" %(__prefix,"sys.getfilesystemencoding",str(sys.getfilesystemencoding()))
 102         __msg += "\n%s%30s : %s" %(__prefix,"locale.getdefaultlocale",str(locale.getdefaultlocale()))
 103         return __msg
 104
 105     def getPythonVersion(self):
 106         "Retourne la version de python disponible"
 107         return ".".join([str(x) for x in sys.version_info[0:3]]) # map(str,sys.version_info[0:3]))
 108
 109     def getNumpyVersion(self):
 110         "Retourne la version de numpy disponible"
 111         import numpy.version
 112         return numpy.version.version
 113
 114     def getScipyVersion(self):
 115         "Retourne la version de scipy disponible"
 116         if has_scipy:
 117             __version = scipy.version.version
 118         else:
 119             __version = "0.0.0"
 120         return __version
 121
 122     def getMatplotlibVersion(self):
 123         "Retourne la version de matplotlib disponible"
 124         if has_matplotlib:
 125             __version = matplotlib.__version__
 126         else:
 127             __version = "0.0.0"
 128         return __version
 129
 130     def getGnuplotVersion(self):
 131         "Retourne la version de gnuplotpy disponible"
 132         if has_gnuplot:
 133             __version = Gnuplot.__version__
 134         else:
 135             __version = "0.0"
 136         return __version
 137
 138     def getSphinxVersion(self):
 139         "Retourne la version de sphinx disponible"
 140         if has_sphinx:
 141             __version = sphinx.__version__
 142         else:
 143             __version = "0.0.0"
 144         return __version
 145
 146     def getNloptVersion(self):
 147         "Retourne la version de nlopt disponible"
 148         if has_nlopt:
 149             __version = "%s.%s.%s"%(
 150                 nlopt.version_major(),
 151                 nlopt.version_minor(),
 152                 nlopt.version_bugfix(),
 153                 )
 154         else:
 155             __version = "0.0.0"
 156         return __version
 157
 158     def getCurrentMemorySize(self):
 159         "Retourne la taille mémoire courante utilisée"
 160         return 1
 161
 162     def MaximumPrecision(self):
 163         "Retourne la precision maximale flottante pour Numpy"
 164         import numpy
 165         try:
 166             numpy.array([1.,], dtype='float128')
 167             mfp = 'float128'
 168         except Exception:
 169             mfp = 'float64'
 170         return mfp
 171
 172     def MachinePrecision(self):
 173         # Alternative sans module :
 174         # eps = 2.38
 175         # while eps > 0:
 176         #     old_eps = eps
 177         #     eps = (1.0 + eps/2) - 1.0
 178         return sys.float_info.epsilon
 179
 180     def __str__(self):
 181         import daCore.version as dav
 182         return "%s %s (%s)"%(dav.name,dav.version,dav.date)
 183
 184 # ==============================================================================
 185 try:
 186     import scipy
 187     import scipy.version
 188     import scipy.optimize
 189     has_scipy = True
 190 except ImportError:
 191     has_scipy = False
 192
 193 try:
 194     import matplotlib
 195     has_matplotlib = True
 196 except ImportError:
 197     has_matplotlib = False
 198
 199 try:
 200     import Gnuplot
 201     has_gnuplot = True
 202 except ImportError:
 203     has_gnuplot = False
 204
 205 try:
 206     import sphinx
 207     has_sphinx = True
 208 except ImportError:
 209     has_sphinx = False
 210
 211 try:
 212     import nlopt
 213     has_nlopt = True
 214 except ImportError:
 215     has_nlopt = False
 216
 217 try:
 218     import sdf
 219     has_sdf = True
 220 except ImportError:
 221     has_sdf = False
 222
 223 has_salome = bool( "ROOT_SALOME"   in os.environ )
 224 has_yacs   = bool( "YACS_ROOT_DIR" in os.environ )
 225 has_adao   = bool( "ADAO_ROOT_DIR" in os.environ )
 226 has_eficas = bool( "EFICAS_ROOT_DIR" in os.environ )
 227
 228 # ==============================================================================
 229 def uniq(__sequence):
 230     """
 231     Fonction pour rendre unique chaque élément d'une liste, en préservant l'ordre
 232     """
 233     __seen = set()
 234     return [x for x in __sequence if x not in __seen and not __seen.add(x)]
 235
 236 def date2int(__date, __lang="FR"):
 237     """
 238     Fonction de secours, conversion pure : dd/mm/yy hh:mm ---> int(yyyymmddhhmm)
 239     """
 240     __date = __date.strip()
 241     if __date.count('/') == 2 and __date.count(':') == 0 and __date.count(' ') == 0:
 242         d,m,y = __date.split("/")
 243         __number = (10**4)*int(y)+(10**2)*int(m)+int(d)
 244     elif __date.count('/') == 2 and __date.count(':') == 1 and __date.count(' ') > 0:
 245         part1, part2 = __date.split()
 246         d,m,y = part1.strip().split("/")
 247         h,n   = part2.strip().split(":")
 248         __number = (10**8)*int(y)+(10**6)*int(m)+(10**4)*int(d)+(10**2)*int(h)+int(n)
 249     else:
 250         raise ValueError("Cannot convert \"%s\" as a D/M/Y H:M date"%d)
 251     return __number
 252
 253 # ==============================================================================
 254 class PathManagement(object):
 255     """
 256     Mise à jour du path système pour les répertoires d'outils
 257     """
 258     def __init__(self):
 259         "Déclaration des répertoires statiques"
 260         parent = os.path.abspath(os.path.join(os.path.dirname(__file__),".."))
 261         self.__paths = {}
 262         self.__paths["daNumerics"]  = os.path.join(parent,"daNumerics")
 263         #
 264         for v in self.__paths.values():
 265             sys.path.insert(0, v )
 266         #
 267         # Conserve en unique exemplaire chaque chemin
 268         sys.path = uniq( sys.path )
 269         del parent
 270
 271     def getpaths(self):
 272         """
 273         Renvoie le dictionnaire des chemins ajoutés
 274         """
 275         return self.__paths
 276
 277 # ==============================================================================
 278 class SystemUsage(object):
 279     """
 280     Permet de récupérer les différentes tailles mémoires du process courant
 281     """
 282     #
 283     # Le module resource renvoie 0 pour les tailles mémoire. On utilise donc
 284     # plutôt : http://code.activestate.com/recipes/286222/ et Wikipedia
 285     #
 286     _proc_status = '/proc/%d/status' % os.getpid()
 287     _memo_status = '/proc/meminfo'
 288     _scale = {
 289         'o'  : 1.0,     # Multiples SI de l'octet
 290         'ko' : 1.e3,
 291         'Mo' : 1.e6,
 292         'Go' : 1.e9,
 293         'kio': 1024.0,  # Multiples binaires de l'octet
 294         'Mio': 1024.0*1024.0,
 295         'Gio': 1024.0*1024.0*1024.0,
 296         'B':     1.0,   # Multiples binaires du byte=octet
 297         'kB' : 1024.0,
 298         'MB' : 1024.0*1024.0,
 299         'GB' : 1024.0*1024.0*1024.0,
 300         }
 301     #
 302     def __init__(self):
 303         "Sans effet"
 304         pass
 305     #
 306     def _VmA(self, VmKey, unit):
 307         "Lecture des paramètres mémoire de la machine"
 308         try:
 309             t = open(self._memo_status)
 310             v = t.read()
 311             t.close()
 312         except IOError:
 313             return 0.0           # non-Linux?
 314         i = v.index(VmKey)       # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
 315         v = v[i:].split(None, 3) # whitespace
 316         if len(v) < 3:
 317             return 0.0           # invalid format?
 318         # convert Vm value to bytes
 319         mem = float(v[1]) * self._scale[v[2]]
 320         return mem / self._scale[unit]
 321     #
 322     def getAvailablePhysicalMemory(self, unit="o"):
 323         "Renvoie la mémoire physique utilisable en octets"
 324         return self._VmA('MemTotal:', unit)
 325     #
 326     def getAvailableSwapMemory(self, unit="o"):
 327         "Renvoie la mémoire swap utilisable en octets"
 328         return self._VmA('SwapTotal:', unit)
 329     #
 330     def getAvailableMemory(self, unit="o"):
 331         "Renvoie la mémoire totale (physique+swap) utilisable en octets"
 332         return self._VmA('MemTotal:', unit) + self._VmA('SwapTotal:', unit)
 333     #
 334     def getUsableMemory(self, unit="o"):
 335         """Renvoie la mémoire utilisable en octets
 336         Rq : il n'est pas sûr que ce décompte soit juste...
 337         """
 338         return self._VmA('MemFree:', unit) + self._VmA('SwapFree:', unit) + \
 339                self._VmA('Cached:', unit) + self._VmA('SwapCached:', unit)
 340     #
 341     def _VmB(self, VmKey, unit):
 342         "Lecture des paramètres mémoire du processus"
 343         try:
 344             t = open(self._proc_status)
 345             v = t.read()
 346             t.close()
 347         except IOError:
 348             return 0.0           # non-Linux?
 349         i = v.index(VmKey)       # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
 350         v = v[i:].split(None, 3) # whitespace
 351         if len(v) < 3:
 352             return 0.0           # invalid format?
 353         # convert Vm value to bytes
 354         mem = float(v[1]) * self._scale[v[2]]
 355         return mem / self._scale[unit]
 356     #
 357     def getUsedMemory(self, unit="o"):
 358         "Renvoie la mémoire résidente utilisée en octets"
 359         return self._VmB('VmRSS:', unit)
 360     #
 361     def getVirtualMemory(self, unit="o"):
 362         "Renvoie la mémoire totale utilisée en octets"
 363         return self._VmB('VmSize:', unit)
 364     #
 365     def getUsedStacksize(self, unit="o"):
 366         "Renvoie la taille du stack utilisé en octets"
 367         return self._VmB('VmStk:', unit)
 368     #
 369     def getMaxUsedMemory(self, unit="o"):
 370         "Renvoie la mémoire résidente maximale mesurée"
 371         return self._VmB('VmHWM:', unit)
 372     #
 373     def getMaxVirtualMemory(self, unit="o"):
 374         "Renvoie la mémoire totale maximale mesurée"
 375         return self._VmB('VmPeak:', unit)
 376
 377 # ==============================================================================
 378 if __name__ == "__main__":
 379     print('\n AUTODIAGNOSTIC \n')