sauveVP

[tools/eficas.git] / Noyau / N_ETAPE.py

diff --git a/Noyau/N_ETAPE.py b/Noyau/N_ETAPE.py
index f2b345ca8f1eb348931cb78fd95831c57e1a2785..50c99e7ae03c6efc2bab36df82d899168eea460a 100644 (file)
--- a/Noyau/N_ETAPE.py
+++ b/Noyau/N_ETAPE.py
@@ -19,49 +19,53 @@
 
 
 """
 
 
 """

-    Ce module contient la classe ETAPE qui sert à vérifier et à exécuter
+    Ce module contient la classe ETAPE qui sert a verifier et a executer

     une commande
 """
 
 # Modules Python
     une commande
 """
 
 # Modules Python

+from __future__ import absolute_import
+from __future__ import print_function
+try :
+   from builtins import str
+except :
+   pass

 import types
 import sys
 import types
 import sys

-import string

 import os
 import linecache
 import traceback
 from copy import copy
 
 # Modules EFICAS
 import os
 import linecache
 import traceback
 from copy import copy
 
 # Modules EFICAS

-import N_MCCOMPO
-from N_Exception import AsException
-import N_utils
-from N_utils import AsType
-from N_ASSD import ASSD
-from N_info import message, SUPERV
+from . import N_MCCOMPO
+from .N_Exception import AsException
+from . import N_utils
+from .N_utils import AsType
+from .N_ASSD import ASSD

 
 
 class ETAPE(N_MCCOMPO.MCCOMPO):
 
     """
 
 
 class ETAPE(N_MCCOMPO.MCCOMPO):
 
     """

-       Cette classe hérite de MCCOMPO car ETAPE est un OBJECT composite
+       Cette classe herite de MCCOMPO car ETAPE est un OBJECT composite

 
     """
     nature = "OPERATEUR"
 
 
     """
     nature = "OPERATEUR"
 

-    # L'attribut de classe codex est utilisé pour rattacher le module de calcul éventuel (voir Build)
-    # On le met à None pour indiquer qu'il n'y a pas de module de calcul
-    # rattaché
+    # L'attribut de classe codex est utilise pour rattacher le module de calcul eventuel (voir Build)
+    # On le met a None pour indiquer qu'il n'y a pas de module de calcul
+    # rattache

     codex = None
 
     def __init__(self, oper=None, reuse=None, args={}, niveau=4):
         """
         Attributs :
     codex = None
 
     def __init__(self, oper=None, reuse=None, args={}, niveau=4):
         """
         Attributs :

-         - definition : objet portant les attributs de définition d'une étape de type opérateur. Il
-                        est initialisé par l'argument oper.
-         - reuse : indique le concept d'entrée réutilisé. Il se trouvera donc en sortie
-                   si les conditions d'exécution de l'opérateur l'autorise
-         - valeur : arguments d'entrée de type mot-clé=valeur. Initialisé avec l'argument args.
+         - definition : objet portant les attributs de definition d'une etape de type operateur. Il
+                        est initialise par l'argument oper.
+         - reuse : indique le concept d'entree reutilise. Il se trouvera donc en sortie
+                   si les conditions d'execution de l'operateur l'autorise
+         - valeur : arguments d'entree de type mot-cle=valeur. Initialise avec l'argument args.

         """
         self.definition = oper
         self.reuse = reuse
         """
         self.definition = oper
         self.reuse = reuse


@@ -80,8 +84,8 @@ class ETAPE(N_MCCOMPO.MCCOMPO):
 
     def make_register(self):
         """
 
     def make_register(self):
         """

-        Initialise les attributs jdc, id, niveau et réalise les
-        enregistrements nécessaires
+        Initialise les attributs jdc, id, niveau et realise les
+        enregistrements necessaires

         """
         if self.parent:
             self.jdc = self.parent.get_jdc_root()
         """
         if self.parent:
             self.jdc = self.parent.get_jdc_root()


@@ -94,10 +98,10 @@ class ETAPE(N_MCCOMPO.MCCOMPO):
 
     def nettoiargs(self):
         """
 
     def nettoiargs(self):
         """

-           Cette methode a pour fonction de retirer tous les arguments egaux à None
-           de la liste des arguments. Ils sont supposés non présents et donc retirés.
+           Cette methode a pour fonction de retirer tous les arguments egaux a None
+           de la liste des arguments. Ils sont supposes non presents et donc retires.

         """
         """

-        for k in self.valeur.keys():
+        for k in list(self.valeur.keys()):

             if self.valeur[k] == None:
                 del self.valeur[k]
 
             if self.valeur[k] == None:
                 del self.valeur[k]
 


@@ -110,23 +114,22 @@ class ETAPE(N_MCCOMPO.MCCOMPO):
 
     def Build_sd(self, nom):
         """
 
     def Build_sd(self, nom):
         """

-           Construit le concept produit de l'opérateur. Deux cas
-           peuvent se présenter :
+           Construit le concept produit de l'operateur. Deux cas
+           peuvent se presenter :

 
 

-             - le parent n'est pas défini. Dans ce cas, l'étape prend en charge la création
+             - le parent n'est pas defini. Dans ce cas, l'etape prend en charge la creation

                et le nommage du concept.
 
                et le nommage du concept.
 

-             - le parent est défini. Dans ce cas, l'étape demande au parent la création et
+             - le parent est defini. Dans ce cas, l'etape demande au parent la creation et

                le nommage du concept.
 
         """
                le nommage du concept.
 
         """

-        # message.debug(SUPERV, "Build_sd %s", self.nom)

         self.sdnom = nom
         try:
             if self.parent:
                 sd = self.parent.create_sdprod(self, nom)
                 if type(self.definition.op_init) == types.FunctionType:
         self.sdnom = nom
         try:
             if self.parent:
                 sd = self.parent.create_sdprod(self, nom)
                 if type(self.definition.op_init) == types.FunctionType:

-                    apply(self.definition.op_init, (
+                    self.definition.op_init(*(

                         self, self.parent.g_context))
             else:
                 sd = self.get_sd_prod()
                         self, self.parent.g_context))
             else:
                 sd = self.get_sd_prod()


@@ -136,7 +139,7 @@ class ETAPE(N_MCCOMPO.MCCOMPO):
                     # On ne nomme le concept que dans le cas de non reutilisation
                     # d un concept
                     sd.set_name(nom)
                     # On ne nomme le concept que dans le cas de non reutilisation
                     # d un concept
                     sd.set_name(nom)

-        except AsException, e:
+        except AsException as e:

             raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
                               'fichier : ', self.appel[1], e)
         except EOFError:
             raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
                               'fichier : ', self.appel[1], e)
         except EOFError:


@@ -146,7 +149,7 @@ class ETAPE(N_MCCOMPO.MCCOMPO):
                 sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
             raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
                               'fichier : ', self.appel[1] + '\n',
                 sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
             raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
                               'fichier : ', self.appel[1] + '\n',

-                              string.join(l))
+                              ''.join(l))

 
         self.Execute()
         return sd
 
         self.Execute()
         return sd


@@ -161,35 +164,31 @@ class ETAPE(N_MCCOMPO.MCCOMPO):
 
     def get_sd_prod(self):
         """
 
     def get_sd_prod(self):
         """

-            Retourne le concept résultat de l'étape
+            Retourne le concept resultat de l'etape

             Deux cas :
                      - cas 1 : sd_prod de oper n'est pas une fonction
                        il s'agit d'une sous classe de ASSD
             Deux cas :
                      - cas 1 : sd_prod de oper n'est pas une fonction
                        il s'agit d'une sous classe de ASSD

-                       on construit le sd à partir de cette classe
+                       on construit le sd a partir de cette classe

                        et on le retourne
                      - cas 2 : il s'agit d'une fonction
                        et on le retourne
                      - cas 2 : il s'agit d'une fonction

-                       on l'évalue avec les mots-clés de l'étape (mc_liste)
-                       on construit le sd à partir de la classe obtenue
+                       on l'evalue avec les mots-cles de l'etape (mc_liste)
+                       on construit le sd a partir de la classe obtenue

                        et on le retourne
         """
         if type(self.definition.sd_prod) == types.FunctionType:
             d = self.cree_dict_valeurs(self.mc_liste)
             try:
                        et on le retourne
         """
         if type(self.definition.sd_prod) == types.FunctionType:
             d = self.cree_dict_valeurs(self.mc_liste)
             try:

-                sd_prod = apply(self.definition.sd_prod, (), d)
+                sd_prod = self.definition.sd_prod(*(), **d)

             except EOFError:
                 raise
             except EOFError:
                 raise

-            except:
+            except Exception as exc:

                 if CONTEXT.debug:
                     traceback.print_exc()
                 if CONTEXT.debug:
                     traceback.print_exc()

-                l = traceback.format_exception(
-                    sys.exc_info()[0], sys.exc_info()[1],
-                    sys.exc_info()[2])
-                raise AsException("impossible d affecter un type au resultat",
-                                  string.join(l[2:]))
-                #         sys.exc_info()[0],sys.exc_info()[1],)
+                raise AsException("impossible d affecter un type au resultat:",
+                                  str(exc))

         else:
             sd_prod = self.definition.sd_prod
         else:
             sd_prod = self.definition.sd_prod

-        # on teste maintenant si la SD est réutilisée ou s'il faut la créer
+        # on teste maintenant si la SD est reutilisee ou s'il faut la creer

         if self.definition.reentrant != 'n' and self.reuse:
             # Le concept produit est specifie reutilise (reuse=xxx). C'est une erreur mais non fatale.
             # Elle sera traitee ulterieurement.
         if self.definition.reentrant != 'n' and self.reuse:
             # Le concept produit est specifie reutilise (reuse=xxx). C'est une erreur mais non fatale.
             # Elle sera traitee ulterieurement.


@@ -198,14 +197,14 @@ class ETAPE(N_MCCOMPO.MCCOMPO):
             self.sd = sd_prod(etape=self)
             # Si l'operateur est obligatoirement reentrant et reuse n'a pas ete specifie, c'est une erreur.
             # On ne fait rien ici. L'erreur sera traiter par la suite.
             self.sd = sd_prod(etape=self)
             # Si l'operateur est obligatoirement reentrant et reuse n'a pas ete specifie, c'est une erreur.
             # On ne fait rien ici. L'erreur sera traiter par la suite.

-        # précaution
+        # precaution

         if self.sd is not None and not isinstance(self.sd, ASSD):
             raise AsException("""
         if self.sd is not None and not isinstance(self.sd, ASSD):
             raise AsException("""

-Impossible de typer le résultat !
+Impossible de typer le resultat !

 Causes possibles :
    Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte,
 Causes possibles :
    Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte,

-                 soit il y a une "," à la fin d'une commande précédente.
-   Développeur : La fonction "sd_prod" retourne un type invalide.""")
+                 soit il y a une "," a la fin d'une commande precedente.
+   Developpeur : La fonction "sd_prod" retourne un type invalide.""")

         return self.sd
 
     def get_type_produit(self):
         return self.sd
 
     def get_type_produit(self):


@@ -216,34 +215,34 @@ Causes possibles :
 
     def get_type_produit_brut(self):
         """
 
     def get_type_produit_brut(self):
         """

-            Retourne le type du concept résultat de l'étape
+            Retourne le type du concept resultat de l'etape

             Deux cas :
               - cas 1 : sd_prod de oper n'est pas une fonction
                 il s'agit d'une sous classe de ASSD
                 on retourne le nom de la classe
               - cas 2 : il s'agit d'une fonction
             Deux cas :
               - cas 1 : sd_prod de oper n'est pas une fonction
                 il s'agit d'une sous classe de ASSD
                 on retourne le nom de la classe
               - cas 2 : il s'agit d'une fonction

-                on l'évalue avec les mots-clés de l'étape (mc_liste)
-                et on retourne son résultat
+                on l'evalue avec les mots-cles de l'etape (mc_liste)
+                et on retourne son resultat

         """
         if type(self.definition.sd_prod) == types.FunctionType:
             d = self.cree_dict_valeurs(self.mc_liste)
         """
         if type(self.definition.sd_prod) == types.FunctionType:
             d = self.cree_dict_valeurs(self.mc_liste)

-            sd_prod = apply(self.definition.sd_prod, (), d)
+            sd_prod = self.definition.sd_prod(*(), **d)

         else:
             sd_prod = self.definition.sd_prod
         return sd_prod
 
     def get_etape(self):
         """
         else:
             sd_prod = self.definition.sd_prod
         return sd_prod
 
     def get_etape(self):
         """

-           Retourne l'étape à laquelle appartient self
-           Un objet de la catégorie etape doit retourner self pour indiquer que
-           l'étape a été trouvée
+           Retourne l'etape a laquelle appartient self
+           Un objet de la categorie etape doit retourner self pour indiquer que
+           l'etape a ete trouvee

         """
         return self
 
     def supprime(self):
         """
         """
         return self
 
     def supprime(self):
         """

-           Méthode qui supprime toutes les références arrières afin que l'objet puisse
-           etre correctement détruit par le garbage collector
+           Methode qui supprime toutes les references arrières afin que l'objet puisse
+           etre correctement detruit par le garbage collector

         """
         N_MCCOMPO.MCCOMPO.supprime(self)
         self.jdc = None
         """
         N_MCCOMPO.MCCOMPO.supprime(self)
         self.jdc = None


@@ -255,14 +254,11 @@ Causes possibles :
             self.sd.supprime()
 
     def __del__(self):
             self.sd.supprime()
 
     def __del__(self):

-        # message.debug(SUPERV, "__del__ ETAPE %s <%s>", getattr(self, 'nom', 'unknown'), self)
-        # if self.sd:
-            # message.debug(SUPERV, "            sd : %s", self.sd.nom)

         pass
 
     def get_created_sd(self):
         pass
 
     def get_created_sd(self):

-        """Retourne la liste des sd réellement produites par l'étape.
-        Si reuse est présent, `self.sd` a été créée avant, donc n'est pas dans
+        """Retourne la liste des sd reellement produites par l'etape.
+        Si reuse est present, `self.sd` a ete creee avant, donc n'est pas dans

         cette liste."""
         if not self.reuse and self.sd:
             return [self.sd, ]
         cette liste."""
         if not self.reuse and self.sd:
             return [self.sd, ]


@@ -270,7 +266,7 @@ Causes possibles :
 
     def isactif(self):
         """
 
     def isactif(self):
         """

-           Indique si l'étape est active (1) ou inactive (0)
+           Indique si l'etape est active (1) ou inactive (0)

         """
         return self.actif
 
         """
         return self.actif
 


@@ -279,10 +275,9 @@ Causes possibles :
             Methode utilisee pour que l etape self se declare etape
             courante. Utilise par les macros
         """
             Methode utilisee pour que l etape self se declare etape
             courante. Utilise par les macros
         """

-        # message.debug(SUPERV, "call etape.set_current_step", stack_id=-1)

         cs = CONTEXT.get_current_step()
         if self.parent != cs:
         cs = CONTEXT.get_current_step()
         if self.parent != cs:

-            raise AsException("L'étape courante", cs.nom, cs,
+            raise AsException("L'etape courante", cs.nom, cs,

                               "devrait etre le parent de", self.nom, self)
         else:
             CONTEXT.unset_current_step()
                               "devrait etre le parent de", self.nom, self)
         else:
             CONTEXT.unset_current_step()


@@ -295,7 +290,7 @@ Causes possibles :
         """
         cs = CONTEXT.get_current_step()
         if self != cs:
         """
         cs = CONTEXT.get_current_step()
         if self != cs:

-            raise AsException("L'étape courante", cs.nom, cs,
+            raise AsException("L'etape courante", cs.nom, cs,

                               "devrait etre", self.nom, self)
         else:
             CONTEXT.unset_current_step()
                               "devrait etre", self.nom, self)
         else:
             CONTEXT.unset_current_step()


@@ -307,13 +302,13 @@ Causes possibles :
             sous etape de self ou non
             1 = oui
             0 = non
             sous etape de self ou non
             1 = oui
             0 = non

-            Une étape simple n'a pas de sous etape
+            Une etape simple n'a pas de sous etape

         """
         return 0
 
     def get_file(self, unite=None, fic_origine='', fname=None):
         """
         """
         return 0
 
     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.jdc:
             logique (entier) ainsi que le source contenu dans le fichier
         """
         if self.jdc:


@@ -347,12 +342,12 @@ Causes possibles :
             l'appelant en argument (d) en fonction de sa definition
         """
         if type(self.definition.op_init) == types.FunctionType:
             l'appelant en argument (d) en fonction de sa definition
         """
         if type(self.definition.op_init) == types.FunctionType:

-            apply(self.definition.op_init, (self, d))
+            self.definition.op_init(*(self, d))

         if self.sd:
             d[self.sd.nom] = self.sd
 
     def copy(self):
         if self.sd:
             d[self.sd.nom] = self.sd
 
     def copy(self):

-        """ Méthode qui retourne une copie de self non enregistrée auprès du JDC
+        """ Methode qui retourne une copie de self non enregistree auprès du JDC

             et sans sd
         """
         etape = copy(self)
             et sans sd
         """
         etape = copy(self)


@@ -369,13 +364,13 @@ Causes possibles :
         return etape
 
     def copy_reuse(self, old_etape):
         return etape
 
     def copy_reuse(self, old_etape):

-        """ Méthode qui copie le reuse d'une autre étape.
+        """ Methode qui copie le reuse d'une autre etape.

         """
         if hasattr(old_etape, "reuse"):
             self.reuse = old_etape.reuse
 
     def copy_sdnom(self, old_etape):
         """
         if hasattr(old_etape, "reuse"):
             self.reuse = old_etape.reuse
 
     def copy_sdnom(self, old_etape):

-        """ Méthode qui copie le sdnom d'une autre étape.
+        """ Methode qui copie le sdnom d'une autre etape.

         """
         if hasattr(old_etape, "sdnom"):
             self.sdnom = old_etape.sdnom
         """
         if hasattr(old_etape, "sdnom"):
             self.sdnom = old_etape.sdnom


@@ -394,7 +389,7 @@ Causes possibles :
 
     def get_cmd(self, nomcmd):
         """
 
     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
             Appele par un ops d'une macro en Python
             donnee par son nom dans les catalogues declares
             au niveau du jdc
             Appele par un ops d'une macro en Python


@@ -403,16 +398,16 @@ Causes possibles :
 
     def copy_intern(self, etape):
         """
 
     def copy_intern(self, etape):
         """

-            Méthode permettant lors du processus de recopie de copier
+            Methode permettant lors du processus de recopie de copier

             les elements internes d'une etape dans une autre
         """
         return
 
     def full_copy(self, parent=None):
         """
             les elements internes d'une etape dans une autre
         """
         return
 
     def full_copy(self, parent=None):
         """

-           Méthode permettant d'effectuer une copie complète
-           d'une étape (y compris concept produit, éléments internes)
-           Si l'argument parent est fourni, la nouvelle étape
+           Methode permettant d'effectuer une copie complète
+           d'une etape (y compris concept produit, elements internes)
+           Si l'argument parent est fourni, la nouvelle etape

            aura cet objet comme parent.
         """
         new_etape = self.copy()
            aura cet objet comme parent.
         """
         new_etape = self.copy()


@@ -438,22 +433,22 @@ Causes possibles :
             self.parent.NommerSdprod(self.sd, self.sd.nom)
 
     def is_include(self):
             self.parent.NommerSdprod(self.sd, self.sd.nom)
 
     def is_include(self):

-        """Permet savoir si on a affaire à la commande INCLUDE
+        """Permet savoir si on a affaire a la commande INCLUDE

         car le comportement de ces macros est particulier.
         """
         return self.nom.startswith('INCLUDE')
 
     def sd_accessible(self):
         car le comportement de ces macros est particulier.
         """
         return self.nom.startswith('INCLUDE')
 
     def sd_accessible(self):

-        """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD produite par l'étape.
+        """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD produite par l'etape.

         """
         if CONTEXT.debug:
         """
         if CONTEXT.debug:

-            print '`- ETAPE sd_accessible :', self.nom
+            print(('`- ETAPE sd_accessible :', self.nom))

         return self.parent.sd_accessible()
 
     def get_concept(self, nomsd):
         """
         return self.parent.sd_accessible()
 
     def get_concept(self, nomsd):
         """

-            Méthode pour recuperer un concept à partir de son nom
+            Methode pour recuperer un concept a partir de son nom

         """
         """

-        # pourrait être appelée par une commande fortran faisant appel à des fonctions python
+        # pourrait etre appelee par une commande fortran faisant appel a des fonctions python

         # on passe la main au parent
         return self.parent.get_concept(nomsd)
         # on passe la main au parent
         return self.parent.get_concept(nomsd)