Ejemplo n.º 1
0
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))
Ejemplo n.º 2
0
 def affiche(self, unite, txt):
     """Affichage du message"""
     txt = convert(txt)
     if aster_exists:
         aster.affiche(unite, txt)
     else:
         print txt
Ejemplo n.º 3
0
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
Ejemplo n.º 4
0
    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))
Ejemplo n.º 5
0
    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()
Ejemplo n.º 6
0
 def __str__(self):
     return convert(self.msg)
Ejemplo n.º 7
0
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)