From: PASCALE NOYRET <pascale.noyret@edf.fr>
Date: Fri, 8 Dec 2023 09:22:56 +0000 (+0100)
Subject: Editeur
X-Git-Tag: avantLeRenommagePourEric~14
X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=f65ba12f9648c237971d3b67e9d3f523e2035a6f;p=tools%2Feficas.git

Editeur
---

diff --git a/Editeur/Objecttreeitem.py b/Editeur/Objecttreeitem.py
index 8b6fbbd6..20e4155d 100644
--- a/Editeur/Objecttreeitem.py
+++ b/Editeur/Objecttreeitem.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021   EDF R&D
+# Copyright (C) 2007-2024   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -19,16 +19,10 @@
 #
 """
 """
-# import generaux
-from __future__ import absolute_import
-from __future__ import print_function
-try :
-    from builtins import str
-    from builtins import object
-except :
-    pass
-import types,os,glob,imp,sys
-from copy import copy,deepcopy
+from builtins import str
+from builtins import object
+import types, os, sys
+from copy import copy, deepcopy
 
 # import du chargeur de composants
 from .comploader import makeObjecttreeitem
@@ -36,14 +30,13 @@ from Ihm import CONNECTOR
 from Extensions.i18n import tr
 from Extensions.eficas_exception import EficasException
 
-try :
-    from repr import Repr
-except :
-    from reprlib import Repr
+from reprlib import Repr
+
 myrepr = Repr()
 myrepr.maxstring = 100
 myrepr.maxother = 100
 
+
 class TreeItem(object):
 
     """Abstract class representing tree items.
@@ -52,6 +45,7 @@ class TreeItem(object):
     is used.
 
     """
+
     # itemNode est une factory qui doit retourner un objet de la classe Node
     # ou derive de cette classe.
     # Le widget arbre utilisera cet objet comme noeud associe au tree item.
@@ -61,7 +55,7 @@ class TreeItem(object):
     # ou treeOrNode est le noeud parent, item est l'item associe
     # command est une fonction python appelee sur selection graphique
     # du noeud et rmenu est une fonction python appelee sur click droit sur le noeud
-    itemNode=None
+    itemNode = None
 
     def __init__(self):
         """Constructor.  Do whatever you need to do."""
@@ -75,7 +69,6 @@ class TreeItem(object):
     expandable = None
 
     def _isExpandable(self):
-        """Do not override!  Called by TreeNode."""
         if self.expandable is None:
             self.expandable = self.isExpandable()
         return self.expandable
@@ -95,21 +88,28 @@ class TreeItem(object):
 
     def IsEditable(self):
         """Return whether the item's text may be edited."""
+        pass
 
     def SetText(self, text):
         """Change the item's text (if it is editable)."""
+        pass
 
     def getIconName(self):
         """Return name of icon to be displayed normally."""
+        pass
 
     def getSelectedIconName(self):
         """Return name of icon to be displayed when selected."""
+        pass
 
     def getSubList(self):
         """Return list of items forming sublist."""
+        pass
 
     def onDoubleClick(self):
         """Called on a double-click on the item."""
+        pass
+
 
 class Delegate(object):
     def __init__(self, delegate=None):
@@ -124,7 +124,7 @@ class Delegate(object):
         return self.object
 
     def __getattr__(self, name):
-        attr = getattr(self.object, name) # May raise AttributeError
+        attr = getattr(self.object, name)  # May raise AttributeError
         setattr(self, name, attr)
         self.__cache[name] = attr
         return attr
@@ -140,10 +140,10 @@ class Delegate(object):
     def cachereport(self):
         keys = list(self.__cache.keys())
         keys.sort()
-        #print keys
+        # print keys
 
 
-class ObjectTreeItem(TreeItem,Delegate):
+class ObjectTreeItem(TreeItem, Delegate):
     def __init__(self, appliEficas, labeltext, object, setFunction=None):
         self.labeltext = labeltext
         self.appliEficas = appliEficas
@@ -153,13 +153,13 @@ class ObjectTreeItem(TreeItem,Delegate):
         # Attention : le delegue peut etre different de l'objet associe (MCLIST)
         # Dans le cas d'une MCListe de longueur 1, l'objet associe est la MCListe
         # et l'objet delegue est le MCFACT (object = _object.data[0])
-        Delegate.__init__(self,object)
+        Delegate.__init__(self, object)
         # On cache l'objet initial (pour destruction eventuelle
         # ulterieure)
         self._object = object
         self.setFunction = setFunction
         self.expandable = 1
-        self.sublist=[]
+        self.sublist = []
         self.init()
 
     def init(self):
@@ -168,13 +168,13 @@ class ObjectTreeItem(TreeItem,Delegate):
     def getObject(self):
         return self._object
 
-    def connect(self,channel,callable,args):
-        """ Connecte la fonction callable (avec arguments args) a l'item self sur le
-            canal channel
+    def connect(self, channel, callable, args):
+        """Connecte la fonction callable (avec arguments args) a l'item self sur le
+        canal channel
         """
-        #print self,channel,callable,args
-        CONNECTOR.Connect(self._object,channel,callable,args)
-        CONNECTOR.Connect(self.object, channel,callable,args)
+        # print self,channel,callable,args
+        CONNECTOR.Connect(self._object, channel, callable, args)
+        CONNECTOR.Connect(self.object, channel, callable, args)
 
     def copy(self):
         """
@@ -184,71 +184,71 @@ class ObjectTreeItem(TreeItem,Delegate):
         appliEficas = copy(self.appliEficas)
         labeltext = copy(self.labeltext)
         fonction = deepcopy(self.setFunction)
-        item = makeObjecttreeitem(appliEficas,labeltext,object,fonction)
+        item = makeObjecttreeitem(appliEficas, labeltext, object, fonction)
         return item
 
     def isActif(self):
-        if hasattr(self.object,'actif'):
+        if hasattr(self.object, "actif"):
             return self.object.actif
         else:
             return 1
 
-    def update(self,item):
+    def update(self, item):
         """
-          Met a jour l'item courant a partir d'un autre item passe en argument
-          Ne fait rien par defaut
+        Met a jour l'item courant a partir d'un autre item passe en argument
+        Ne fait rien par defaut
         """
         pass
 
     def getLabelText(self):
-        """ Retourne 3 valeurs :
+        """Retourne 3 valeurs :
         - le texte a afficher dans le noeud representant l'item
         - la fonte dans laquelle afficher ce texte
         - la couleur du texte
         """
         # None --> fonte et couleur par defaut
-        return tr(self.labeltext),None,None
+        return tr(self.labeltext), None, None
 
-    def getNature(self) :
+    def getNature(self):
         """
-            Retourne la nature de l'item et de l'objet
+        Retourne la nature de l'item et de l'objet
         """
         return self.object.nature
 
     def getRegles(self):
-        """ retourne les regles de l'objet pointe par self """
+        """retourne les regles de l'objet pointe par self"""
         return self.object.getRegles()
 
     def getListeMcPresents(self):
-        """ Retourne la liste des mots-cles fils de l'objet pointe par self """
+        """Retourne la liste des mots-cles fils de l'objet pointe par self"""
         return self.object.listeMcPresents()
 
     def getVal(self):
-        """ Retourne le nom de la valeur de l'objet pointe par self dans le cas
-            ou celle-ci est un objet (ASSD) """
+        """Retourne le nom de la valeur de l'objet pointe par self dans le cas
+        ou celle-ci est un objet (ASSD)"""
         return self.object.getVal()
 
     def get_definition(self):
         """
-           Retourne l'objet definition de l'objet pointe par self
+        Retourne l'objet definition de l'objet pointe par self
         """
         return self.object.definition
 
-    def getListeMcOrdonnee(self,liste,dico):
-        """ retourne la liste ordonnee (suivant le catalogue) brute des mots-cles
-            d'une entite composee dont le chemin complet est donne sous forme
-            d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
-            il faut encore rearranger cette liste (certains mots-cles deja
-            presents ne doivent plus etre proposes, regles ...)"""
-        return self.object.getListeMcOrdonnee(liste,dico)
+    def getListeMcOrdonnee(self, liste, dico):
+        """retourne la liste ordonnee (suivant le catalogue) brute des mots-cles
+        d'une entite composee dont le chemin complet est donne sous forme
+        d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
+        il faut encore rearranger cette liste (certains mots-cles deja
+        presents ne doivent plus etre proposes, regles ...)"""
+        return self.object.getListeMcOrdonnee(liste, dico)
 
-    def getListeMcOrdonneeBrute(self,liste,dico):
+    def getListeMcOrdonneeBrute(self, liste, dico):
         """
         retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles
         d'une entite composee dont le chemin complet est donne sous forme
         d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
         """
-        return self.object.getListeMcOrdonneeBrute(liste,dico)
+        return self.object.getListeMcOrdonneeBrute(liste, dico)
 
     def getGenealogie(self):
         """
@@ -257,7 +257,7 @@ class ObjectTreeItem(TreeItem,Delegate):
         """
         return self.object.getGenealogie()
 
-    def getIndexChild(self,nom_fils):
+    def getIndexChild(self, nom_fils):
         """
         Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
         Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
@@ -265,84 +265,86 @@ class ObjectTreeItem(TreeItem,Delegate):
         """
         return self.object.getIndexChild(nom_fils)
 
-    def getIndexChild_old(self,nom_fils):
+    def getIndexChild_old(self, nom_fils):
         """
         Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
         Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
         le nouveau mot-cle
         """
-        liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(self.getGenealogie(),self.getJdc().cata_ordonne_dico)
+        liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(
+            self.getGenealogie(), self.getJdc().cata_ordonne_dico
+        )
         liste_noms_mc_presents = self.object.listeMcPresents()
-        l=[]
+        l = []
         for nom in liste_noms_mc_ordonnee:
             if nom in liste_noms_mc_presents or nom == nom_fils:
                 l.append(nom)
         # l contient les anciens mots-cles + le nouveau dans l'ordre
         return l.index(nom_fils)
 
-    def appendChild(self,name,pos=None):
+    def appendChild(self, name, pos=None):
         """
-          Permet d'ajouter un item fils a self
+        Permet d'ajouter un item fils a self
         """
-        if pos == 'first':
+        if pos == "first":
             index = 0
-        elif pos == 'last':
+        elif pos == "last":
             index = len(self.listeMcPresents())
-        elif type(pos) == int :
+        elif type(pos) == int:
             # la position est fixee
             index = pos
-        #elif type(pos) == types.InstanceType:
-        elif type(pos) == object :
+        # elif type(pos) == types.InstanceType:
+        elif type(pos) == object:
             # pos est un item. Il faut inserer name apres pos
-            index = self.getIndex(pos) +1
-        #elif type(name) == types.InstanceType:
-        elif type(name) == object :
+            index = self.getIndex(pos) + 1
+        # elif type(name) == types.InstanceType:
+        elif type(name) == object:
             index = self.getIndexChild(name.nom)
         else:
             index = self.getIndexChild(name)
-        return self.addobject(name,index)
+        return self.addobject(name, index)
 
-    def appendBrother(self,name,pos='after'):
+    def appendBrother(self, name, pos="after"):
         """
         Permet d'ajouter un frere a self
         par defaut on l'ajoute apres self
         """
         index = self._object.parent.getIndex(self.getObject())
-        if pos == 'before':
+        if pos == "before":
             index = index
-        elif pos == 'after':
-            index = index +1
+        elif pos == "after":
+            index = index + 1
         else:
             print((tr("%d n'est pas un index valide pour appendBrother", pos)))
             return
-        return self.parent.addobject(name,index)
+        return self.parent.addobject(name, index)
 
     def getCopieObjet(self):
-        """ Retourne une copie de l'objet pointe par self """
+        """Retourne une copie de l'objet pointe par self"""
         return self.object.copy()
 
     def getPosition(self):
-        """ Retourne la valeur de l'attribut position de l'objet pointe par self """
+        """Retourne la valeur de l'attribut position de l'objet pointe par self"""
         definition = self.get_definition()
         try:
-            return getattr(definition,'position')
+            return getattr(definition, "position")
         except AttributeError:
-            return 'local'
+            return "local"
 
     def getNom(self):
-        """ Retourne le nom de l'objet pointe par self """
+        """Retourne le nom de l'objet pointe par self"""
         return self.object.nom
 
     def getJdc(self):
-        """ Retourne le jdc auquel appartient l'objet pointe par self """
+        """Retourne le jdc auquel appartient l'objet pointe par self"""
         return self.object.jdc
 
     def getValeur(self):
-        """ Retourne la valeur de l'objet pointe par self """
+        """Retourne la valeur de l'objet pointe par self"""
         return self.object.valeur
 
     def getCr(self):
-        """ Retourne le compte-rendu CR de self """
+        """Retourne le compte-rendu CR de self"""
         return self.object.report()
 
     def getObjetCommentarise(self):
@@ -351,12 +353,15 @@ class ObjectTreeItem(TreeItem,Delegate):
         representatif de self.object
         --> a surcharger par les differents items
         """
-        raise EficasException("MESSAGE AU DEVELOPPEUR : il faut \
+        raise EficasException(
+            "MESSAGE AU DEVELOPPEUR : il faut \
                                  surcharger la methode getObjetCommentarise() \
-                                 pour la classe %s", self.__class__.__name__)
+                                 pour la classe %s",
+            self.__class__.__name__,
+        )
 
     def isValid(self):
-        """ Retourne 1 si l'objet pointe par self est valide, 0 sinon"""
+        """Retourne 1 si l'objet pointe par self est valide, 0 sinon"""
         return self.object.isValid()
 
     def isCopiable(self):
@@ -367,25 +372,25 @@ class ObjectTreeItem(TreeItem,Delegate):
         return 0
 
     def getMcPresents(self):
-        """ Retourne le dictionnaire des mots-cles presents de l'objet pointe par self """
+        """Retourne le dictionnaire des mots-cles presents de l'objet pointe par self"""
         return self.object.dictMcPresents()
 
-    def verifConditionRegles(self,l_mc_presents):
+    def verifConditionRegles(self, l_mc_presents):
         return self.object.verifConditionRegles(l_mc_presents)
 
     def getFr(self):
-        """ Retourne le fr de l'objet pointe par self """
+        """Retourne le fr de l'objet pointe par self"""
         try:
             return self.object.getFr()
         except:
             return ""
 
     def getDocu(self):
-        """ Retourne la cle de doc de l'objet pointe par self """
+        """Retourne la cle de doc de l'objet pointe par self"""
         return self.object.getDocu()
 
-    def setValeur(self,new_valeur):
-        """ Remplace la valeur de l'objet pointe par self par new_valeur """
+    def setValeur(self, new_valeur):
+        """Remplace la valeur de l'objet pointe par self par new_valeur"""
         return self.object.setValeur(new_valeur)
 
     def getText(self):
@@ -420,36 +425,39 @@ class ObjectTreeItem(TreeItem,Delegate):
                 self.appliEficas,
                 str(key) + " =",
                 value,
-                lambda value, key=key, object=self.object:
-                    setattr(object, key, value))
+                lambda value, key=key, object=self.object: setattr(object, key, value),
+            )
             sublist.append(item)
         return sublist
 
-    # a piori inutile PN 06 11 17
-    #def wait_fichier_init(self):
+        # a piori inutile PN 06 11 17
+        # def wait_fichier_init(self):
         """ Retourne 1 si l'object pointe par self attend un fichier d'initialisation
         (ex: macros POURSUITE et INCLUDE de Code_Aster), 0 SINON """
+
     #    return self.object.definition.fichier_ini
 
-    def makeObjecttreeitem(self,appliEficas,labeltext, object, setFunction=None):
+    def makeObjecttreeitem(self, appliEficas, labeltext, object, setFunction=None):
         """
-           Cette methode, globale pour les objets de type item, permet de construire et de retourner un objet
-           de type item associe a l'object passe en argument.
+        Cette methode, globale pour les objets de type item, permet de construire et de retourner un objet
+        de type item associe a l'object passe en argument.
         """
-        return makeObjecttreeitem(appliEficas,labeltext,object,setFunction)
+        return makeObjecttreeitem(appliEficas, labeltext, object, setFunction)
 
-    #def __del__(self):
+    # def __del__(self):
     #    print "__del__",self
 
+
 class AtomicObjectTreeItem(ObjectTreeItem):
     def isExpandable(self):
         return 0
 
+
 class SequenceTreeItem(ObjectTreeItem):
     def isExpandable(self):
         return len(self._object) > 0
 
-    def __len__(self) :
+    def __len__(self):
         return len(self._object)
 
     def keys(self):
@@ -466,20 +474,20 @@ class SequenceTreeItem(ObjectTreeItem):
     def ajoutPossible(self):
         return self._object.ajoutPossible()
 
-    def getIndex(self,child):
-        """ Retourne le numero de child dans la liste des enfants de self """
+    def getIndex(self, child):
+        """Retourne le numero de child dans la liste des enfants de self"""
         return self._object.getIndex(child.getObject())
 
     def getText(self):
-        return  "    "
+        return "    "
 
-    def addItem(self,obj,pos):
-        self._object.insert(pos,obj)
+    def addItem(self, obj, pos):
+        self._object.insert(pos, obj)
         item = self.makeObjecttreeitem(self.appliEficas, obj.nom + ":", obj)
         return item
 
-    def suppItem(self,item):
-        try :
+    def suppItem(self, item):
+        try:
             self._object.remove(item.getObject())
             # la liste peut etre retournee vide !
             message = "Mot-clef " + item.getObject().nom + " supprime"
@@ -489,24 +497,32 @@ class SequenceTreeItem(ObjectTreeItem):
             return 0
 
     def getSubList(self):
-        isublist=iter(self.sublist)
-        liste=self._object.data
-        iliste=iter(liste)
-        self.sublist=[]
+        isublist = iter(self.sublist)
+        liste = self._object.data
+        iliste = iter(liste)
+        self.sublist = []
 
-        while(1):
-            old_obj=obj=None
+        while 1:
+            old_obj = obj = None
             for item in isublist:
-                old_obj=item.getObject()
-                if old_obj in liste:break
+                old_obj = item.getObject()
+                if old_obj in liste:
+                    break
 
             for obj in iliste:
-                if obj is old_obj:break
+                if obj is old_obj:
+                    break
+
                 # nouvel objet : on cree un nouvel item
                 def setFunction(value, object=obj):
-                    object=value
-                it = self.makeObjecttreeitem(self.appliEficas, obj.nom + " : ", obj, setFunction)
+                    object = value
+
+                it = self.makeObjecttreeitem(
+                    self.appliEficas, obj.nom + " : ", obj, setFunction
+                )
                 self.sublist.append(it)
-            if old_obj is None and obj is None:break
-            if old_obj is obj: self.sublist.append(item)
+            if old_obj is None and obj is None:
+                break
+            if old_obj is obj:
+                self.sublist.append(item)
         return self.sublist
diff --git a/Editeur/__init__.py b/Editeur/__init__.py
index 58d19a98..0b2b77ff 100644
--- a/Editeur/__init__.py
+++ b/Editeur/__init__.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021   EDF R&D
+# Copyright (C) 2007-2024   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
diff --git a/Editeur/analyse_catalogue.py b/Editeur/analyse_catalogue.py
index 200f5994..7a4f86b5 100644
--- a/Editeur/analyse_catalogue.py
+++ b/Editeur/analyse_catalogue.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021   EDF R&D
+# Copyright (C) 2007-2024   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -17,244 +17,238 @@
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
-from __future__ import absolute_import
-from __future__ import print_function
-try :
-    from builtins import str
-    from builtins import object
-except :
-    pass
+from builtins import str
+from builtins import object
 
-import re,six.moves.cPickle,os
+import re, os
 
 from Extensions.i18n import tr
-from Noyau.N_CR import CR
 
+l_noms_commandes = ["OPER", "PROC", "MACRO", "FORM"]
+l_noms_composes = ["FACT", "BLOC", "NUPL", "FORM"]
+l_noms_simples = [
+    "SIMP",
+]
+l_noms = l_noms_composes + l_noms_simples
 
-#
-__Id__="$Id: analyseCatalogue.py,v 1.9.8.1.2.1.2.6 2014-01-23 09:14:44 pnoyret Exp $"
-__version__="$Name:  $"
-#
-l_noms_commandes = ['OPER','PROC','MACRO','FORM']
-l_noms_composes=['FACT','BLOC','NUPL','FORM']
-l_noms_simples=['SIMP',]
-l_noms=l_noms_composes+l_noms_simples
 
 def elimineCommentaires(text):
-    """ Elimine les lignes de commentaires dans text
-    Attention : supprime sauvagement tous les caracteres entre # et le retour chariot ..."""
-    comments = re.compile(r'#[^\n]*')
-    return comments.sub(u'',text)
+    """Elimine les lignes de commentaires dans text
+    Attention : supprime sauvagement tous les caracteres entre # et le retour chariot ...
+    """
+    comments = re.compile(r"#[^\n]*")
+    return comments.sub("", text)
+
 
 def chercheNom(text):
-    Whitespace = r'[ \f\t]*'
-    Name = r'[a-zA-Z_]\w*'
-    myexpr = '(u'+Name+')'+Whitespace+'='+Whitespace+'$'
-    a=re.search(myexpr,text)
+    Whitespace = r"[ \f\t]*"
+    Name = r"[a-zA-Z_]\w*"
+    myexpr = "(u" + Name + ")" + Whitespace + "=" + Whitespace + "$"
+    a = re.search(myexpr, text)
     return a.group(1)
 
+
 def chercheArgs(text):
     text = text.strip()
     longueur = len(text)
-    if text[0] != '(u':
-        return 'erreur !'
-    else :
+    if text[0] != "(u":
+        return "erreur !"
+    else:
         nbpar = 1
-        for i in range(1,longueur) :
-            if text[i] =='(u':
+        for i in range(1, longueur):
+            if text[i] == "(u":
                 nbpar = nbpar + 1
-            elif text[i] == ')':
+            elif text[i] == ")":
                 nbpar = nbpar - 1
-            else :
+            else:
                 continue
             if nbpar == 0:
                 break
-        if nbpar != 0 :
-            return tr('Erreur ! Erreur !')
-        else :
-            try :
-                return text[1:i],text[i+1:] # on enleve les premiere et derniere parentheses
-            except :
-                return text[1:i],''
+        if nbpar != 0:
+            return tr("Erreur ! Erreur !")
+        else:
+            try:
+                return (
+                    text[1:i],
+                    text[i + 1 :],
+                )  # on enleve les premiere et derniere parentheses
+            except:
+                return text[1:i], ""
+
 
 class ENTITE(object):
     def chercheEnfants(self):
-        try :
+        try:
             self.text = self.text.strip()
-            liste = re.split(u'=',self.text,1)
-            if len(liste)>1 :
-                arg1=liste[0]
-                reste=liste[1]
+            liste = re.split("=", self.text, 1)
+            if len(liste) > 1:
+                arg1 = liste[0]
+                reste = liste[1]
                 reste = reste.strip()
-                if reste[0:4] in l_noms :
-                    nom_mc = chercheNom(arg1+'=')
-                    arg_mc, self.text = chercheArgs(reste[4:])
-                    self.creeMc(nom_mc,arg_mc,reste[0:4])
-                else :
+                if reste[0:4] in l_noms:
+                    nomMc = chercheNom(arg1 + "=")
+                    argMc, self.text = chercheArgs(reste[4:])
+                    self.creeMc(nomMc, argMc, reste[0:4])
+                else:
                     self.text = reste
                 self.chercheEnfants()
-            else :
+            else:
                 # pas de = rencontre
                 return
         except Exception as e:
             self.cr.fatal(tr("Erreur rencontree dans rechercheEnfants : %s", e.__str()))
 
-    def creeMc(self,nom_mc,arg_mc,test):
-        if test in l_noms_composes :
-            mc = FACT_CATA(nom_mc,arg_mc,self)
+    def creeMc(self, nomMc, argMc, test):
+        if test in l_noms_composes:
+            mc = FACT_CATA(nomMc, argMc, self)
             self.children.append(mc)
-        elif test in l_noms_simples :
-            mc = SIMP_CATA(nom_mc,self)
+        elif test in l_noms_simples:
+            mc = SIMP_CATA(nomMc, self)
             self.children.append(mc)
-        else :
-            print (tr("Erreur dans la creation du mot-cle : %s", nom_mc) )
+        else:
+            print(tr("Erreur dans la creation du mot-cle : %s", nomMc))
 
     def construitListeDico(self):
-        l=[]
-        d={}
-        if len(self.children)==0:
-            self.ordre_mc = l
+        l = []
+        d = {}
+        if len(self.children) == 0:
+            self.ordreMC = l
             self.entites = d
             return
-        try :
+        try:
             for child in self.children:
                 l.append(child.nom)
-                d[child.nom]=child
-            self.ordre_mc = l
+                d[child.nom] = child
+            self.ordreMC = l
             self.entites = d
         except:
-            print (("erreur : ", self.nom,  self.__class__))
+            print(("erreur : ", self.nom, self.__class__))
 
-class COMMANDE_CATA(ENTITE) :
-    def __init__(self,nom,args,parent):
+
+class COMMANDE_CATA(ENTITE):
+    def __init__(self, nom, args, parent):
         self.nom = nom
         self.args = args
         self.children = []
         self.text = args
         self.cr = CR()
-        self.cr.debut = "Debut commande %s" %self.nom
-        self.cr.fin = "Fin commande %s" %self.nom
+        self.cr.debut = "Debut commande %s" % self.nom
+        self.cr.fin = "Fin commande %s" % self.nom
         self.chercheEnfants()
         self.construitListeDico()
         parent.cr.add(self.cr)
 
     def affiche(self):
-        texte_cmd = '\n'
-        texte_cmd = texte_cmd + 'Commande :' + self.nom + '\n'
-        for child in self.children :
-            texte_cmd = texte_cmd + child.affiche(1)
-        return texte_cmd
-
-class SIMP_CATA(object) :
-    def __init__(self,nom,parent):
+        texteCmd = "\n"
+        texteCmd = texteCmd + "Commande :" + self.nom + "\n"
+        for child in self.children:
+            texteCmd = texteCmd + child.affiche(1)
+        return texteCmd
+
+
+class SIMP_CATA(object):
+    def __init__(self, nom, parent):
         self.nom = nom
         self.cr = CR()
-        self.cr.debut = "Debut mot-cle simple %s" %self.nom
-        self.cr.fin = "Fin mot-cle simple %s" %self.nom
+        self.cr.debut = "Debut mot-cle simple %s" % self.nom
+        self.cr.fin = "Fin mot-cle simple %s" % self.nom
         parent.cr.add(self.cr)
 
-    def affiche(self,ind):
-        sep = ' '*5
-        return sep*ind+self.nom+'\n'
+    def affiche(self, ind):
+        sep = " " * 5
+        return sep * ind + self.nom + "\n"
+
 
-class FACT_CATA(ENTITE) :
-    def __init__(self,nom,args,parent):
-        self.nom=nom
-        self.args=args
+class FACT_CATA(ENTITE):
+    def __init__(self, nom, args, parent):
+        self.nom = nom
+        self.args = args
         self.children = []
-        self.text=args
+        self.text = args
         self.cr = CR()
-        self.cr.debut = "Debut mot-cle facteur ou bloc %s" %self.nom
-        self.cr.fin = "Fin mot-cle facteur ou bloc %s" %self.nom
+        self.cr.debut = "Debut mot-cle facteur ou bloc %s" % self.nom
+        self.cr.fin = "Fin mot-cle facteur ou bloc %s" % self.nom
         self.chercheEnfants()
         self.construitListeDico()
         parent.cr.add(self.cr)
 
-    def affiche(self,ind):
-        sep = ' '*5
-        text = ''
-        text = text + sep*ind+self.nom+'\n'
-        for child in self.children :
-            text = text + child.affiche(ind+1)
+    def affiche(self, ind):
+        sep = " " * 5
+        text = ""
+        text = text + sep * ind + self.nom + "\n"
+        for child in self.children:
+            text = text + child.affiche(ind + 1)
         return text
 
+
 class CATALOGUE_CATA(object):
-    def __init__(self,parent,fichier):
+    def __init__(self, parent, fichier):
         self.parent = parent
-        self.fichier=fichier
+        self.fichier = fichier
         self.cr = CR()
-        self.cr.debut = "Debut compte-rendu catalogue %s" %self.fichier
-        self.cr.fin = "Fin compte-rendu catalogue %s" %self.fichier
+        self.cr.debut = "Debut compte-rendu catalogue %s" % self.fichier
+        self.cr.fin = "Fin compte-rendu catalogue %s" % self.fichier
         self.ouvrirFichier()
-        self.liste_commandes=[]
-        self.liste_textes_commandes=[]
+        self.listeCommandes = []
+        self.listeTextesCommandes = []
 
     def ouvrirFichier(self):
-        try :
+        try:
             with open(self.fichier) as fd:
-                self.texte_complet=fd.read()
-        except :
+                self.texte_complet = fd.read()
+        except:
             print((tr("Impossible d'ouvrir le fichier : %s ", str(self.fichier))))
             self.cr.fatal(tr("Impossible d'ouvrir le fichier : %s ", str(self.fichier)))
 
-    def constrListTxtCmd(self,text):
+    def constrListTxtCmd(self, text):
         text = elimineCommentaires(text)
-        pattern = '\) *;'
-        liste=re.split(pattern,text)
-        for i in range(0,len(liste)-1):
-            self.liste_textes_commandes.append(liste[i]+')')
-
-    def analyseCommandeOld(self,text):
-        liste = re.split(u'OPER *\(u',text,1)
-        if len(liste) < 2 :
-            liste = re.split(u'PROC *\(u',text,1)
-        if len(liste) < 2 :
-            liste = re.split(u'MACRO *\(u',text,1)
-        if len(liste) < 2 :
-            print ((tr("le texte a analyser n'est pas celui d'une commande ou d'un operateur : "), text))
-            self.cr.fatal(tr("le texte a analyser n'est pas celui d'une commande ou \
-                             d'un operateur : %s", text))
-            return
-        debut = liste[0]
-        fin = liste[1]
-        nom_cmd = chercheNom(debut)
-        if nom_cmd == 'erreur !':
-            print((tr("Erreur dans la recherche  du nom de la commande : "), debut))
-        args_cmd,toto = chercheArgs(u'(u'+fin)
-        if args_cmd == 'erreur !':
-            print((tr("Erreur dans la recherche des  args de la commande :") , debut))
-        cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
-        self.liste_commandes.append(cmd)
-
-    def analyseCommande(self,text):
-        for nom_cmd in l_noms_commandes:
-            liste = re.split(nom_cmd+' *\(u',text,1)
-            if len(liste) == 2 : break
-        if len(liste) < 2 :
-            print((tr("le texte a analyser n'est pas celui d'une commande connue : \
-                            %(v_1)s %(v_2)s", {'v_1': str(l_noms_commandes), 'v_2': text})))
-            self.cr.fatal(tr("le texte a analyser n'est pas celui d'une commande connue : \
-                             %(v_1)s %(v_2)s", {'v_1': str(l_noms_commandes), 'v_2': text}))
+        pattern = "\) *;"
+        liste = re.split(pattern, text)
+        for i in range(0, len(liste) - 1):
+            self.listeTextesCommandes.append(liste[i] + ")")
+
+    def analyseCommande(self, text):
+        for nomCmd in l_noms_commandes:
+            liste = re.split(nomCmd + " *\(u", text, 1)
+            if len(liste) == 2:
+                break
+        if len(liste) < 2:
+            print(
+                (
+                    tr(
+                        "le texte a analyser n'est pas celui d'une commande connue : \
+                            %(v_1)s %(v_2)s",
+                        {"v_1": str(l_noms_commandes), "v_2": text},
+                    )
+                )
+            )
+            self.cr.fatal(
+                tr(
+                    "le texte a analyser n'est pas celui d'une commande connue : \
+                             %(v_1)s %(v_2)s",
+                    {"v_1": str(l_noms_commandes), "v_2": text},
+                )
+            )
             return
         debut = liste[0]
         fin = liste[1]
-        nom_cmd = chercheNom(debut)
-        if nom_cmd == 'erreur !':
-            print(( tr("Erreur dans la recherche du  nom de la commande : "), debut))
-        args_cmd,toto = chercheArgs(u'(u'+fin)
-        if args_cmd == 'erreur !':
-            print(( tr("Erreur dans la recherche des args de la commande : "), debut))
+        nomCmd = chercheNom(debut)
+        if nomCmd == "erreur !":
+            print((tr("Erreur dans la recherche du  nom de la commande : "), debut))
+        args_cmd, toto = chercheArgs("(u" + fin)
+        if args_cmd == "erreur !":
+            print((tr("Erreur dans la recherche des args de la commande : "), debut))
             print((tr(fin)))
-        cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
-        self.liste_commandes.append(cmd)
+        cmd = COMMANDE_CATA(nomCmd, args_cmd, self)
+        self.listeCommandes.append(cmd)
 
-    def analyseTexte(self,texte):
+    def analyseTexte(self, texte):
         self.constrListTxtCmd(texte)
         try:
-            self.parent.configure_barre(len(self.liste_textes_commandes))
+            self.parent.configure_barre(len(self.listeTextesCommandes))
         except:
             pass
-        for texte_commande in self.liste_textes_commandes :
+        for texte_commande in self.listeTextesCommandes:
             try:
                 self.parent.update_barre()
             except:
@@ -263,49 +257,39 @@ class CATALOGUE_CATA(object):
         self.construitListeDico()
 
     def ecritLcmd(self):
-        f=open(u'U:\\EFICAS\\Accas\\cata.txt','w')
-        for cmd in self.liste_commandes :
+        f = open("U:\\EFICAS\\Accas\\cata.txt", "w")
+        for cmd in self.listeCommandes:
             f.write(cmd.affiche())
         f.close()
 
     def construitListeDico(self):
-        l=[]
-        d={}
-        for cmd in self.liste_commandes:
+        l = []
+        d = {}
+        for cmd in self.listeCommandes:
             l.append(cmd.nom)
-            d[cmd.nom]=cmd
-        self.ordre_mc = l
+            d[cmd.nom] = cmd
+        self.ordreMC = l
         self.entites = d
 
     def report(self):
-        """ retourne l'objet rapport du catalogue de commande """
+        """retourne l'objet rapport du catalogue de commande"""
         return self.cr
 
-def analyseCatalogue(parent,nom_cata):
-    cata = CATALOGUE_CATA(parent,nom_cata)
+
+def analyseCatalogue(parent, nom_cata):
+    cata = CATALOGUE_CATA(parent, nom_cata)
     cata.analyseTexte(cata.texte_complet)
     return cata
 
-def analyseCatalogueCommande(parent,nom_cata):
-    cata = CATALOGUE_CATA(parent,nom_cata)
+
+def analyseCatalogueCommande(parent, nom_cata):
+    cata = CATALOGUE_CATA(parent, nom_cata)
     cata.analyseCommande(cata.texte_complet)
     cata.construitListeDico()
     return cata
 
 
-def makeCataPickle(ficCata):
-    """
-    Lance l'analyse de l'ordre des mots-cles dans le catalogue dont le nom
-    est passe en argument et sauvegarde ces infos dans le fichier pickle relu
-    par Eficas
-    """
-    ficCata_p = os.path.splitext(ficCata)[0]+'_pickled.py'
-    cata_ordonne = analyseCatalogue(None,ficCata)
-    f = open(ficCata_p,'w+')
-    p = six.moves.cPickle.Pickler(f)
-    p.dump(cata_ordonne.entites)
-    f.close()
-
-if __name__ == "__main__" :
+if __name__ == "__main__":
     import profile
-    profile.run(u"analyseCatalogue(None,'U:\\EFICAS\\Cata\\cata_saturne.py')")
+
+    profile.run("analyseCatalogue(None,'U:\\EFICAS\\Cata\\cata_saturne.py')")
diff --git a/Editeur/analyse_catalogue_initial.py b/Editeur/analyse_catalogue_initial.py
index 8a5bb62f..d5015023 100644
--- a/Editeur/analyse_catalogue_initial.py
+++ b/Editeur/analyse_catalogue_initial.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021   EDF R&D
+# Copyright (C) 2007-2024   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -17,51 +17,42 @@
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
-from __future__ import absolute_import
-from __future__ import print_function
-try :
-    from builtins import str
-    from builtins import object
-except :
-    pass
-import re,os
+from builtins import str
+from builtins import object
+import re, os
 
 from Extensions.i18n import tr
-#
-__Id__="$Id: analyseCatalogue_initial.py,v 1.2.4.1.2.2.2.4 2017-04-09 14:04:44 pnoyret Exp $"
-__version__="$Name: V7_main $"
-#
 
 
-class Catalogue_initial(object):
-    def __init__(self,fichier):
-        self.liste_commandes=[]
-        self.lignes=[]
-        self.fichier=fichier
+class catalogueInitial(object):
+    def __init__(self, fichier):
+        self.listeCommandes = []
+        self.lignes = []
+        self.fichier = fichier
         self.ouvrirFichier()
         self.constrListTxtCmd()
 
     def ouvrirFichier(self):
-        try :
+        try:
             with open(self.fichier) as fd:
-                self.lignes=fd.readlines()
-        except :
+                self.lignes = fd.readlines()
+        except:
             print(tr("Impossible d'ouvrir le fichier : %s", str(self.fichier)))
 
     def constrListTxtCmd(self):
-        pattern = '^# Ordre Catalogue '
-        for i in self.lignes :
-            if (re.search(pattern,i)):
-                i=i.replace('# Ordre Catalogue ','')
-                i=i.replace('\n','')
-                self.liste_commandes.append(i)
+        pattern = "^# Ordre Catalogue "
+        for i in self.lignes:
+            if re.search(pattern, i):
+                i = i.replace("# Ordre Catalogue ", "")
+                i = i.replace("\n", "")
+                self.listeCommandes.append(i)
 
 
-def analyseCatalogue(nom_cata):
-    cata = Catalogue_initial(nom_cata)
-    return cata.liste_commandes
+def analyseCatalogue(nomCata):
+    cata = catalogueInitial(nomCata)
+    return cata.listeCommandes
 
 
-if __name__ == "__main__" :
-    monCata="/local/noyret/Install_Eficas/EficasQT4/Openturns_StudyOpenTURNS_Cata_Study_V4.py"
+if __name__ == "__main__":
+    monCata = "/local/noyret/Install_Eficas/EficasQT4/Openturns_StudyOpenTURNS_Cata_Study_V4.py"
     analyseCatalogue(monCata)
diff --git a/Editeur/autre_analyse_cata.py b/Editeur/autre_analyse_cata.py
index 359b8bdf..ef253786 100644
--- a/Editeur/autre_analyse_cata.py
+++ b/Editeur/autre_analyse_cata.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021   EDF R&D
+# Copyright (C) 2007-2024   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -21,109 +21,111 @@
    Ce module sert a retrouver l'ordre des mots cles d'un catalogue de
    commandes
 """
-from __future__ import absolute_import
-from __future__ import print_function
-if __name__ == "__main__" :
-    import sys
-    sys.path[:0]=[".."]
-    sys.path[:0]=["../Aster"]
-    sys.path[:0]=["../Saturne"]
+import sys
 
 from Accas import NUPL
 
+
 def traiteEntiteNUPL(entite):
     """
-        Fonction speciale pour les nuplets (classe NUPL)
-        Cette fonction ajoute a l'objet entite un attribut de nom ordre_mc
-        qui est une liste vide.
+    Fonction speciale pour les nuplets (classe NUPL)
+    Cette fonction ajoute a l'objet entite un attribut de nom ordreMC
+    qui est une liste vide.
     """
-    entite.ordre_mc=[]
+    entite.ordreMC = []
+
 
-def traiteEntite(entite,liste_simp_reel):
+def traiteEntite(entite, listeSimpReel):
     """
-        Cette fonction ajoute a l'objet entite un attribut de nom ordre_mc
-        qui est une liste contenant le nom des sous entites dans l'ordre
-        de leur apparition dans le catalogue.
-        L'ordre d'apparition dans le catalogue est donne par l'attribut _no
-        de l'entite
-        La fonction active le meme type de traitement pour les sous entites
-        de entite
+    Cette fonction ajoute a l'objet entite un attribut de nom ordreMC
+    qui est une liste contenant le nom des sous entites dans l'ordre
+    de leur apparition dans le catalogue.
+    L'ordre d'apparition dans le catalogue est donne par l'attribut _no
+    de l'entite
+    La fonction active le meme type de traitement pour les sous entites
+    de entite
     """
-    l=[]
-    for k,v in list(entite.entites.items()):
-        if isinstance(v,NUPL):
+    l = []
+    for k, v in list(entite.entites.items()):
+        if isinstance(v, NUPL):
             traiteEntiteNUPL(v)
         else:
-            traiteReel(v,liste_simp_reel)
-            traiteEntite(v,liste_simp_reel)
+            traiteReel(v, listeSimpReel)
+            traiteEntite(v, listeSimpReel)
             traiteCache(v)
-        l.append((v._no,k))
+        l.append((v._no, k))
     l.sort()
-    entite.ordre_mc=[ item for index, item in l ]
+    entite.ordreMC = [item for index, item in l]
+
 
 def traiteCache(objet):
-    if not hasattr(objet, "cache"): return
-    if objet.cache == 0 :return
-    clef=objet.nom
-    if objet.equiv != None : clef=objet.equiv
-    if hasattr(objet.pere,"mcOblig"):
-        objet.pere.mcOblig[clef]=objet.defaut
-    else :
-        objet.pere.mcOblig={}
-        objet.pere.mcOblig[clef]=objet.defaut
-
-def traiteReel(objet,liste_simp_reel):
+    if not hasattr(objet, "cache"):
+        return
+    if objet.cache == 0:
+        return
+    clef = objet.nom
+    if objet.equiv != None:
+        clef = objet.equiv
+    if hasattr(objet.pere, "mcOblig"):
+        objet.pere.mcOblig[clef] = objet.defaut
+    else:
+        objet.pere.mcOblig = {}
+        objet.pere.mcOblig[clef] = objet.defaut
+
+
+def traiteReel(objet, listeSimpReel):
     if objet.__class__.__name__ == "SIMP":
-        if ( 'R' in objet.type):
-            if objet.nom not in liste_simp_reel :
-                liste_simp_reel.append(objet.nom)
+        if "R" in objet.type:
+            if objet.nom not in listeSimpReel:
+                listeSimpReel.append(objet.nom)
+
 
-def analyseNiveau(cata_ordonne_dico,niveau,liste_simp_reel):
+def analyseNiveau(cata_ordonne_dico, niveau, listeSimpReel):
     """
-        Analyse un niveau dans un catalogue de commandes
+    Analyse un niveau dans un catalogue de commandes
     """
-    if niveau.l_niveaux == ():
+    if niveau.lNiveaux == ():
         # Il n'y a pas de sous niveaux
         for oper in niveau.entites:
-            traiteEntite(oper,liste_simp_reel)
-            cata_ordonne_dico[oper.nom]=oper
+            traiteEntite(oper, listeSimpReel)
+            cata_ordonne_dico[oper.nom] = oper
     else:
-        for niv in niveau.l_niveaux:
-            analyseNiveau(cata_ordonne_dico,niv)
+        for niv in niveau.lNiveaux:
+            analyseNiveau(cata_ordonne_dico, niv)
+
 
 def analyseCatalogue(cata):
     """
-       Cette fonction analyse le catalogue cata pour construire avec l'aide
-       de traiteEntite la structure de donnees ordre_mc qui donne l'ordre
-       d'apparition des mots cles dans le catalogue
-       Elle retourne un dictionnaire qui contient toutes les commandes
-       du catalogue indexees par leur nom
+    Cette fonction analyse le catalogue cata pour construire avec l'aide
+    de traiteEntite la structure de donnees ordreMC qui donne l'ordre
+    d'apparition des mots cles dans le catalogue
+    Elle retourne un dictionnaire qui contient toutes les commandes
+    du catalogue indexees par leur nom
     """
-    cata_ordonne_dico={}
-    liste_simp_reel=[]
-    if cata.JdC.l_niveaux == ():
+    cata_ordonne_dico = {}
+    listeSimpReel = []
+    if cata.JdC.lNiveaux == ():
         # Il n'y a pas de niveaux
         for oper in cata.JdC.commandes:
-            traiteEntite(oper,liste_simp_reel)
-            cata_ordonne_dico[oper.nom]=oper
+            traiteEntite(oper, listeSimpReel)
+            cata_ordonne_dico[oper.nom] = oper
     else:
-        for niv in cata.JdC.l_niveaux:
-            analyseNiveau(cata_ordonne_dico,niv,liste_simp_reel)
-    return cata_ordonne_dico,liste_simp_reel
+        for niv in cata.JdC.lNiveaux:
+            analyseNiveau(cata_ordonne_dico, niv, listeSimpReel)
+    return cata_ordonne_dico, listeSimpReel
+
 
+if __name__ == "__main__":
+    from Test import cataTest
 
-if __name__ == "__main__" :
-    from Cata import cata_STA6
-    dico=analyseCatalogue(cata_STA6)
-    #import cata_saturne
-    #dico=analyseCatalogue(cata_saturne)
+    dico = analyseCatalogue(cataTest)
 
-    def print_entite(entite,dec='  '):
-        print (dec,entite.nom,entite.__class__.__name__)
-        for mocle in entite.ordre_mc:
-            print_entite(entite.entites[mocle],dec=dec+'  ')
+    def print_entite(entite, dec="  "):
+        print(dec, entite.nom, entite.__class__.__name__)
+        for mocle in entite.ordreMC:
+            print_entite(entite.entites[mocle], dec=dec + "  ")
 
-    for k,v in list(dico.items()):
-        print_entite(v,dec='')
+    for k, v in list(dico.items()):
+        print_entite(v, dec="")
 
-    print (dico)
+    print(dico)
diff --git a/Editeur/catadesc.py b/Editeur/catadesc.py
index 3a30d159..8813e943 100644
--- a/Editeur/catadesc.py
+++ b/Editeur/catadesc.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021   EDF R&D
+# Copyright (C) 2007-2024   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -17,14 +17,22 @@
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
-try :
-    from builtins import object
-except : pass
+from builtins import object
 
-class CatalogDescription(object):
 
-    def __init__(self, labelCode, fichierCata, formatFichierOut = "python", formatFichierIn='python',
-                 default = False, code = None,ssCode=None, selectable = True, userName=None):
+class CatalogDescription(object):
+    def __init__(
+        self,
+        labelCode,
+        fichierCata,
+        formatFichierOut="python",
+        formatFichierIn="python",
+        default=False,
+        code=None,
+        ssCode=None,
+        selectable=True,
+        userName=None,
+    ):
         """
         This class can be used to describe an Eficas catalog.
 
@@ -73,48 +81,57 @@ class CatalogDescription(object):
             self.userName = userName
         self.selectable = selectable
 
-
     @staticmethod
     def createFromTuple(cataTuple):
-        #print "Warning: Describing a catalog with a tuple is deprecated. " \
+        # print "Warning: Describing a catalog with a tuple is deprecated. " \
         #      "Please create a CatalogDescription instance directly."
-        if cataTuple[0] == 'TELEMAC':
-            desc = CatalogDescription(code = cataTuple[0],
-                                      ssCode = cataTuple[1],
-                                      labelCode = cataTuple[0]+cataTuple[1],
-                                      fichierCata = cataTuple[2],
-                                      formatFichierOut = cataTuple[3],
-                                      formatFichierIn = cataTuple[4])
+        if cataTuple[0] == "TELEMAC":
+            desc = CatalogDescription(
+                code=cataTuple[0],
+                ssCode=cataTuple[1],
+                labelCode=cataTuple[0] + cataTuple[1],
+                fichierCata=cataTuple[2],
+                formatFichierOut=cataTuple[3],
+                formatFichierIn=cataTuple[4],
+            )
             return desc
-        if cataTuple[0] == 'MAP' :
-            desc = CatalogDescription(code = cataTuple[0],
-                                   labelCode = cataTuple[1],
-                                   fichierCata = cataTuple[2],
-                                   ssCode      = cataTuple[3],
-                                   formatFichierOut = 'MAP',
-                                   formatFichierIn  = 'MAP')
+        if cataTuple[0] == "MAP":
+            desc = CatalogDescription(
+                code=cataTuple[0],
+                labelCode=cataTuple[1],
+                fichierCata=cataTuple[2],
+                ssCode=cataTuple[3],
+                formatFichierOut="MAP",
+                formatFichierIn="MAP",
+            )
         elif len(cataTuple) == 4:
-            desc = CatalogDescription(code = cataTuple[0],
-                                   labelCode = cataTuple[1],
-                                   fichierCata = cataTuple[2],
-                                   formatFichierOut = cataTuple[3],
-                                   formatFichierIn  = 'python')
-        elif len(cataTuple) == 5 :
-            desc = CatalogDescription(code = cataTuple[0],
-                                   labelCode = cataTuple[1],
-                                   fichierCata = cataTuple[2],
-                                   formatFichierOut = cataTuple[3],
-                                   formatFichierIn  = cataTuple[4])
-        elif len(cataTuple) == 6 :
-            desc = CatalogDescription(code = cataTuple[0],
-                                   labelCode = cataTuple[1],
-                                   fichierCata = cataTuple[2],
-                                   formatFichierOut = cataTuple[3],
-                                   formatFichierIn  = cataTuple[4],
-                                   defaut=cataTuple[5])
-        else :
-            print ('pb a la description du catalogue avec les donnees')
-            print (cataTuple)
-            desc=None
+            desc = CatalogDescription(
+                code=cataTuple[0],
+                labelCode=cataTuple[1],
+                fichierCata=cataTuple[2],
+                formatFichierOut=cataTuple[3],
+                formatFichierIn="python",
+            )
+        elif len(cataTuple) == 5:
+            desc = CatalogDescription(
+                code=cataTuple[0],
+                labelCode=cataTuple[1],
+                fichierCata=cataTuple[2],
+                formatFichierOut=cataTuple[3],
+                formatFichierIn=cataTuple[4],
+            )
+        elif len(cataTuple) == 6:
+            desc = CatalogDescription(
+                code=cataTuple[0],
+                labelCode=cataTuple[1],
+                fichierCata=cataTuple[2],
+                formatFichierOut=cataTuple[3],
+                formatFichierIn=cataTuple[4],
+                defaut=cataTuple[5],
+            )
+        else:
+            print("pb a la description du catalogue avec les donnees")
+            print(cataTuple)
+            desc = None
 
         return desc
diff --git a/Editeur/comploader.py b/Editeur/comploader.py
index c802862c..414fda56 100644
--- a/Editeur/comploader.py
+++ b/Editeur/comploader.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021   EDF R&D
+# Copyright (C) 2007-2024   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -30,36 +30,39 @@
      - makeObjecttreeitem(appliEficas,labeltext, object, setFunction=None) -> item : fonction qui retourne un item
        correspondant a l'objet noyau fourni.
 """
-# import generaux
-from __future__ import absolute_import
-import os,glob,types
+import os, glob, types
 
 # Dictionnaire {object : item} permettant d'associer un item a un object
 # Ce dictionnaire est renseigne par la methode chargerComposants
 composants = {}
 
-def chargerComposants(Ihm="QT"):
+
+def chargerComposants(GUIPath):
+    # PN changer Ihm pour avoir le repertoire en parametre
     """
-        Cette fonction a pour but de charger tous les modules composants graphiques
-        (fichiers compo*.py dans le meme repertoire que ce module )
-        et de remplir le dictionnaire composants utilise par makeObjecttreeitem
+    Cette fonction a pour but de charger tous les modules composants graphiques
+    (fichiers compo*.py dans le meme repertoire que ce module )
+    et de remplir le dictionnaire composants utilise par makeObjecttreeitem
     """
-    reper=os.path.dirname(__file__)
-    repertoire=reper+"/../InterfaceQT4"
-    package="InterfaceQT4"
-    listfich=glob.glob(os.path.join(repertoire, "compo*.py"))
+    debug = 0
+    repertoire = os.path.join("..", GUIPath)
+    package = GUIPath
+    listfich = glob.glob(os.path.join(repertoire, "compo*.py"))
     for fichier in listfich:
-        m= os.path.basename(fichier)[:-3]
-        module=__import__(package,globals(),locals(),[m])
+        m = os.path.basename(fichier)[:-3]
+        module = __import__(package, globals(), locals(), [m])
         module = getattr(module, m)
-        composants[module.objet]=module.treeitem
+        composants[module.objet] = module.treeitem
+    if debug:
+        print("fin chargerComposants, composants : ", composants)
     return composants
 
+
 def gettreeitem(object):
     """
-      Cette fonction retourne la classe item associee a l'objet object.
-      Cette classe item depend bien sur de la nature de object, d'ou
-      l'interrogation du dictionnaire composants
+    Cette fonction retourne la classe item associee a l'objet object.
+    Cette classe item depend bien sur de la nature de object, d'ou
+    l'interrogation du dictionnaire composants
     """
     # Si la definition de l'objet a un attribut itemeditor, il indique
     # la classe a utiliser pour l'item
@@ -68,27 +71,36 @@ def gettreeitem(object):
     except:
         pass
 
+    # voir avec Eric ? side car ou 2 try
+    # try:
+    #    return object.definition.itemeditor
+    # except:
+    #    pass
     # On cherche ensuite dans les composants (plugins)
     try:
-        itemtype= composants[object.__class__]
+        itemtype = composants[object.__class__]
         return itemtype
     except:
         pass
 
     # Puis une eventuelle classe heritee (aleatoire car sans ordre)
     for e in list(composants.keys()):
-        if e and isinstance(object,e):
-            itemtype= composants[e]
+        if e and isinstance(object, e):
+            itemtype = composants[e]
             return itemtype
 
     # Si on n'a rien trouve dans les composants on utilise l'objet par defaut
-    itemtype=composants[None]
+    itemtype = composants[None]
     return itemtype
 
-def makeObjecttreeitem(appliEficas,labeltext, object, setFunction=None):
+
+def makeObjecttreeitem(appliEficas, labeltext, object, setFunction=None):
     """
-       Cette fonction permet de construire et de retourner un objet
-       de type item associe a l'object passe en argument.
+    Cette fonction permet de construire et de retourner un objet
+    de type item associe a l'object passe en argument.
     """
+    debug = 0
+    if debug:
+        print(appliEficas, labeltext, object, setFunction)
     c = gettreeitem(object)
-    return c(appliEficas,labeltext, object, setFunction)
+    return c(appliEficas, labeltext, object, setFunction)
diff --git a/Editeur/listePatrons.py b/Editeur/listePatrons.py
index 43003113..b8d6139b 100644
--- a/Editeur/listePatrons.py
+++ b/Editeur/listePatrons.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2007-2021   EDF R&D
+# Copyright (C) 2007-2024   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -16,40 +16,38 @@
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
-from __future__ import absolute_import
-try :
-    from builtins import object
-except : pass
+from builtins import object
 import os
 import re
 
-sous_menus={
-#           "OPENTURNS_STUDY" : {0:{"Essai":"Std.comm"}},
-#            "OPENTURNS_WRAPPER" : {0:{"Essai":"wrapper_exemple.comm"}},
-           }
+# To DO, ajuster les sous-menu
 
-class listePatrons(object) :
+sous_menus = {}
 
-    def __init__(self,code = "ASTER"):
-        repIni=os.path.dirname(os.path.abspath(__file__))
-        self.rep_patrons=repIni+"/Patrons/"+code
-        self.sous_menu={}
-        if code in sous_menus  :
-            self.sous_menu=sous_menus[code]
-        self.code=code
-        self.liste={}
+
+class listePatrons(object):
+    def __init__(self, code="ASTER"):
+        repIni = os.path.dirname(os.path.abspath(__file__))
+        self.rep_patrons = repIni + "/Patrons/" + code
+        self.sous_menu = {}
+        if code in sous_menus:
+            self.sous_menu = sous_menus[code]
+        self.code = code
+        self.liste = {}
         self.traiteListe()
 
     def traiteListe(self):
-        if not (self.code in sous_menus) : return
-        if not (os.path.exists(self.rep_patrons)) : return
+        if not (self.code in sous_menus):
+            return
+        if not (os.path.exists(self.rep_patrons)):
+            return
         for file in os.listdir(self.rep_patrons):
             for i in range(len(self.sous_menu)):
-                clef=list(self.sous_menu[i].keys())[0]
-                chaine=self.sous_menu[i][clef]
-                if re.search(chaine,file) :
+                clef = list(self.sous_menu[i].keys())[0]
+                chaine = self.sous_menu[i][clef]
+                if re.search(chaine, file):
                     if clef in self.liste:
                         self.liste[clef].append(file)
-                    else :
-                        self.liste[clef]=[file]
+                    else:
+                        self.liste[clef] = [file]
                     break
diff --git a/Editeur/session.py b/Editeur/session.py
index 2fd87c62..9235081a 100644
--- a/Editeur/session.py
+++ b/Editeur/session.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021   EDF R&D
+# Copyright (C) 2007-2024   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -55,28 +55,19 @@ comm=ppp
 La session utilisera le catalogue V7.3 en mode debug.
 """
 
-from __future__ import absolute_import
-from __future__ import print_function
-try :
-    from builtins import str
-except :
-    pass
-try:
-    import optparse
-    from optparse import OptionValueError
-except:
-    from Tools import optparse
-    from Tools.optparse import OptionValueError
-
-import os,traceback
-import six.moves.configparser
+from builtins import str
+
+import optparse
+from optparse import OptionValueError
+
+import os, traceback
 import re
 
 from Extensions.i18n import tr
 
 # Les valeurs decodees par optparse sont mises dans un objet dictionnaire-like.
 # On l'utilise comme environnement de session.
-d_env={}
+d_env = {}
 #
 # L'attribut "studies" de d_env est une liste dans laquelle on range les etudes de niveau global.
 # Une etude est stockee dans un dictionnaire.
@@ -94,31 +85,36 @@ d_env={}
 # sont stockees hierarchiquement
 #
 
+
 def checkComm(option, opt_str, value, parser):
-    if not hasattr(parser.values,"studies"):
-        parser.values.studies=[]
-        parser.values.comm=[]
+    if not hasattr(parser.values, "studies"):
+        parser.values.studies = []
+        parser.values.comm = []
     if not os.path.isfile(value):
         raise OptionValueError(tr("le fichier de commandes %s n'existe pas", value))
     parser.values.comm.append(value)
-    d_study={"comm":value}
-    parser.values.current=d_study
+    d_study = {"comm": value}
+    parser.values.current = d_study
     parser.values.studies.append(d_study)
 
+
 def checkPoursuite(option, opt_str, value, parser):
     if parser.values.comm is None:
-        raise OptionValueError(tr("un fichier de commandes doit etre defini avant une poursuite %s", value))
+        raise OptionValueError(
+            tr("un fichier de commandes doit etre defini avant une poursuite %s", value)
+        )
     if not os.path.isfile(value):
         raise OptionValueError(tr("le fichier poursuite %s n'existe pas", value))
-    #current : fichier de commandes en cours de traitement (dictionnaire des infos)
-    comm=parser.values.current
-    d_study={"comm":value}
-    comm["pours"]=d_study
-    parser.values.current=d_study
+    # current : fichier de commandes en cours de traitement (dictionnaire des infos)
+    comm = parser.values.current
+    d_study = {"comm": value}
+    comm["pours"] = d_study
+    parser.values.current = d_study
+
 
 def checkInclude(option, opt_str, value, parser):
     try:
-        args=[int(parser.rargs[0]),parser.rargs[1]]
+        args = [int(parser.rargs[0]), parser.rargs[1]]
     except:
         raise OptionValueError(tr("include mal defini %s", parser.rargs[0:2]))
 
@@ -126,186 +122,298 @@ def checkInclude(option, opt_str, value, parser):
     del parser.rargs[0]
 
     if parser.values.comm is None:
-        raise OptionValueError(tr("un fichier de commandes doit etre defini avant un include %s", args))
+        raise OptionValueError(
+            tr("un fichier de commandes doit etre defini avant un include %s", args)
+        )
     if not os.path.isfile(args[1]):
         raise OptionValueError(tr("le fichier include %s n'existe pas", args[1]))
 
-    comm=parser.values.current
-    comm[args[0]]=args[1]
+    comm = parser.values.current
+    comm[args[0]] = args[1]
 
 
-def checkJdc(config,jdc,parser,fich):
+def checkJdc(config, jdc, parser, fich):
     """
-        Fonction : analyse une section de fichier .ini pour en extraire
-        les informations sur les fichiers poursuite et includes
-        definis dans cette section
-
-        parser : objet analyseur de la ligne de commande
-        fich : nom du fichier .ini en cours d'analyse
-        config : objet de la classe Configparser permettant de parser le fichier fich
-        jdc : nom de la section du fichier fich a analyser
+    Fonction : analyse une section de fichier .ini pour en extraire
+    les informations sur les fichiers poursuite et includes
+    definis dans cette section
+
+    parser : objet analyseur de la ligne de commande
+    fich : nom du fichier .ini en cours d'analyse
+    config : objet de la classe Configparser permettant de parser le fichier fich
+    jdc : nom de la section du fichier fich a analyser
     """
-    d_study={}
+    d_study = {}
 
     for o in config.options(jdc):
         if o == "poursuite":
-            p=config.get(jdc,"poursuite")
-
-            if not config.has_option(p,"comm"):
-                raise OptionValueError(tr(" jdc %(v_1)s manque \
-                                         fichier comm dans section %(v_2)s", \
-                                         {'v_1': fich, 'v_2': p}))
-            comm=config.get(p,"comm")
+            p = config.get(jdc, "poursuite")
+
+            if not config.has_option(p, "comm"):
+                raise OptionValueError(
+                    tr(
+                        " jdc %(v_1)s manque \
+                                         fichier comm dans section %(v_2)s",
+                        {"v_1": fich, "v_2": p},
+                    )
+                )
+            comm = config.get(p, "comm")
             if not os.path.isfile(comm):
-                raise OptionValueError(tr("jdc %(v_1)s, le fichier\
-                                         de commandes %(v_2)s n'existe pas", \
-                                         {'v_1': fich, 'v_2': comm}))
-
-            pours=checkJdc(config,p,parser,fich)
-            pours["comm"]=comm
-            d_study["pours"]=pours
+                raise OptionValueError(
+                    tr(
+                        "jdc %(v_1)s, le fichier\
+                                         de commandes %(v_2)s n'existe pas",
+                        {"v_1": fich, "v_2": comm},
+                    )
+                )
+
+            pours = checkJdc(config, p, parser, fich)
+            pours["comm"] = comm
+            d_study["pours"] = pours
             continue
 
         try:
-            unit=int(o)
+            unit = int(o)
             # si le parametre est un entier, il s'agit d'un include
-            inc=config.get(jdc,o)
+            inc = config.get(jdc, o)
         except EficasException:
             continue
         if not os.path.isfile(inc):
-            raise OptionValueError(tr(" jdc %(v_1)s \
+            raise OptionValueError(
+                tr(
+                    " jdc %(v_1)s \
                                      fichier include %(v_2)s, %(v_3)s \
-                                     n'existe pas", \
-                                     {'v_1': fich, 'v_2': unit, 'v_3': inc}))
-        d_study[unit]=inc
+                                     n'existe pas",
+                    {"v_1": fich, "v_2": unit, "v_3": inc},
+                )
+            )
+        d_study[unit] = inc
 
     return d_study
 
+
 def checkFich(option, opt_str, fich, parser):
     """
-        Fonction : parse le fichier fich (format .ini)
+    Fonction : parse le fichier fich (format .ini)
 
-        option : option en cours de traitement
-        opt_str : chaine de caracteres utilisee par l'utilisateur
-        fich : nom du fichier .ini donne par l'utilisateur
-        parser : objet parseur des options de la ligne de commande
+    option : option en cours de traitement
+    opt_str : chaine de caracteres utilisee par l'utilisateur
+    fich : nom du fichier .ini donne par l'utilisateur
+    parser : objet parseur des options de la ligne de commande
     """
     if not os.path.isfile(fich):
         raise OptionValueError(tr(" le fichier jdc %s n'existe pas", str(fich)))
     if parser.values.fich is None:
-        parser.values.fich=[]
+        parser.values.fich = []
     parser.values.fich.append(fich)
-    if not hasattr(parser.values,"studies"):
-        parser.values.studies=[]
-        parser.values.comm=[]
-    # Python 2 to 3
-    try :
-        import ConfigParser
-        config=ConfigParser.ConfigParser()
-    except :
-        import configparser
-        config=configparser.configparser()
+    if not hasattr(parser.values, "studies"):
+        parser.values.studies = []
+        parser.values.comm = []
+    import configparser
+
+    config = configparser.configparser()
     config.read([fich])
-    if not config.has_option(u"jdc","jdc"):
-        raise OptionValueError(tr(" jdc %s manque option jdc dans section jdc", str(fich)))
-    jdc=config.get(u"jdc","jdc")
-
-    if not config.has_option(jdc,"comm"):
-        raise OptionValueError(tr(" jdc %(v_1)s manque fichier comm \
-                                 dans section %(v_2)s", {'v_1': fich, 'v_2': jdc}))
-    comm=config.get(jdc,"comm")
+    if not config.has_option("jdc", "jdc"):
+        raise OptionValueError(
+            tr(" jdc %s manque option jdc dans section jdc", str(fich))
+        )
+    jdc = config.get("jdc", "jdc")
+
+    if not config.has_option(jdc, "comm"):
+        raise OptionValueError(
+            tr(
+                " jdc %(v_1)s manque fichier comm \
+                                 dans section %(v_2)s",
+                {"v_1": fich, "v_2": jdc},
+            )
+        )
+    comm = config.get(jdc, "comm")
     if not os.path.isfile(comm):
-        raise OptionValueError(tr("jdc %(v_1)s, le fichier de commandes \
-                                 %(v_2)s n'existe pas", {'v_1': fich, 'v_2': comm}))
+        raise OptionValueError(
+            tr(
+                "jdc %(v_1)s, le fichier de commandes \
+                                 %(v_2)s n'existe pas",
+                {"v_1": fich, "v_2": comm},
+            )
+        )
     parser.values.comm.append(comm)
 
-    d_study=checkJdc(config,jdc,parser,fich)
-    d_study["comm"]=comm
+    d_study = checkJdc(config, jdc, parser, fich)
+    d_study["comm"] = comm
     parser.values.studies.append(d_study)
 
-def printPours(d_pours,dec=''):
+
+def printPours(d_pours, dec=""):
     # Les fichiers includes d'abord
-    for k,v in list(d_pours.items()):
-        if k in (u"pours","comm"):continue
-        print(( tr("%(v_1)s include %(v_2)s : %(v_3)s", {'v_1': str(dec), 'v_2': str(k), 'v_3': str(v)})))
+    for k, v in list(d_pours.items()):
+        if k in ("pours", "comm"):
+            continue
+        print(
+            (
+                tr(
+                    "%(v_1)s include %(v_2)s : %(v_3)s",
+                    {"v_1": str(dec), "v_2": str(k), "v_3": str(v)},
+                )
+            )
+        )
 
     if "pours" in d_pours:
         # Description de la poursuite
-        print((tr("%(v_1)s fichier poursuite: %(v_2)s", {'v_1': dec, 'v_2': d_pours["pours"]["comm"]})))
-        printPours(d_pours["pours"],dec=dec+"++")
+        print(
+            (
+                tr(
+                    "%(v_1)s fichier poursuite: %(v_2)s",
+                    {"v_1": dec, "v_2": d_pours["pours"]["comm"]},
+                )
+            )
+        )
+        printPours(d_pours["pours"], dec=dec + "++")
+
 
 def printDEnv():
-    if d_env.studies is None:return
+    if d_env.studies is None:
+        return
     for study in d_env.studies:
         print((tr("nom etude : %s", study["comm"])))
-        printPours(study,dec="++")
+        printPours(study, dec="++")
+
 
 def createparser():
     # creation du parser des options de la ligne de commande
-    #import prefs
-    parser=optparse.OptionParser(usage=tr("utilisation : %prog [options]"), version="%prog 9.5")
-
-    parser.add_option(u"-j","--jdc",dest="comm",type='string',
-                    action="callback",callback=checkComm,
-                    help=tr("nom du fichier de commandes"))
-
-    parser.add_option(u"-p","--poursuite", type="string",dest="pours",
-                  action="callback", callback=checkPoursuite,
-                  help=tr("nom du fichier poursuite"))
-
-    parser.add_option(u"-i","--include",
-                  action="callback", callback=checkInclude,
-                  nargs=2, help=tr("numero d'unite suivi du nom du fichier include"))
-
-    #parser.add_option(u"-f","--fich", type="string",dest="fich",
+    # import prefs
+    parser = optparse.OptionParser(
+        usage=tr("utilisation : %prog [options]"), version="%prog 9.5"
+    )
+
+    parser.add_option(
+        "-j",
+        "--jdc",
+        dest="comm",
+        type="string",
+        action="callback",
+        callback=checkComm,
+        help=tr("nom du fichier de commandes"),
+    )
+
+    parser.add_option(
+        "-p",
+        "--poursuite",
+        type="string",
+        dest="pours",
+        action="callback",
+        callback=checkPoursuite,
+        help=tr("nom du fichier poursuite"),
+    )
+
+    parser.add_option(
+        "-i",
+        "--include",
+        action="callback",
+        callback=checkInclude,
+        nargs=2,
+        help=tr("numero d'unite suivi du nom du fichier include"),
+    )
+
+    # parser.add_option(u"-f","--fich", type="string",dest="fich",
     #              action="callback", callback=checkFich,
     #              help=tr("fichier decrivant une etude"))
 
-    parser.add_option(u"-c","--cata", action="store", type="string",dest="fichierCata",
-                  help=tr("catalogue a utiliser"))
-
-    parser.add_option(u"-o","--fichierXMLOut", action="store", type="string",dest="fichierXMLOut",
-                  help=tr("nom du fichier xml genere"))
-
-    parser.add_option(u"-v","--label", action="store", type="string",dest="labelCode",
-                  help=tr("version de catalogue a utiliser"))
-
-
-    parser.add_option(u"-k","--kode", action="store", type="string",dest="code",
-                  help=tr("nom du code a utiliser"))
-
-    parser.add_option(u"-d","--debug", action="store", type="int",dest="debug",
-                  help=tr("niveau de debug"))
-
-    parser.add_option(u"-x","--withXSD", action="store_true", dest="withXSD",
-                  default=False,
-                  help=tr("construit le .xml en meme temps que le .comm"))
-
-    parser.add_option(u"-a","--withEltAbstrait", action="store_true", dest="avecEltAbstrait",
-                  default=False,
-                  help=tr("construit des elements abstraits dans le XSD pour gerer le cascading"))
-
-    parser.add_option(u"-s","--schema", action="store", type="string",dest="ssCode",
-                  help=tr("schema"))
+    parser.add_option(
+        "-c",
+        "--cata",
+        action="store",
+        type="string",
+        dest="fichierCata",
+        help=tr("catalogue a utiliser"),
+    )
+
+    parser.add_option(
+        "-o",
+        "--fichierXMLOut",
+        action="store",
+        type="string",
+        dest="fichierXMLOut",
+        help=tr("nom du fichier xml genere"),
+    )
+
+    parser.add_option(
+        "-v",
+        "--label",
+        action="store",
+        type="string",
+        dest="labelCode",
+        help=tr("version de catalogue a utiliser"),
+    )
+
+    parser.add_option(
+        "-k",
+        "--kode",
+        action="store",
+        type="string",
+        dest="code",
+        help=tr("nom du code a utiliser"),
+    )
+
+    parser.add_option(
+        "-d",
+        "--debug",
+        action="store",
+        type="int",
+        dest="debug",
+        help=tr("niveau de debug"),
+    )
+
+    parser.add_option(
+        "-x",
+        "--withXSD",
+        action="store_true",
+        dest="withXSD",
+        default=False,
+        help=tr("construit le .xml en meme temps que le .comm"),
+    )
+
+    parser.add_option(
+        "-a",
+        "--withEltAbstrait",
+        action="store_true",
+        dest="avecEltAbstrait",
+        default=False,
+        help=tr("construit des elements abstraits dans le XSD pour gerer le cascading"),
+    )
+
+    parser.add_option(
+        "-s",
+        "--schema",
+        action="store",
+        type="string",
+        dest="ssCode",
+        help=tr("schema"),
+    )
     # To handle locale information
-    #parser.add_option("-l", "--locale", action="store", type="string", dest="locale",
+    # parser.add_option("-l", "--locale", action="store", type="string", dest="locale",
     #              help=tr("localisation de l'application, pour la traduction"))
 
-
     return parser
 
+
 def parse(args):
-    parser=createparser()
-    (options,args)=parser.parse_args(args[1:])
-    if not hasattr(options,"studies"):
-        options.studies=[]
-        options.comm=[]
-    if not hasattr(options,"fichierCata"): options.fichierCata=None
-    if not hasattr(options,"labelCode"): options.labelCode=None
-    if not hasattr(options,"fichierXMLOut"): options.fichierXMLOut=None
-    if options.withXSD :
-        try : import pyxb
-        except : print ('Please, source pyxb environment'); exit()
+    parser = createparser()
+    (options, args) = parser.parse_args(args[1:])
+    if not hasattr(options, "studies"):
+        options.studies = []
+        options.comm = []
+    if not hasattr(options, "fichierCata"):
+        options.fichierCata = None
+    if not hasattr(options, "labelCode"):
+        options.labelCode = None
+    if not hasattr(options, "fichierXMLOut"):
+        options.fichierXMLOut = None
+    if options.withXSD:
+        try:
+            import pyxb
+        except:
+            print("Please, source pyxb environment")
+            exit()
     try:
         del parser.values.current
     except:
@@ -313,17 +421,22 @@ def parse(args):
     for file in args:
         if os.path.isfile(file):
             options.comm.append(file)
-            options.studies.append({"comm":file})
-            #print options.studies
-        elif len(args)==1 and (re.search('.comm',file) or re.search('.map',file) or re.search('.cas',file) or re.search('.xml',file)):
-            try :
-                f=open(file,'w')
+            options.studies.append({"comm": file})
+            # print options.studies
+        elif len(args) == 1 and (
+            re.search(".comm", file)
+            or re.search(".map", file)
+            or re.search(".cas", file)
+            or re.search(".xml", file)
+        ):
+            try:
+                f = open(file, "w")
                 f.close()
-            except :
+            except:
                 parser.error(tr("Nombre incorrect d'arguments"))
             options.comm.append(file)
-            options.studies.append({"comm":file})
-        elif len(args) == 2 :
+            options.studies.append({"comm": file})
+        elif len(args) == 2:
             if options.locale:
                 print((tr("Localisation specifiee pour l'application.")))
             else:
@@ -332,38 +445,41 @@ def parse(args):
             parser.error(tr("Nombre incorrect d'arguments"))
 
     global d_env
-    d_env=options
-    #printDEnv()
-    #print (options)
+    d_env = options
+    # printDEnv()
+    # print (options)
     return options
 
-def getUnit(d_study,appliEficas):
+
+def getUnit(d_study, appliEficas):
     """
-       Fonction : construit et retourne un dictionnaire contenant les informations
-       sur les fichiers poursuite et includes sous la forme adaptee
-       pour EFICAS ::
+    Fonction : construit et retourne un dictionnaire contenant les informations
+    sur les fichiers poursuite et includes sous la forme adaptee
+    pour EFICAS ::
 
-                  [None : nom_fichier, texte_source, unites_associees,           # poursuite
-                   numero_include : nom_fichier, texte_source, unites_associees, # include
-                    ...]
+               [None : nom_fichier, texte_source, unites_associees,           # poursuite
+                numero_include : nom_fichier, texte_source, unites_associees, # include
+                 ...]
 
-       d_study : dictionnaire de l'etude
-       appliEficas : objet application EFICAS (permet d'acceder aux services comme getSource)
+    d_study : dictionnaire de l'etude
+    appliEficas : objet application EFICAS (permet d'acceder aux services comme getSource)
     """
-    return getDunit(d_study,appliEficas)
+    return getDunit(d_study, appliEficas)
+
 
-def getDunit(d_unit,appliEficas):
-    d={}
-    if 'pours' in d_unit:
+def getDunit(d_unit, appliEficas):
+    d = {}
+    if "pours" in d_unit:
         # on a une poursuite
-        comm=d_unit["pours"]["comm"]
-        g=getDunit(d_unit["pours"],appliEficas)
-        text=appliEficas.getSource(comm)
-        d[None]=comm,text,g
-
-    for k,v in list(d_unit.items()):
-        if k in (u"pours","comm"): continue
-        text=appliEficas.getSource(v)
-        d[k]=v,text,d
+        comm = d_unit["pours"]["comm"]
+        g = getDunit(d_unit["pours"], appliEficas)
+        text = appliEficas.getSource(comm)
+        d[None] = comm, text, g
+
+    for k, v in list(d_unit.items()):
+        if k in ("pours", "comm"):
+            continue
+        text = appliEficas.getSource(v)
+        d[k] = v, text, d
 
     return d
diff --git a/Editeur/uiinfo.py b/Editeur/uiinfo.py
index 5ffe1af9..a541b256 100644
--- a/Editeur/uiinfo.py
+++ b/Editeur/uiinfo.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021   EDF R&D
+# Copyright (C) 2007-2024   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -21,90 +21,97 @@
    Ce module sert a construire les structures de donnees porteuses
    des informations liees aux groupes de commandes
 """
-from __future__ import absolute_import
 import types
 
+
 class UIINFO:
     """
-        Pour le moment la classe UIINFO ne sait traiter que des infos
-        portant sur la definition des groupes de commandes
-        Les autres informations sont ignorees
+    Pour le moment la classe UIINFO ne sait traiter que des infos
+    portant sur la definition des groupes de commandes
+    Les autres informations sont ignorees
     """
-    def __init__(self,parent,groupes=None,**args):
+
+    def __init__(self, parent, groupes=None, **args):
         """
-           Initialiseur de la classe UIINFO.
-           Initialise a partir du dictionnaire UIinfo passe a
-           un objet ENTITE les attributs de la classe
+        Initialiseur de la classe UIINFO.
+        Initialise a partir du dictionnaire UIinfo passe a
+        un objet ENTITE les attributs de la classe
         """
         # L'attribut parent stocke le lien vers l'objet ENTITE relie a UIINFO
-        self.parent=parent
-        self.groupes=groupes
+        self.parent = parent
+        self.groupes = groupes
         if groupes == None:
             # L'entite n'a pas de groupe associe. On lui associe le groupe "DEFAUT"
-            self.groupes=("DEFAUT",)
+            self.groupes = ("DEFAUT",)
         if type(self.groupes) != tuple:
-            self.groupes=(self.groupes,)
+            self.groupes = (self.groupes,)
+
 
-def traiteCommande(commande,niveau):
+def traiteCommande(commande, niveau):
     """
-        Cette fonction cree l'attribut UI de l'objet commande
-        a partir des informations contenues dans UIinfo
+    Cette fonction cree l'attribut UI de l'objet commande
+    a partir des informations contenues dans UIinfo
     """
-    uiinfo=commande.UIinfo or {}
-    UI=UIINFO(commande,**uiinfo)
-    commande.UI=UI
-    #if "CACHE" in UI.groupes:
-        # La commande est cachee aux utilisateurs
-        #niveau.dict_groupes["CACHE"].append(commande.nom)
-        #pass
-    #else:
-        # On ajoute la commande dans tous les groupes specifies
+    uiinfo = commande.UIinfo or {}
+    UI = UIINFO(commande, **uiinfo)
+    commande.UI = UI
+    # if "CACHE" in UI.groupes:
+    # La commande est cachee aux utilisateurs
+    # niveau.dict_groupes["CACHE"].append(commande.nom)
+    # pass
+    # else:
+    # On ajoute la commande dans tous les groupes specifies
     for grp in UI.groupes:
-        if not grp in niveau.dict_groupes: niveau.dict_groupes[grp]=[]
+        if not grp in niveau.dict_groupes:
+            niveau.dict_groupes[grp] = []
         niveau.dict_groupes[grp].append(commande.nom)
 
+
 def traiteNiveau(niveau):
-    if niveau.l_niveaux == ():
+    if niveau.lNiveaux == ():
         # Il n'y a pas de sous niveaux. niveau.entites ne contient que des commandes
-        niveau.dict_groupes={}
+        niveau.dict_groupes = {}
         for oper in niveau.entites:
-            traiteCommande(oper,niveau)
+            traiteCommande(oper, niveau)
         # A la fin les cles du dictionnaire dict_groupes donnent la liste des groupes
         # sans doublon
-        niveau.liste_groupes=list(niveau.dict_groupes.keys())
+        niveau.liste_groupes = list(niveau.dict_groupes.keys())
         # On ordonne les listes alphabetiquement
         niveau.liste_groupes.sort()
-        for v in niveau.dict_groupes.values():v.sort()
-        #print niveau.liste_groupes
-        #print niveau.dict_groupes
+        for v in niveau.dict_groupes.values():
+            v.sort()
+        # print niveau.liste_groupes
+        # print niveau.dict_groupes
     else:
-        for niv in niveau.l_niveaux:
+        for niv in niveau.lNiveaux:
             traiteNiveau(niv)
 
+
 def traite_UIinfo(cata):
     """
-       Cette fonction parcourt la liste des commandes d'un catalogue (cata)
-       construit les objets UIINFO a partir de l'attribut UIinfo de la commande
-       et construit la liste complete de tous les groupes presents
+    Cette fonction parcourt la liste des commandes d'un catalogue (cata)
+    construit les objets UIINFO a partir de l'attribut UIinfo de la commande
+    et construit la liste complete de tous les groupes presents
     """
-    #dict_groupes["CACHE"]=[]
-    #XXX Ne doit pas marcher avec les niveaux
-    if cata.JdC.l_niveaux == ():
+    # dict_groupes["CACHE"]=[]
+    # XXX Ne doit pas marcher avec les niveaux
+    if cata.JdC.lNiveaux == ():
         # Il n'y a pas de niveaux
         # On stocke la liste des groupes et leur contenu dans le JdC
         # dans les attributs liste_groupes et dict_groupes
-        cata.JdC.dict_groupes={}
+        cata.JdC.dict_groupes = {}
         for commande in cata.JdC.commandes:
-            traiteCommande(commande,cata.JdC)
+            traiteCommande(commande, cata.JdC)
         # A la fin les cles du dictionnaire dict_groupes donnent la liste des groupes
         # sans doublon
-        cata.JdC.liste_groupes=list(cata.JdC.dict_groupes.keys())
+        cata.JdC.liste_groupes = list(cata.JdC.dict_groupes.keys())
         # On ordonne les listes alphabetiquement
         cata.JdC.liste_groupes.sort()
-        for v in cata.JdC.dict_groupes.values():v.sort()
-        #print cata.JdC.liste_groupes
-        #print cata.JdC.dict_groupes
+        for v in cata.JdC.dict_groupes.values():
+            v.sort()
+        # print cata.JdC.liste_groupes
+        # print cata.JdC.dict_groupes
     else:
         # Le catalogue de commandes contient des definitions de niveau
-        for niv in cata.JdC.l_niveaux:
+        for niv in cata.JdC.lNiveaux:
             traiteNiveau(niv)