# -*- 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
#
"""
"""
-# 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
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.
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.
# 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."""
expandable = None
def _isExpandable(self):
- """Do not override! Called by TreeNode."""
if self.expandable is None:
self.expandable = self.isExpandable()
return self.expandable
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):
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
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
# 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):
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):
"""
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):
"""
"""
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
"""
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):
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):
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):
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):
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"
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
# -*- 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
# -*- 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
#
# 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:
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')")
# -*- 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
#
# 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)
# -*- 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
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)
# -*- 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
#
# 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.
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
# -*- 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
- 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
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)
-# 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
#
# 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
# -*- 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
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.
# 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]))
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:
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:
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
# -*- 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
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)
