def _debug(arg, label, dest='RESULTAT'):
"""Generic function for debugging
:param arg: object to print
:type arg: ASSD, string or iterable
:param dest: output 'MESSAGE' or 'RESULTAT'
:type dest: string
"""
if not DEBUG:
return
from code_aster.Cata.Commands import IMPR_CO
from code_aster.Cata.Syntax import _F, ASSD, MCFACT
show = partial(aster.affiche, dest)
if isinstance(arg, ASSD):
show("#DEBUG: {} >>> {} <{}>".format(label, arg.nom, arg.__class__))
IMPR_CO(UNITE=8 if dest == 'RESULTAT' else 6,
CONCEPT=_F(NOM=arg),
NIVEAU=-1)
else:
if type(arg) in (str, unicode):
arg = convert(arg)
else:
try:
if isinstance(arg, _F):
arg = [arg[i] for i in arg]
for obj in arg:
_debug(obj, label, dest)
except TypeError:
arg = repr(arg)
else:
return
show("#DEBUG: {} >>> {}".format(label, arg))
def affiche(self, unite, txt):
"""Affichage du message"""
txt = convert(txt)
if aster_exists:
aster.affiche(unite, txt)
else:
print txt
def _print(*args):
"""Fonction 'print'."""
l_str = []
for arg in args:
if type(arg) not in (str, unicode):
arg = repr(arg)
l_str.append(arg)
text = convert(" ".join(l_str))
if aster_exists:
aster.affiche('MESSAGE', text)
else:
print text
def mess(self, code, message):
# pour imprimer un message d'erreur :
ucode = string.upper(code)
if ucode == 'I':
print "\n<" + ucode + "> INFORMATION: ", convert(message)
elif ucode == 'A':
print "\n<" + ucode + "> ALARME: ", convert(message)
elif ucode == 'E':
print "\n<" + ucode + "> ERREUR: ", convert(message)
self.IER = self.IER + 1
elif ucode == 'F':
print "\n<" + ucode + "> ERREUR: ", convert(message)
self.IER = self.IER + 1
else:
raise StandardError
if ucode == 'E' or ucode == 'A' or ucode == 'F':
if len(self.contxt) > 0:
print " CONTEXTE: "
for c in self.contxt:
print " " + c
if ucode == 'F':
raise StandardError(convert(message))
def print_buffer_content(self, print_as=None, files=None, cc=True):
"""Extrait l'ensemble des messages du buffer dans un dictionnaire unique,
imprime le message, et vide le buffer pour le message suivant.
- code : celui du message le plus grave (cf. dgrav)
- id : celui du premier message qui est affiché
- corps : concaténation de tous les messages.
'print'_as permet d'imprimer un message sur des fichiers autres que les fichiers
habituels de 'code'. Par ex, imprimer un message d'info sur 'ERREUR'.
'files' : liste de noms de fichiers ou objets fichier dans lesquels
écrire le message
'cc' : si True, on écrit comme d'habitude et dans les 'files',
si False, on n'écrit que sur les fichiers habituels (MESSAGE, RESULTAT,
ERREUR) ou bien dans 'files' si fournit.
"""
if type(files) in (str, unicode):
files = files.strip()
if len(self._buffer) < 1:
return None
# construction du dictionnaire du message global
dglob = {
'flags': self.get_current_flags(),
'id_message': self.get_current_id(),
'liste_message': [],
'liste_context': [],
}
dglob['code'], dglob['exc_name'], dglob[
'exc_typ'] = self.get_current_code()
for dictmess in self._buffer:
dglob['liste_message'].append(dictmess['corps_message'])
dglob['liste_context'].append(dictmess['context_info'])
dglob['corps_message'] = ''.join(dglob['liste_message'])
dglob['context_info'] = ''.join(dglob['liste_context'])
# liste des unités d'impression en fonction du type de message
if dglob['flags'] & ALL_UNIT:
print_as = 'E'
l_unit = list_unit(print_as or dglob['code'])
# texte final et impression
if cc or not files:
txt = self.format_message(dglob)
for unite in l_unit:
self.affiche(unite, txt)
# "files"
if files:
copy_text_to(convert(txt), files)
self.init_buffer()
def __str__(self):
return convert(self.msg)
class MESSAGE_LOGGER(Singleton):
"""Classe gérant l'impression de messages.
On ne crée qu'une instance de ce type (singleton).
Cette instance est accessible dans le module aster_core pour les appels
depuis le fortran.
"""
def __init__(self):
"""Initialisation
"""
self.init_buffer()
# est-ce qu'une erreur <E> s'est produite
self.erreur_E = False
# compteur des alarmes émises { 'id_alarm' : count }
self.nmax_alarm = 5
self.count_alarm = {} # dans la commande courante (pour arret à 5)
self.count_alarm_tot = {} # au total
# alarmes à ignorer, à masquer (on ne les compte pas temporairement)
self._ignored_alarm = {}
self._hidden_alarm = {}
# on prépare le dictionnaire des valeurs par défaut des arguments
# (dicarg) :
self.default_args = {}
# initialisation des 50 premiers
for i in range(1, 51):
self.default_args['i%d' % i] = 99999999
self.default_args['r%d' % i] = 9.9999E99
self.default_args['k%d' % i] = u'xxxxxx'
# mettre en cache les messages 'I' (et uniquement 'I')
self._cache_txt = {}
# arguments mpi : ligne de commande à envoyer au proc #0
self._mpi_rank = None
self.init_mpi_error()
def init_mpi_error(self):
"""Stocke les informations nécessaires pour la gestion des erreurs en MPI."""
if not aster_exists:
return
rank = aster_core.MPI_CommRankSize()[0]
self._mpi_rank = aster_core._USE_MPI and rank or None
import platform
node = platform.node()
def __call__(self, *args, **kwargs):
"""Raccourci pour simplifier l'appel depuis astermodule.c et UTMESS.
"""
self.print_message(*args, **kwargs)
def print_message(self,
code,
idmess,
valk=(),
vali=(),
valr=(),
exc_num=None,
exception=False,
print_as=None,
files=None,
cc=True):
"""Appelé par la routine fortran U2MESG ou à la fonction python UTMESS
pour afficher un message.
L'impression de ce message est différée si le `code` est suivi d'un "+".
code : 'A', 'E', 'S', 'F', 'I'
idmess : identificateur du message
valk, vali, valr : liste des chaines, entiers ou réels.
Si exception==True, on lève une exception en cas d'erreur, sinon
c'est l'appelant qui devra s'en charger (dans le C a priori).
'print_as', 'files', 'cc' : cf. print_buffer_content.
"""
idmess = idmess.strip()
# le '+' n'a pas de sens pour les messages 'I'.
if code == "I+":
code = "I"
if code == 'I':
msg = self._cache_txt.get(idmess)
if msg:
try:
self.affiche('MESSAGE',
msg % self.build_dict_args(valk, vali, valr))
return
except:
# le formattage 'brut' échoue, on passera par une
# conversion complète
pass
if self._parent is None:
self.set_parent(idmess)
if not self.update_counter(code, idmess):
return
# récupération du texte du message
dictmess = self.get_message(code, idmess, valk, vali, valr, exc_num)
# on le met dans le buffer
self.add_to_buffer(dictmess)
# si on n'attend pas une suite, ...
if is_last_message(code):
id0 = self.get_current_id().strip()
# vérification des compteurs
self.check_limit()
# on imprime le message en attente
self.print_buffer_content(print_as, files, cc)
if exception and code[0] in ('S', 'F'):
if self._mpi_rank is not None:
aster_core.MPI_Warn()
if self._mpi_rank == 0:
l_unit = list_unit('F')
txt = _(
u"On ne peut pas lever d'exception dans une exécution MPI."
)
for unite in l_unit:
self.affiche(unite, txt)
exc_typ = dictmess.get('exc_typ')
if exc_typ:
raise exc_typ(id0, valk, vali, valr)
raise error(id0, valk, vali, valr)
return None
def build_dict_args(self, valk, vali, valr):
"""Construit le dictionnaire de formatage du message.
"""
# homogénéisation : uniquement des tuples + strip des chaines de
# caractères
valk, vali, valr = map(force_list, (valk, vali, valr))
valk = [k.strip() for k in valk]
# variables passées au message
dicarg = self.default_args.copy()
for i in range(1, len(valk) + 1):
dicarg['k%d' % i] = to_unicode(valk[i - 1])
for i in range(1, len(vali) + 1):
dicarg['i%d' % i] = vali[i - 1]
for i in range(1, len(valr) + 1):
dicarg['r%d' % i] = valr[i - 1]
# valeur spéciale : ktout = concaténation de toutes les chaines
dicarg['ktout'] = ' '.join(valk)
return dicarg
def get_message(self,
code,
idmess,
valk=(),
vali=(),
valr=(),
exc_num=None):
"""Retourne le texte du message dans un dictionnaire dont les clés sont :
'code', 'id_message', 'corps_message'
"""
# décodage : idmess => (catamess, numess)
idmess = idmess.strip()
x = idmess.split("_")
assert len(x) > 1, idmess
catamess = '_'.join(x[0:-1]).lower()
numess = int(x[-1])
assert numess > 0 and numess < 100, idmess
# import catamess => cata_msg
try:
mod = __import__('Messages.%s' % catamess, globals(), locals(),
[catamess])
# si le dictionnaire n'existe pas, on alertera au moment du
# formatage.
cata_msg = getattr(mod, 'cata_msg', {})
except Exception, msg:
# doit permettre d'éviter la récursivité (catamess réservé à
# Utmess)
if catamess != 'catamess':
code = 'A'
if in_testcase():
raise ImportError(
_(u"Fichier de messages non trouvé: {0}").format(
str(msg)))
self.print_message(code,
'CATAMESS_57',
valk=(catamess, str(msg)))
cata_msg = {}
# corps du message
fmt_msg = '?'
try:
dicarg = self.build_dict_args(valk, vali, valr)
# cata_msg[num] = 'format'
# ou { 'message' : 'format',
# 'flags' : 'DECORATED | CENTER',
# 'context' : 'éléments de contexte' }
if type(cata_msg[numess]) == dict:
fmt_msg = cata_msg[numess]['message']
flags = eval(cata_msg[numess].get('flags', 0))
ctxt_msg = cata_msg[numess].get('context', None)
else:
fmt_msg = cata_msg[numess]
flags = 0
ctxt_msg = None
dictmess = {
'code': code,
'flags': flags,
'id_message': idmess,
'corps_message': ufmt(fmt_msg, dicarg),
'context_info': self.get_context(ctxt_msg, idmess, dicarg),
}
if code == 'I':
self._cache_txt[idmess] = convert(fmt_msg)
except Exception, msg:
if code == 'I':
code = 'A'
if in_testcase():
raise SyntaxError(
_(u"Impossible de construire le texte du "
u"message: {0}").format(str(msg)))
dictmess = {
'code':
code,
'flags':
0,
'id_message':
idmess,
'corps_message':
_(u"""Erreur de programmation.
Le message %s n'a pas pu être formaté correctement.
Arguments :
entiers : %s
réels : %s
chaines : %s
format : %s
--------------------------------------------------------------------------
%s
Exception : %s
--------------------------------------------------------------------------
%s"""),
'context_info':
'',
}
args = (idmess, vali, valr, valk, fmt_msg,
''.join(traceback.format_tb(sys.exc_traceback)), msg,
contacter_assistance)
# cette étape ne doit jamais faire planter !
try:
dictmess['corps_message'] = dictmess['corps_message'] % args
except Exception, exc:
dictmess['corps_message'] = repr(args)