"""
- Ce module contient la classe JDC qui sert à interpréter un jeu de commandes
+ Ce module contient la classe JDC qui sert a interpreter un jeu de commandes
"""
# Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+except : pass
import os
-import string
import traceback
import types
import sys
import linecache
# Modules EFICAS
-import N_OBJECT
-import N_CR
-from N_Exception import AsException, InterruptParsingError
-from N_ASSD import ASSD
-from N_info import message, SUPERV
-from strfunc import get_encoding
+from . import N_OBJECT
+from . import N_CR
+from .N_Exception import AsException, InterruptParsingError
+from .N_ASSD import ASSD
+from .strfunc import get_encoding
+from six.moves import range
MemoryErrorMsg = """MemoryError :
-En général, cette erreur se produit car la mémoire utilisée hors du fortran
+En general, cette erreur se produit car la memoire utilisee hors du fortran
(jeveux) est importante.
Causes possibles :
- le calcul produit de gros objets Python dans une macro-commande ou
- dans le jeu de commande lui-même,
+ dans le jeu de commande lui-meme,
- le calcul appelle un solveur (MUMPS par exemple) ou un outil externe
- qui a besoin de mémoire hors jeveux,
+ qui a besoin de memoire hors jeveux,
- utilisation de jeveux dynamique,
- ...
Solution :
- - distinguer la mémoire limite du calcul (case "Mémoire totale" de astk)
- de la mémoire réservée à jeveux (case "dont Aster"), le reste étant
+ - distinguer la memoire limite du calcul (case "Memoire totale" de astk)
+ de la memoire reservee a jeveux (case "dont Aster"), le reste etant
disponible pour les allocations dynamiques.
"""
NONE = None
"""
- from N_utils import SEP
+ from .N_utils import SEP
def __init__(self, definition=None, procedure=None, cata=None,
cata_ord_dico=None, parent=None,
self.procedure = procedure
self.definition = definition
self.cata = cata
- if type(self.cata) != types.TupleType and cata != None:
+ if type(self.cata) != tuple and cata != None:
self.cata = (self.cata,)
self._build_reserved_kw_list()
self.cata_ordonne_dico = cata_ord_dico
self.appli = appli
self.parent = parent
self.context_ini = context_ini
- # On conserve les arguments supplémentaires. Il est possible de passer
+ # On conserve les arguments supplementaires. Il est possible de passer
# des informations globales au JDC par ce moyen. Il pourrait etre plus
# sur de mettre en place le mecanisme des mots-cles pour verifier la
- # validité des valeurs passées.
- # Ceci reste à faire
+ # validite des valeurs passees.
+ # Ceci reste a faire
# On initialise avec les parametres de la definition puis on
# update avec ceux du JDC
self.args = self.definition.args
# on met le jdc lui-meme dans le context global pour l'avoir sous
# l'etiquette "jdc" dans le fichier de commandes
self.g_context = {'jdc': self}
- # message.debug(SUPERV, "g_context : %s - %s", self.g_context, id(self.g_context))
# Dictionnaire pour stocker tous les concepts du JDC (acces rapide par
# le nom)
self.sds_dict = {}
self.index_etape_courante = 0
self.UserError = "UserError"
self.alea = None
- # permet transitoirement de conserver la liste des étapes
+ # permet transitoirement de conserver la liste des etapes
self.hist_etape = False
def compile(self):
"""
Cette methode compile la chaine procedure
- Si des erreurs se produisent, elles sont consignées dans le
+ Si des erreurs se produisent, elles sont consignees dans le
compte-rendu self.cr
"""
try:
encoded_filename = self.nom.encode(get_encoding())
self.proc_compile = compile(
self.procedure, encoded_filename, 'exec')
- except SyntaxError, e:
+ except SyntaxError as e:
if CONTEXT.debug:
traceback.print_exc()
l = traceback.format_exception_only(SyntaxError, e)
- self.cr.exception("Compilation impossible : " + string.join(l))
- except MemoryError, e:
+ self.cr.exception("Compilation impossible : " + ''.join(l))
+ except MemoryError as e:
self.cr.exception(MemoryErrorMsg)
- except SystemError, e:
+ except SystemError as e:
erreurs_connues = """
Causes possibles :
- - offset too large : liste trop longue derrière un mot-clé.
+ - offset too large : liste trop longue derrière un mot-cle.
Solution : liste = (valeurs, ..., )
MOT_CLE = *liste,
"""
def exec_compile(self):
"""
- Cette méthode execute le jeu de commandes compilé dans le contexte
+ Cette methode execute le jeu de commandes compile dans le contexte
self.g_context de l'objet JDC
"""
CONTEXT.set_current_step(self)
- # Le module nommage utilise le module linecache pour accéder
+ # Le module nommage utilise le module linecache pour acceder
# au source des commandes du jeu de commandes.
# Dans le cas d'un fichier, on accède au contenu de ce fichier
- # Dans le cas d'une chaine de caractères il faut accéder
+ # Dans le cas d'une chaine de caractères il faut acceder
# aux commandes qui sont dans la chaine
import linecache
- linecache.cache[self.nom] = 0, 0, string.split(
- self.procedure, '\n'), self.nom
+ linecache.cache[self.nom] = 0, 0, self.procedure.split('\n'), self.nom
try:
- exec self.exec_init in self.g_context
- # message.debug(SUPERV, "JDC.exec_compile_1 - len(g_context) = %d",
- # len(self.g_context.keys()))
+ exec(self.exec_init, self.g_context)
for obj_cata in self.cata:
if type(obj_cata) == types.ModuleType:
init2 = "from " + obj_cata.__name__ + " import *"
- exec init2 in self.g_context
- # message.debug(SUPERV, "JDC.exec_compile_2 - len(g_context) = %d",
- # len(self.g_context.keys()))
+ exec(init2, self.g_context)
- # Initialisation du contexte global pour l'évaluation des conditions de BLOC
+ # Initialisation du contexte global pour l'evaluation des conditions de BLOC
# On utilise une copie de l'initialisation du contexte du jdc
self.condition_context = self.g_context.copy()
# Si l'attribut context_ini n'est pas vide, on ajoute au contexte global
- # le contexte initial (--> permet d'évaluer un JDC en récupérant un contexte
+ # le contexte initial (--> permet d'evaluer un JDC en recuperant un contexte
# d'un autre par exemple)
if self.context_ini:
self.g_context.update(self.context_ini)
# Update du dictionnaire des concepts
- for sdnom, sd in self.context_ini.items():
+ for sdnom, sd in list(self.context_ini.items()):
if isinstance(sd, ASSD):
self.sds_dict[sdnom] = sd
if self.appli != None:
self.appli.affiche_infos(
- 'Interprétation du fichier de commandes en cours ...')
+ 'Interpretation du fichier de commandes en cours ...')
# On sauve le contexte pour garder la memoire des constantes
# En mode edition (EFICAS) ou lors des verifications le contexte
- # est recalculé
+ # est recalcule
# mais les constantes sont perdues
self.const_context = self.g_context
- # message.debug(SUPERV, "pass")
- exec self.proc_compile in self.g_context
- # message.debug(SUPERV, "JDC.exec_compile_3 - len(g_context) = %d",
- # len(self.g_context.keys()))
+ exec(self.proc_compile, self.g_context)
CONTEXT.unset_current_step()
if self.appli != None:
self.affiche_fin_exec()
self.traiter_fin_exec('commande')
- except AsException, e:
+ except AsException as e:
# une erreur a ete identifiee
if CONTEXT.debug:
traceback.print_exc()
- # l'exception a été récupérée avant (où, comment ?),
+ # l'exception a ete recuperee avant (ou, comment ?),
# donc on cherche dans le texte
txt = str(e)
if txt.find('MemoryError') >= 0:
self.cr.exception(txt)
CONTEXT.unset_current_step()
- except NameError, e:
+ except NameError as e:
etype, value, tb = sys.exc_info()
l = traceback.extract_tb(tb)
s = traceback.format_exception_only("Erreur de nom", e)[0][:-1]
self.cr.exception(msg)
CONTEXT.unset_current_step()
- except self.UserError, exc_val:
- self.traiter_user_exception(exc_val)
- CONTEXT.unset_current_step()
- self.affiche_fin_exec()
- self.traiter_fin_exec('commande')
+ # except self.UserError as exc_val:
+ # self.traiter_user_exception(exc_val)
+ # CONTEXT.unset_current_step()
+ # self.affiche_fin_exec()
+ # self.traiter_fin_exec('commande')
except:
# erreur inattendue
# sys_exc_typ,sys_exc_value,sys_exc_frame = sys_exc.info()
- # (tuple de 3 éléments)
+ # (tuple de 3 elements)
if CONTEXT.debug:
traceback.print_exc()
exc_typ, exc_val, exc_fr = sys.exc_info()
l = traceback.format_exception(exc_typ, exc_val, exc_fr)
self.cr.exception(
- "erreur non prevue et non traitee prevenir la maintenance " + '\n' + string.join(l))
+ "erreur non prevue et non traitee prevenir la maintenance " + '\n' + ''.join(l))
del exc_typ, exc_val, exc_fr
CONTEXT.unset_current_step()
Par defaut il n'y a pas de traitement. Elle doit etre surchargee
pour en introduire un
"""
- message.info(SUPERV, "FIN D'EXECUTION %s %s", mode, etape)
+ print ( "FIN D'EXECUTION %s %s" %s( mode, etape))
def traiter_user_exception(self, exc_val):
"""Cette methode realise un traitement sur les exceptions utilisateur
- Par defaut il n'y a pas de traitement. La méthode doit etre
- surchargée pour en introduire un.
+ Par defaut il n'y a pas de traitement. La methode doit etre
+ surchargee pour en introduire un.
"""
return
def register(self, etape):
"""
- Cette méthode ajoute etape dans la liste des etapes : self.etapes
- et retourne un numéro d'enregistrement
+ Cette methode ajoute etape dans la liste des etapes : self.etapes
+ et retourne un numero d'enregistrement
"""
self.etapes.append(etape)
self.index_etapes[etape] = len(self.etapes) - 1
- # message.debug(SUPERV, "#%d %s", self.index_etapes[etape], etape.nom)
return self.g_register(etape)
def o_register(self, sd):
Retourne un identificateur pour concept
"""
self.nsd = self.nsd + 1
- nom = sd.idracine + self.SEP + `self.nsd`
+ nom = sd.idracine + self.SEP + repr(self.nsd)
return nom
def g_register(self, etape):
Retourne un identificateur pour etape
"""
self.nstep = self.nstep + 1
- idetape = etape.idracine + self.SEP + `self.nstep`
+ idetape = etape.idracine + self.SEP + repr(self.nstep)
return idetape
def create_sdprod(self, etape, nomsd):
Cette methode doit fabriquer le concept produit retourne
par l'etape etape et le nommer.
- Elle est appelée à l'initiative de l'etape
+ Elle est appelee a l'initiative de l'etape
pendant le processus de construction de cette etape :
methode __call__ de la classe CMD (OPER ou MACRO)
- Ce travail est réalisé par le contexte supérieur
+ Ce travail est realise par le contexte superieur
(etape.parent) car dans certains cas, le concept ne doit
- pas etre fabriqué mais l'etape doit simplement utiliser
- un concept préexistant.
+ pas etre fabrique mais l'etape doit simplement utiliser
+ un concept preexistant.
Deux cas possibles :
- - Cas 1 : etape.reuse != None : le concept est réutilisé
- - Cas 2 : l'étape appartient à une macro qui a déclaré un
+ - Cas 1 : etape.reuse != None : le concept est reutilise
+ - Cas 2 : l'etape appartient a une macro qui a declare un
concept de sortie qui doit etre produit par cette
etape.
Dans le cas du JDC, le deuxième cas ne peut pas se produire.
Nomme la SD apres avoir verifie que le nommage est possible : nom
non utilise
Si le nom est deja utilise, leve une exception
- Met le concept créé dans le concept global g_context
+ Met le concept cree dans le concept global g_context
"""
o = self.sds_dict.get(sdnom, None)
if isinstance(o, ASSD):
raise AsException("Nom de concept deja defini : %s" % sdnom)
if sdnom in self._reserved_kw:
raise AsException(
- "Nom de concept invalide. '%s' est un mot-clé réservé." % sdnom)
+ "Nom de concept invalide. '%s' est un mot-cle reserve." % sdnom)
# Ajoute a la creation (appel de reg_sd).
self.sds_dict[sdnom] = sd
# du JDC
if restrict == 'non':
self.g_context[sdnom] = sd
- # message.debug(SUPERV, "g_context[%r] = %s", sdnom, sd)
def reg_sd(self, sd):
"""
def delete_concept_after_etape(self, etape, sd):
"""
- Met à jour les étapes du JDC qui sont après etape suite à
+ Met a jour les etapes du JDC qui sont après etape suite a
la disparition du concept sd
"""
- # Cette methode est définie dans le noyau mais ne sert que pendant
+ # Cette methode est definie dans le noyau mais ne sert que pendant
# la phase de creation des etapes et des concepts. Il n'y a aucun
- # traitement particulier à réaliser.
- # Dans d'autres conditions, il faut surcharger cette méthode
+ # traitement particulier a realiser.
+ # Dans d'autres conditions, il faut surcharger cette methode
return
def supprime(self):
etape.supprime()
def clean(self, netapes):
- """Nettoie les `netapes` dernières étapes de la liste des étapes."""
+ """Nettoie les `netapes` dernières etapes de la liste des etapes."""
if self.hist_etape:
return
- for i in xrange(netapes):
+ for i in range(netapes):
e = self.etapes.pop()
jdc = e.jdc
parent = e.parent
e.supprime()
e.parent = parent
e.jdc = jdc
- # message.debug(SUPERV, "JDC.clean - etape = %r - refcount(e) = %d",
- # e.nom, sys.getrefcount(e))
del self.index_etapes[e]
def get_file(self, unite=None, fic_origine='', fname=None):
"""
- Retourne le nom du fichier correspondant à un numero d'unité
+ Retourne le nom du fichier correspondant a un numero d'unite
logique (entier) ainsi que le source contenu dans le fichier
"""
if self.appli:
- # Si le JDC est relié à une application maitre, on délègue la
+ # Si le JDC est relie a une application maitre, on delègue la
# recherche
return self.appli.get_file(unite, fic_origine)
else:
en fonction de la valeur du mot cle PAR_LOT et
du contexte : application maitre ou pas
- En PAR_LOT='NON', il n'y a pas d'ambiguité.
- En PAR_LOT='OUI', E_SUPERV positionne l'attribut à 'NON' après la phase
- d'analyse et juste avant la phase d'exécution.
+ En PAR_LOT='NON', il n'y a pas d'ambiguite.
+ d'analyse et juste avant la phase d'execution.
`user_value` : permet de stocker la valeur choisie par l'utilisateur
pour l'interroger plus tard (par exemple dans `get_contexte_avant`).
"""
- # message.debug(SUPERV, "set par_lot = %r", par_lot)
if user_value:
self.par_lot_user = par_lot
if self.appli == None:
"""
CONTEXT.set_current_step(self)
try:
- # Le module nommage utilise le module linecache pour accéder
+ # Le module nommage utilise le module linecache pour acceder
# au source des commandes du jeu de commandes.
# Dans le cas d'un fichier, on accède au contenu de ce fichier
- # Dans le cas de la console interactive, il faut pouvoir accéder
+ # Dans le cas de la console interactive, il faut pouvoir acceder
# aux commandes qui sont dans le buffer de la console
import linecache
import code
comme DETRUIRE ou les macros
Si etape == None, on retourne le contexte en fin de JDC
"""
- # L'étape courante pour laquelle le contexte a été calculé est
- # mémorisée dans self.index_etape_courante
+ # L'etape courante pour laquelle le contexte a ete calcule est
+ # memorisee dans self.index_etape_courante
# XXX on pourrait faire mieux dans le cas PAR_LOT="NON" : en
- # mémorisant l'étape
- # courante pendant le processus de construction des étapes.
- # Si on insère des commandes (par ex, dans EFICAS), il faut préalablement
- # remettre ce pointeur à 0
- # message.debug(SUPERV, "g_context : %s", [k for k, v in self.g_context.items() if isinstance(v, ASSD)])
- # message.debug(SUPERV, "current_context : %s", [k for k, v in
+ # memorisant l'etape
+ # courante pendant le processus de construction des etapes.
+ # Si on insère des commandes (par ex, dans EFICAS), il faut prealablement
+ # remettre ce pointeur a 0
# self.current_context.items() if isinstance(v, ASSD)])
if self.par_lot_user == 'NON':
d = self.current_context = self.g_context.copy()
return d
# retirer les sd produites par 'etape'
sd_names = [sd.nom for sd in etape.get_created_sd()]
- # message.debug(SUPERV, "reuse : %s, sdprods : %s", etape.reuse,
- # sd_names)
for nom in sd_names:
try:
del d[nom]
if e.isactif():
e.update_context(d)
self.index_etape_courante = index_etape
- # message.debug(SUPERV, "returns : %s", [k for k, v in d.items() if
- # isinstance(v, ASSD)])
return d
def get_global_contexte(self):
"""Retourne "un" contexte global ;-)"""
- # N'est utilisé que par INCLUDE (sauf erreur).
- # g_context est remis à {} en PAR_LOT='OUI'. const_context permet
- # de retrouver ce qui y a été mis par exec_compile.
- # Les concepts n'y sont pas en PAR_LOT='OUI'. Ils sont ajoutés
+ # N'est utilise que par INCLUDE (sauf erreur).
+ # g_context est remis a {} en PAR_LOT='OUI'. const_context permet
+ # de retrouver ce qui y a ete mis par exec_compile.
+ # Les concepts n'y sont pas en PAR_LOT='OUI'. Ils sont ajoutes
# par get_global_contexte de la MACRO.
d = self.const_context.copy()
d.update(self.g_context)
def get_contexte_courant(self, etape_courante=None):
"""
Retourne le contexte tel qu'il est (ou 'sera' si on est en phase
- de construction) au moment de l'exécution de l'étape courante.
+ de construction) au moment de l'execution de l'etape courante.
"""
if etape_courante is None:
etape_courante = CONTEXT.get_current_step()
def get_concept(self, nomsd):
"""
- Méthode pour récuperer un concept à partir de son nom
+ Methode pour recuperer un concept a partir de son nom
"""
co = self.get_contexte_courant().get(nomsd.strip(), None)
if not isinstance(co, ASSD):
def get_concept_by_type(self, nomsd, typesd, etape):
"""
- Méthode pour récuperer un concept à partir de son nom et de son type.
+ Methode pour recuperer un concept a partir de son nom et de son type.
Il aura comme père 'etape'.
"""
assert issubclass(typesd, ASSD), typesd
def del_concept(self, nomsd):
"""
- Méthode pour supprimer la référence d'un concept dans le sds_dict.
- Ne détruire pas le concept (différent de supprime).
+ Methode pour supprimer la reference d'un concept dans le sds_dict.
+ Ne detruire pas le concept (different de supprime).
"""
try:
del self.sds_dict[nomsd.strip()]
def get_cmd(self, nomcmd):
"""
- Méthode pour recuperer la definition d'une commande
+ Methode pour recuperer la definition d'une commande
donnee par son nom dans les catalogues declares
au niveau du jdc
"""
def append_reset(self, etape):
"""
Ajoute une etape provenant d'un autre jdc a la liste des etapes
- et remet à jour la parenté de l'étape et des concepts
+ et remet a jour la parente de l'etape et des concepts
"""
self.etapes.append(etape)
self.index_etapes[etape] = len(self.etapes) - 1
"""On peut acceder aux "valeurs" (jeveux) des ASSD si le JDC est en PAR_LOT="NON".
"""
if CONTEXT.debug:
- print ' `- JDC sd_accessible : PAR_LOT =', self.par_lot
+ print((' `- JDC sd_accessible : PAR_LOT =', self.par_lot))
return self.par_lot == 'NON'
def _build_reserved_kw_list(self):
- """Construit la liste des mots-clés réservés (interdits pour le
+ """Construit la liste des mots-cles reserves (interdits pour le
nommage des concepts)."""
self._reserved_kw = set()
for cat in self.cata:
