1 # -*- coding: utf-8 -*-
3 # Copyright (C) 2008-2018 EDF R&D
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.
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.
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
19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
24 Informations sur le code et la plateforme, et mise à jour des chemins
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 :
31 print(PlatformInfo().getVersion())
32 created = PlatformInfo().getDate()
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 :
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
44 __author__ = "Jean-Philippe ARGAUD"
52 # ==============================================================================
53 class PlatformInfo(object):
55 Rassemblement des informations sur le code et la plateforme
62 "Retourne le nom de l'application"
63 import daCore.version as dav
67 "Retourne le numéro de la version"
68 import daCore.version as dav
72 "Retourne la date de création de la version"
73 import daCore.version as dav
77 "Retourne l'année de création de la version"
78 import daCore.version as dav
81 def getSystemInformation(self, __prefix=""):
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 len(platform.processor())>0:
89 __msg += "\n%s%30s : %s" %(__prefix,"platform.processor",platform.processor())
91 if sys.platform.startswith('linux'):
92 if hasattr(platform, 'linux_distribution'):
93 __msg += "\n%s%30s : %s" %(__prefix,
94 "platform.linux_distribution",str(platform.linux_distribution()))
96 __msg += "\n%s%30s : %s" %(__prefix,"platform.dist",str(platform.dist()))
97 elif sys.platform.startswith('darwin'):
98 if hasattr(platform, 'mac_ver'):
99 __macosxv = {'5': 'Leopard', '6': 'Snow Leopard', '7': 'Lion',
100 '8': 'Mountain Lion', '9': 'Mavericks', '10': 'Yosemite',
101 '11': 'El Capitan', '12': 'Sierra'}
102 for key in __macosxv:
103 if (platform.mac_ver()[0].split('.')[1] == key):
104 __msg += "\n%s%30s : %s" %(__prefix,
105 "platform.mac_ver",str(platform.mac_ver()[0]+"(" + macosx_dict[key]+")"))
107 __msg += "\n%s%30s : %s" %(__prefix,"platform.dist",str(platform.dist()))
108 elif os.name == 'nt':
109 __msg += "\n%s%30s : %s" %(__prefix,"platform.win32_ver",platform.win32_ver()[1])
112 __msg += "\n%s%30s : %s" %(__prefix,"platform.python_implementation",platform.python_implementation())
113 __msg += "\n%s%30s : %s" %(__prefix,"sys.executable",sys.executable)
114 __msg += "\n%s%30s : %s" %(__prefix,"sys.version",sys.version.replace('\n',''))
115 __msg += "\n%s%30s : %s" %(__prefix,"sys.getfilesystemencoding",str(sys.getfilesystemencoding()))
116 __msg += "\n%s%30s : %s" %(__prefix,"locale.getdefaultlocale",str(locale.getdefaultlocale()))
118 __msg += "\n%s%30s : %s" %(__prefix,"platform.node",platform.node())
119 __msg += "\n%s%30s : %s" %(__prefix,"os.path.expanduser",os.path.expanduser('~'))
122 def getPythonVersion(self):
123 "Retourne la version de python disponible"
124 return ".".join([str(x) for x in sys.version_info[0:3]]) # map(str,sys.version_info[0:3]))
126 def getNumpyVersion(self):
127 "Retourne la version de numpy disponible"
129 return numpy.version.version
131 def getScipyVersion(self):
132 "Retourne la version de scipy disponible"
134 __version = scipy.version.version
139 def getMatplotlibVersion(self):
140 "Retourne la version de matplotlib disponible"
142 __version = matplotlib.__version__
147 def getGnuplotVersion(self):
148 "Retourne la version de gnuplotpy disponible"
150 __version = Gnuplot.__version__
155 def getSphinxVersion(self):
156 "Retourne la version de sphinx disponible"
158 __version = sphinx.__version__
163 def getNloptVersion(self):
164 "Retourne la version de nlopt disponible"
166 __version = "%s.%s.%s"%(
167 nlopt.version_major(),
168 nlopt.version_minor(),
169 nlopt.version_bugfix(),
175 def getCurrentMemorySize(self):
176 "Retourne la taille mémoire courante utilisée"
179 def MaximumPrecision(self):
180 "Retourne la precision maximale flottante pour Numpy"
183 numpy.array([1.,], dtype='float128')
189 def MachinePrecision(self):
190 # Alternative sans module :
194 # eps = (1.0 + eps/2) - 1.0
195 return sys.float_info.epsilon
198 import daCore.version as dav
199 return "%s %s (%s)"%(dav.name,dav.version,dav.date)
201 # ==============================================================================
205 import scipy.optimize
212 has_matplotlib = True
214 has_matplotlib = False
240 has_salome = bool( "ROOT_SALOME" in os.environ )
241 has_yacs = bool( "YACS_ROOT_DIR" in os.environ )
242 has_adao = bool( "ADAO_ROOT_DIR" in os.environ )
243 has_eficas = bool( "EFICAS_ROOT_DIR" in os.environ )
245 # ==============================================================================
246 def uniq( __sequence ):
248 Fonction pour rendre unique chaque élément d'une liste, en préservant l'ordre
251 return [x for x in __sequence if x not in __seen and not __seen.add(x)]
253 def isIterable( __sequence, __check = False, __header = "" ):
255 Vérification que l'argument est un itérable
257 if isinstance( __sequence, (list, tuple, map) ):
259 elif type(__sequence).__name__ in ('generator','range'):
261 elif "_iterator" in type(__sequence).__name__:
265 if __check and not __isOk:
266 raise TypeError("Not iterable or unkown input type%s: %s"%(__header, type(__sequence),))
269 def date2int( __date, __lang="FR" ):
271 Fonction de secours, conversion pure : dd/mm/yy hh:mm ---> int(yyyymmddhhmm)
273 __date = __date.strip()
274 if __date.count('/') == 2 and __date.count(':') == 0 and __date.count(' ') == 0:
275 d,m,y = __date.split("/")
276 __number = (10**4)*int(y)+(10**2)*int(m)+int(d)
277 elif __date.count('/') == 2 and __date.count(':') == 1 and __date.count(' ') > 0:
278 part1, part2 = __date.split()
279 d,m,y = part1.strip().split("/")
280 h,n = part2.strip().split(":")
281 __number = (10**8)*int(y)+(10**6)*int(m)+(10**4)*int(d)+(10**2)*int(h)+int(n)
283 raise ValueError("Cannot convert \"%s\" as a D/M/Y H:M date"%d)
286 # ==============================================================================
287 class PathManagement(object):
289 Mise à jour du path système pour les répertoires d'outils
292 "Déclaration des répertoires statiques"
293 parent = os.path.abspath(os.path.join(os.path.dirname(__file__),".."))
295 self.__paths["daNumerics"] = os.path.join(parent,"daNumerics")
297 for v in self.__paths.values():
298 sys.path.insert(0, v )
300 # Conserve en unique exemplaire chaque chemin
301 sys.path = uniq( sys.path )
306 Renvoie le dictionnaire des chemins ajoutés
310 # ==============================================================================
311 class SystemUsage(object):
313 Permet de récupérer les différentes tailles mémoires du process courant
316 # Le module resource renvoie 0 pour les tailles mémoire. On utilise donc
317 # plutôt : http://code.activestate.com/recipes/286222/ et Wikipedia
319 _proc_status = '/proc/%d/status' % os.getpid()
320 _memo_status = '/proc/meminfo'
322 'o' : 1.0, # Multiples SI de l'octet
326 'kio': 1024.0, # Multiples binaires de l'octet
327 'Mio': 1024.0*1024.0,
328 'Gio': 1024.0*1024.0*1024.0,
329 'B': 1.0, # Multiples binaires du byte=octet
331 'MB' : 1024.0*1024.0,
332 'GB' : 1024.0*1024.0*1024.0,
339 def _VmA(self, VmKey, unit):
340 "Lecture des paramètres mémoire de la machine"
342 t = open(self._memo_status)
346 return 0.0 # non-Linux?
347 i = v.index(VmKey) # get VmKey line e.g. 'VmRSS: 9999 kB\n ...'
348 v = v[i:].split(None, 3) # whitespace
350 return 0.0 # invalid format?
351 # convert Vm value to bytes
352 mem = float(v[1]) * self._scale[v[2]]
353 return mem / self._scale[unit]
355 def getAvailablePhysicalMemory(self, unit="o"):
356 "Renvoie la mémoire physique utilisable en octets"
357 return self._VmA('MemTotal:', unit)
359 def getAvailableSwapMemory(self, unit="o"):
360 "Renvoie la mémoire swap utilisable en octets"
361 return self._VmA('SwapTotal:', unit)
363 def getAvailableMemory(self, unit="o"):
364 "Renvoie la mémoire totale (physique+swap) utilisable en octets"
365 return self._VmA('MemTotal:', unit) + self._VmA('SwapTotal:', unit)
367 def getUsableMemory(self, unit="o"):
368 """Renvoie la mémoire utilisable en octets
369 Rq : il n'est pas sûr que ce décompte soit juste...
371 return self._VmA('MemFree:', unit) + self._VmA('SwapFree:', unit) + \
372 self._VmA('Cached:', unit) + self._VmA('SwapCached:', unit)
374 def _VmB(self, VmKey, unit):
375 "Lecture des paramètres mémoire du processus"
377 t = open(self._proc_status)
381 return 0.0 # non-Linux?
382 i = v.index(VmKey) # get VmKey line e.g. 'VmRSS: 9999 kB\n ...'
383 v = v[i:].split(None, 3) # whitespace
385 return 0.0 # invalid format?
386 # convert Vm value to bytes
387 mem = float(v[1]) * self._scale[v[2]]
388 return mem / self._scale[unit]
390 def getUsedMemory(self, unit="o"):
391 "Renvoie la mémoire résidente utilisée en octets"
392 return self._VmB('VmRSS:', unit)
394 def getVirtualMemory(self, unit="o"):
395 "Renvoie la mémoire totale utilisée en octets"
396 return self._VmB('VmSize:', unit)
398 def getUsedStacksize(self, unit="o"):
399 "Renvoie la taille du stack utilisé en octets"
400 return self._VmB('VmStk:', unit)
402 def getMaxUsedMemory(self, unit="o"):
403 "Renvoie la mémoire résidente maximale mesurée"
404 return self._VmB('VmHWM:', unit)
406 def getMaxVirtualMemory(self, unit="o"):
407 "Renvoie la mémoire totale maximale mesurée"
408 return self._VmB('VmPeak:', unit)
410 # ==============================================================================
411 if __name__ == "__main__":
412 print('\n AUTODIAGNOSTIC \n')