from Extensions.i18n import tr
def substractList(liste1,liste2):
- """
- Enleve tous les elements de liste2 presents dans liste1 et retourne liste1
- """
- for item in liste2:
- try:
- liste1.remove(item)
- except:
- pass
- return liste1
+ """
+ Enleve tous les elements de liste2 presents dans liste1 et retourne liste1
+ """
+ for item in liste2:
+ try:
+ liste1.remove(item)
+ except:
+ pass
+ return liste1
def getRepUser(dir):
- """
- Determine sur quelle plate-forme s'execute Eficas et recherche
- le repertoire de l'utilisateur /$home/Eficas_install
- """
+ """
+ Determine sur quelle plate-forme s'execute Eficas et recherche
+ le repertoire de l'utilisateur /$home/Eficas_install
+ """
- #rep_user_eficas= os.path.join(os.environ['HOME'],dir)
- rep_user_eficas= os.path.join(os.path.expanduser("~"),dir)
- if os.path.exists(rep_user_eficas):
- if os.path.isfile(rep_user_eficas) :
- print (tr("Un fichier de nom %s existe deja : impossible de creer un repertoire de meme nom", rep_user_eficas))
- rep_user_eficas=None
- else :
- try:
- os.mkdir(rep_user_eficas)
- except:
- print (tr("Creation du repertoire %s impossible\n Verifiez vos droits d'acces", rep_user_eficas))
- return rep_user_eficas
+ #rep_user_eficas= os.path.join(os.environ['HOME'],dir)
+ rep_user_eficas= os.path.join(os.path.expanduser("~"),dir)
+ if os.path.exists(rep_user_eficas):
+ if os.path.isfile(rep_user_eficas) :
+ print (tr("Un fichier de nom %s existe deja : impossible de creer un repertoire de meme nom", rep_user_eficas))
+ rep_user_eficas=None
+ else :
+ try:
+ os.mkdir(rep_user_eficas)
+ except:
+ print (tr("Creation du repertoire %s impossible\n Verifiez vos droits d'acces", rep_user_eficas))
+ return rep_user_eficas
def read_file(file):
- """
- ouvre le fichier file et retourne son contenu
- si pbe retourne None
- """
- try :
- with open(file) as fd :
- text=fd.read()
- return text
- except:
- return None
+ """
+ ouvre le fichier file et retourne son contenu
+ si pbe retourne None
+ """
+ try :
+ with open(file) as fd :
+ text=fd.read()
+ return text
+ except:
+ return None
def save_in_file(file,text,dir=None):
- """
- cree le fichier file (ou l'ecrase s'il existe) et ecrit text dedans
- retourne 1 si OK 0 sinon
- """
- try :
- if dir != None:
- os.chdir(dir)
- with open(file) as fd :
- fd.write(text)
- return 1
- except:
- return 0
+ """
+ cree le fichier file (ou l'ecrase s'il existe) et ecrit text dedans
+ retourne 1 si OK 0 sinon
+ """
+ try :
+ if dir != None:
+ os.chdir(dir)
+ with open(file) as fd :
+ fd.write(text)
+ return 1
+ except:
+ return 0
def extension_fichier(pathAndFile):
""" Return ext if path/filename.ext is given """
return os.path.split(pathAndFile)[1]
def initRep_CataDev(fic_cata,rep_goal):
- """
- Initialise le repertoire des catalogues developpeurs (chemin d'acces donne
- dans le fichier eficas.ini cad :
- - le cree s'il n'existe pas encore
- - copie dedans les 3 fichiers necessaires :
- * __init__.py (pour que ce repertoire puisse etre interprete comme un package)
- * entete.py (pour realiser les import necessaires a l'interpretation des catalogues)
- * declaration_concepts.py (idem)
- - cree le fichier cata_developpeur.py qui sera par la suite importe
- """
- try :
- if not os.path.isdir(rep_goal) :
- os.mkdir(rep_goal)
- #texte_entete = getEnteteCata(fic_cata)
- texte_entete=""
- # rep_goal doit contenir les catalogues du developpeur sous la forme *.capy
- # il faut creer le catalogue developpeur par concatenation de entete,declaration_concepts
- # et de tous ces fichiers
- cur_dir = os.getcwd()
- os.chdir(rep_goal)
- l_cata_dev = glob.glob('*.capy')
- if os.path.isfile('cata_developpeur.py') : os.remove('cata_developpeur.py')
- if len(l_cata_dev) :
- # des catalogues developpeurs sont effectivement presents : on cree cata_dev.py dans rep_goal
- str = ''
- str = str + texte_entete+'\n'
- for file in l_cata_dev :
- str = str + open(file,'r').read() +'\n'
- open('cata_developpeur.py','w+').write(str)
- os.chdir(cur_dir)
- except:
- traceback.print_exc()
- print ( tr("Impossible de transferer les fichiers requis dans : %s", str(rep_goal)))
+ """
+ Initialise le repertoire des catalogues developpeurs (chemin d'acces donne
+ dans le fichier eficas.ini cad :
+ - le cree s'il n'existe pas encore
+ - copie dedans les 3 fichiers necessaires :
+ * __init__.py (pour que ce repertoire puisse etre interprete comme un package)
+ * entete.py (pour realiser les import necessaires a l'interpretation des catalogues)
+ * declaration_concepts.py (idem)
+ - cree le fichier cata_developpeur.py qui sera par la suite importe
+ """
+ try :
+ if not os.path.isdir(rep_goal) :
+ os.mkdir(rep_goal)
+ #texte_entete = getEnteteCata(fic_cata)
+ texte_entete=""
+ # rep_goal doit contenir les catalogues du developpeur sous la forme *.capy
+ # il faut creer le catalogue developpeur par concatenation de entete,declaration_concepts
+ # et de tous ces fichiers
+ cur_dir = os.getcwd()
+ os.chdir(rep_goal)
+ l_cata_dev = glob.glob('*.capy')
+ if os.path.isfile('cata_developpeur.py') : os.remove('cata_developpeur.py')
+ if len(l_cata_dev) :
+ # des catalogues developpeurs sont effectivement presents : on cree cata_dev.py dans rep_goal
+ str = ''
+ str = str + texte_entete+'\n'
+ for file in l_cata_dev :
+ str = str + open(file,'r').read() +'\n'
+ open('cata_developpeur.py','w+').write(str)
+ os.chdir(cur_dir)
+ except:
+ traceback.print_exc()
+ print ( tr("Impossible de transferer les fichiers requis dans : %s", str(rep_goal)))
def getEnteteCata(fic_cata):
- """ Retrouve l'entete du catalogue """
- l_lignes = open(fic_cata,'r').readlines()
- txt = ''
- flag = 0
- for ligne in l_lignes :
- if re.match(u"# debut entete",ligne) : flag = 1
- if re.match(u"# fin entete",ligne) : break
- if not flag : continue
- txt = txt + ligne
- return txt
-
+ """ Retrouve l'entete du catalogue """
+ l_lignes = open(fic_cata,'r').readlines()
+ txt = ''
+ flag = 0
+ for ligne in l_lignes :
+ if re.match(u"# debut entete",ligne) : flag = 1
+ if re.match(u"# fin entete",ligne) : break
+ if not flag : continue
+ txt = txt + ligne
+ return txt
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
- from builtins import object
+ from builtins import str
+ from builtins import object
except :
- pass
+ pass
import types,os,glob,imp,sys
from copy import copy,deepcopy
from Extensions.eficas_exception import EficasException
try :
- from repr import Repr
+ from repr import Repr
except :
- from reprlib import Repr
+ from reprlib import Repr
myrepr = Repr()
myrepr.maxstring = 100
myrepr.maxother = 100
return self._object
def connect(self,channel,callable,args):
- """ Connecte la fonction callable (avec arguments args) a l'item self sur le
+ """ Connecte la fonction callable (avec arguments args) a l'item self sur le
canal channel
"""
#print self,channel,callable,args
fonction = deepcopy(self.setFunction)
item = makeObjecttreeitem(appliEficas,labeltext,object,fonction)
return item
-
+
def isActif(self):
if hasattr(self.object,'actif'):
return self.object.actif
else:
return 1
-
+
def update(self,item):
"""
Met a jour l'item courant a partir d'un autre item passe en argument
return tr(self.labeltext),None,None
def getNature(self) :
- """
+ """
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 """
return self.object.getRegles()
-
+
def getListeMcPresents(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) """
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
d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
"""
return self.object.getListeMcOrdonneeBrute(liste,dico)
-
+
def getGenealogie(self):
"""
Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC ou ETAPE)
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):
"""
Permet d'ajouter un item fils a self
elif pos == 'last':
index = len(self.listeMcPresents())
elif type(pos) == int :
- # la position est fixee
+ # la position est fixee
index = pos
#elif type(pos) == types.InstanceType:
elif type(pos) == object :
def getCopieObjet(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 """
definition = self.get_definition()
return getattr(definition,'position')
except AttributeError:
return 'local'
-
+
def getNom(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 """
return self.object.jdc
-
+
def getValeur(self):
""" Retourne la valeur de l'objet pointe par self """
return self.object.valeur
raise EficasException("MESSAGE AU DEVELOPPEUR : il faut \
surcharger la methode getObjetCommentarise() \
pour la classe %s", self.__class__.__name__)
-
+
def isValid(self):
""" Retourne 1 si l'objet pointe par self est valide, 0 sinon"""
return self.object.isValid()
Par defaut retourne 0
"""
return 0
-
+
def getMcPresents(self):
""" Retourne le dictionnaire des mots-cles presents de l'objet pointe par self """
return self.object.dictMcPresents()
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):
return myrepr.repr(self.object)
-
+
def getIconName(self):
if not self.isExpandable():
return "python"
def isExpandable(self):
return 1
-
+
def getSubList(self):
keys = dir(self.object)
sublist = []
def __len__(self) :
return len(self._object)
-
+
def keys(self):
return list(range(len(self._object)))
def getIconName(self):
if self._object.isValid():
- return "ast-green-los"
+ return "ast-green-los"
elif self._object.isOblig():
- return "ast-red-los"
+ return "ast-red-los"
else:
- return "ast-yel-los"
+ return "ast-yel-los"
def ajoutPossible(self):
return self._object.ajoutPossible()
return self._object.getIndex(child.getObject())
def getText(self):
- return " "
+ return " "
def addItem(self,obj,pos):
self._object.insert(pos,obj)
self.sublist=[]
while(1):
- old_obj=obj=None
- for item in isublist:
- old_obj=item.getObject()
- if old_obj in liste:break
-
- for obj in iliste:
- 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)
- self.sublist.append(it)
- if old_obj is None and obj is None:break
- if old_obj is obj: self.sublist.append(item)
+ old_obj=obj=None
+ for item in isublist:
+ old_obj=item.getObject()
+ if old_obj in liste:break
+
+ for obj in iliste:
+ 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)
+ self.sublist.append(it)
+ if old_obj is None and obj is None:break
+ if old_obj is obj: self.sublist.append(item)
return self.sublist
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient la classe 3Dpilote qui va creer les ordres
+ Ce module contient la classe 3Dpilote qui va creer les ordres
de pilotage de l idl PAL pour un element de structure
"""
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import object
+ from builtins import object
except :
- pass
+ pass
import generator
from Extensions.i18n import tr
class TroisDPilote(object):
- def __init__(self,node,appliEficas):
- self.node=node
- self.appliEficas=appliEficas
+ def __init__(self,node,appliEficas):
+ self.node=node
+ self.appliEficas=appliEficas
- def envoievisu(self):
- """
- """
- format="vers3DSalome"
- if format in generator.plugins :
- # Le generateur existe on l'utilise
- g=generator.plugins[format]()
- g.initJdc(self.node.getJdc())
- texte=g.gener(self.node)
- else:
- print ("Le generateur n'a pas ete trouve")
- print ("Erreur ! Erreur!")
- return ""
- from Extensions.param2 import originalMath
- originalMath.toOriginal()
- self.appliEficas.envoievisu(texte)
- originalMath.toSurcharge()
-
+ def envoievisu(self):
+ """
+ """
+ format="vers3DSalome"
+ if format in generator.plugins :
+ # Le generateur existe on l'utilise
+ g=generator.plugins[format]()
+ g.initJdc(self.node.getJdc())
+ texte=g.gener(self.node)
+ else:
+ print ("Le generateur n'a pas ete trouve")
+ print ("Erreur ! Erreur!")
+ return ""
+ from Extensions.param2 import originalMath
+ originalMath.toOriginal()
+ self.appliEficas.envoievisu(texte)
+ originalMath.toSurcharge()
#
from __future__ import absolute_import
from __future__ import print_function
-try :
- from builtins import str
- from builtins import object
+try :
+ from builtins import str
+ from builtins import object
except :
- pass
+ pass
import re,six.moves.cPickle,os
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(u'',text)
def chercheNom(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)
+ 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 !'
+ text = text.strip()
+ longueur = len(text)
+ if text[0] != '(u':
+ return 'erreur !'
+ else :
+ nbpar = 1
+ for i in range(1,longueur) :
+ if text[i] =='(u':
+ nbpar = nbpar + 1
+ elif text[i] == ')':
+ nbpar = nbpar - 1
+ else :
+ continue
+ if nbpar == 0:
+ break
+ if nbpar != 0 :
+ return tr('Erreur ! Erreur !')
else :
- nbpar = 1
- for i in range(1,longueur) :
- if text[i] =='(u':
- nbpar = nbpar + 1
- elif text[i] == ')':
- nbpar = nbpar - 1
- 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],''
+ 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 :
- self.text = self.text.strip()
- liste = re.split(u'=',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 :
- self.text = reste
- self.chercheEnfants()
- 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)
- self.children.append(mc)
- elif test in l_noms_simples :
- mc = SIMP_CATA(nom_mc,self)
- self.children.append(mc)
+ def chercheEnfants(self):
+ try :
+ self.text = self.text.strip()
+ liste = re.split(u'=',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 :
- print (tr("Erreur dans la creation du mot-cle : %s", nom_mc) )
-
- def construitListeDico(self):
- l=[]
- d={}
- if len(self.children)==0:
- self.ordre_mc = l
- self.entites = d
- return
- try :
- for child in self.children:
- l.append(child.nom)
- d[child.nom]=child
- self.ordre_mc = l
- self.entites = d
- except:
- print (("erreur : ", self.nom, self.__class__))
-
-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.text = reste
self.chercheEnfants()
- self.construitListeDico()
- parent.cr.add(self.cr)
+ 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)
+ self.children.append(mc)
+ elif test in l_noms_simples :
+ mc = SIMP_CATA(nom_mc,self)
+ self.children.append(mc)
+ else :
+ print (tr("Erreur dans la creation du mot-cle : %s", nom_mc) )
+
+ def construitListeDico(self):
+ l=[]
+ d={}
+ if len(self.children)==0:
+ self.ordre_mc = l
+ self.entites = d
+ return
+ try :
+ for child in self.children:
+ l.append(child.nom)
+ d[child.nom]=child
+ self.ordre_mc = l
+ self.entites = d
+ except:
+ print (("erreur : ", self.nom, self.__class__))
- 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 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.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):
- 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
- parent.cr.add(self.cr)
+ 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
+ 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
- self.children = []
- 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.chercheEnfants()
- self.construitListeDico()
- parent.cr.add(self.cr)
+ def __init__(self,nom,args,parent):
+ self.nom=nom
+ self.args=args
+ self.children = []
+ 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.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)
+ return text
- 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):
- self.parent = parent
- 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.ouvrirFichier()
- self.liste_commandes=[]
- self.liste_textes_commandes=[]
-
- def ouvrirFichier(self):
- try :
- with open(self.fichier) as fd:
- 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):
- 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}))
- 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))
- print((tr(fin)))
- cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
- self.liste_commandes.append(cmd)
-
- def analyseTexte(self,texte):
- self.constrListTxtCmd(texte)
- try:
- self.parent.configure_barre(len(self.liste_textes_commandes))
- except:
- pass
- for texte_commande in self.liste_textes_commandes :
- try:
- self.parent.update_barre()
- except:
- pass
- self.analyseCommande(texte_commande)
- self.construitListeDico()
-
- def ecritLcmd(self):
- f=open(u'U:\\EFICAS\\Accas\\cata.txt','w')
- for cmd in self.liste_commandes :
- f.write(cmd.affiche())
- f.close()
+ def __init__(self,parent,fichier):
+ self.parent = parent
+ 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.ouvrirFichier()
+ self.liste_commandes=[]
+ self.liste_textes_commandes=[]
+
+ def ouvrirFichier(self):
+ try :
+ with open(self.fichier) as fd:
+ 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):
+ 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}))
+ 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))
+ print((tr(fin)))
+ cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
+ self.liste_commandes.append(cmd)
+
+ def analyseTexte(self,texte):
+ self.constrListTxtCmd(texte)
+ try:
+ self.parent.configure_barre(len(self.liste_textes_commandes))
+ except:
+ pass
+ for texte_commande in self.liste_textes_commandes :
+ try:
+ self.parent.update_barre()
+ except:
+ pass
+ self.analyseCommande(texte_commande)
+ self.construitListeDico()
+
+ def ecritLcmd(self):
+ f=open(u'U:\\EFICAS\\Accas\\cata.txt','w')
+ for cmd in self.liste_commandes :
+ f.write(cmd.affiche())
+ f.close()
- def construitListeDico(self):
- l=[]
- d={}
- for cmd in self.liste_commandes:
- l.append(cmd.nom)
- d[cmd.nom]=cmd
- self.ordre_mc = l
- self.entites = d
+ def construitListeDico(self):
+ l=[]
+ d={}
+ for cmd in self.liste_commandes:
+ l.append(cmd.nom)
+ d[cmd.nom]=cmd
+ self.ordre_mc = l
+ self.entites = d
- def report(self):
- """ retourne l'objet rapport du catalogue de commande """
- return self.cr
+ def report(self):
+ """ retourne l'objet rapport du catalogue de commande """
+ return self.cr
def analyseCatalogue(parent,nom_cata):
- cata = CATALOGUE_CATA(parent,nom_cata)
- cata.analyseTexte(cata.texte_complet)
- return 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)
- cata.analyseCommande(cata.texte_complet)
- cata.construitListeDico()
- return 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__" :
- import profile
- profile.run(u"analyseCatalogue(None,'U:\\EFICAS\\Cata\\cata_saturne.py')")
-
-
-
-
-
+ """
+ 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__" :
+ import profile
+ profile.run(u"analyseCatalogue(None,'U:\\EFICAS\\Cata\\cata_saturne.py')")
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
- from builtins import object
+ from builtins import str
+ from builtins import object
except :
- pass
+ pass
import re,os
from Extensions.i18n import tr
__version__="$Name: V7_main $"
#
-
-class Catalogue_initial(object):
- def __init__(self,fichier):
- self.liste_commandes=[]
- self.lignes=[]
- self.fichier=fichier
- self.ouvrirFichier()
- self.constrListTxtCmd()
-
- def ouvrirFichier(self):
- try :
- with open(self.fichier) as fd:
- 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)
+class Catalogue_initial(object):
+ def __init__(self,fichier):
+ self.liste_commandes=[]
+ self.lignes=[]
+ self.fichier=fichier
+ self.ouvrirFichier()
+ self.constrListTxtCmd()
+
+ def ouvrirFichier(self):
+ try :
+ with open(self.fichier) as fd:
+ 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)
def analyseCatalogue(nom_cata):
- cata = Catalogue_initial(nom_cata)
- return cata.liste_commandes
+ cata = Catalogue_initial(nom_cata)
+ return cata.liste_commandes
if __name__ == "__main__" :
- monCata="/local/noyret/Install_Eficas/EficasQT4/Openturns_StudyOpenTURNS_Cata_Study_V4.py"
- analyseCatalogue(monCata)
-
-
-
-
-
-
-
-
-
-
-
-
-
+ monCata="/local/noyret/Install_Eficas/EficasQT4/Openturns_StudyOpenTURNS_Cata_Study_V4.py"
+ analyseCatalogue(monCata)
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
+ sys.path[:0]=[".."]
+ sys.path[:0]=["../Aster"]
+ sys.path[:0]=["../Saturne"]
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.
- """
- entite.ordre_mc=[]
+ """
+ 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.
+ """
+ entite.ordre_mc=[]
def traiteEntite(entite,liste_simp_reel):
- """
- 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
- """
- 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)
- traiteCache(v)
- l.append((v._no,k))
- l.sort()
- entite.ordre_mc=[ item for index, item in l ]
+ """
+ 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
+ """
+ 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)
+ traiteCache(v)
+ l.append((v._no,k))
+ l.sort()
+ entite.ordre_mc=[ item for index, item in l ]
def traiteCache(objet):
if not hasattr(objet, "cache"): return
clef=objet.nom
if objet.equiv != None : clef=objet.equiv
if hasattr(objet.pere,"mcOblig"):
- objet.pere.mcOblig[clef]=objet.defaut
+ objet.pere.mcOblig[clef]=objet.defaut
else :
- objet.pere.mcOblig={}
- objet.pere.mcOblig[clef]=objet.defaut
+ objet.pere.mcOblig={}
+ objet.pere.mcOblig[clef]=objet.defaut
def traiteReel(objet,liste_simp_reel):
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 liste_simp_reel :
+ liste_simp_reel.append(objet.nom)
def analyseNiveau(cata_ordonne_dico,niveau,liste_simp_reel):
- """
- Analyse un niveau dans un catalogue de commandes
- """
- if niveau.l_niveaux == ():
- # Il n'y a pas de sous niveaux
- for oper in niveau.entites:
- traiteEntite(oper,liste_simp_reel)
- cata_ordonne_dico[oper.nom]=oper
- else:
- for niv in niveau.l_niveaux:
- analyseNiveau(cata_ordonne_dico,niv)
-
+ """
+ Analyse un niveau dans un catalogue de commandes
+ """
+ if niveau.l_niveaux == ():
+ # Il n'y a pas de sous niveaux
+ for oper in niveau.entites:
+ traiteEntite(oper,liste_simp_reel)
+ cata_ordonne_dico[oper.nom]=oper
+ else:
+ for niv in niveau.l_niveaux:
+ 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
- """
- cata_ordonne_dico={}
- liste_simp_reel=[]
- if cata.JdC.l_niveaux == ():
- # Il n'y a pas de niveaux
- for oper in cata.JdC.commandes:
- traiteEntite(oper,liste_simp_reel)
- 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
+ """
+ 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
+ """
+ cata_ordonne_dico={}
+ liste_simp_reel=[]
+ if cata.JdC.l_niveaux == ():
+ # Il n'y a pas de niveaux
+ for oper in cata.JdC.commandes:
+ traiteEntite(oper,liste_simp_reel)
+ 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
if __name__ == "__main__" :
- from Cata import cata_STA6
- dico=analyseCatalogue(cata_STA6)
- #import cata_saturne
- #dico=analyseCatalogue(cata_saturne)
+ from Cata import cata_STA6
+ dico=analyseCatalogue(cata_STA6)
+ #import cata_saturne
+ #dico=analyseCatalogue(cata_saturne)
- 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.ordre_mc:
+ 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)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
try :
- from builtins import object
+ from builtins import object
except : pass
class STYLE(object):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
try :
- from builtins import object
+ from builtins import object
except : pass
class CatalogDescription(object):
-
+
def __init__(self, labelCode, fichierCata, formatFichierOut = "python", formatFichierIn='python',
default = False, code = None,ss_code=None,):
"""
:type labelCode: string
:param labelCode: unique labelCode for the catalog
-
+
:type fichierCata: string
:param fichierCata: path of the file containing the catalog itself
-
+
:type fileFormatOut: string
:param fileFormatOut: format of the files generated when using this catalog
-
+
:type default: boolean
:param default: indicate if this catalog is the default one (appear on the top of the catalogs list)
-
+
:type code: string
:param code: Used to indicate the code associated to this catalog
-
+
:type ss_code: string
:param ss_code: scheme associated to this catalog (Map only)
-
+
"""
self.labelCode = labelCode
self.fichierCata = fichierCata
self.formatFichierOut = formatFichierOut
- self.formatFichierIn = formatFichierIn
+ self.formatFichierIn = formatFichierIn
self.default = default
self.code = code
#print "Warning: Describing a catalog with a tuple is deprecated. " \
# "Please create a CatalogDescription instance directly."
if cataTuple[0] == 'MAP' :
- desc = CatalogDescription(code = cataTuple[0],
- labelCode = cataTuple[1],
- fichierCata = cataTuple[2],
- ssCode = cataTuple[3],
- formatFichierOut = 'MAP',
- formatFichierIn = '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
import os,glob,types
# Dictionnaire {object : item} permettant d'associer un item a un object
-# Ce dictionnaire est renseigne par la methode chargerComposants
+# Ce dictionnaire est renseigne par la methode chargerComposants
composants = {}
def chargerComposants(Ihm="QT"):
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
+ # Si la definition de l'objet a un attribut itemeditor, il indique
# la classe a utiliser pour l'item
try:
- return object.definition.itemeditor
+ return object.definition.itemeditor
except:
- pass
+ pass
# On cherche ensuite dans les composants (plugins)
try:
- itemtype= composants[object.__class__]
- return itemtype
+ itemtype= composants[object.__class__]
+ return itemtype
except:
- pass
+ 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]
- return itemtype
+ itemtype= composants[e]
+ return itemtype
# Si on n'a rien trouve dans les composants on utilise l'objet par defaut
itemtype=composants[None]
"""
c = gettreeitem(object)
return c(appliEficas,labeltext, object, setFunction)
-
standard12_gras_italique = ( "times",12,'bold','italic')
standardcourier10 = ("Courier",10)
-
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module realise toutes les mises a jour du chemin pour
+ Ce module realise toutes les mises a jour du chemin pour
les imports de modules Python
"""
from __future__ import absolute_import
# representant le code utilise (si fourni)
# Ensuite on utilise les packages de l'intallation
if hasattr(prefs_Code,'CODE_PATH'):
- if prefs_Code.CODE_PATH:
- sys.path[:0]=[prefs_Code.CODE_PATH]
- import Noyau,Validation
- del sys.path[0]
+ if prefs_Code.CODE_PATH:
+ sys.path[:0]=[prefs_Code.CODE_PATH]
+ import Noyau,Validation
+ del sys.path[0]
sys.path[:0]=[prefs_Code.INSTALLDIR]
import Accas
#
from __future__ import absolute_import
try :
- from builtins import object
+ from builtins import object
except : pass
import os
import re
sous_menus={
-# "OPENTURNS_STUDY" : {0:{"Essai":"Std.comm"}},
+# "OPENTURNS_STUDY" : {0:{"Essai":"Std.comm"}},
# "OPENTURNS_WRAPPER" : {0:{"Essai":"wrapper_exemple.comm"}},
}
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()
+ 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
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]
- break
+ if clef in self.liste:
+ self.liste[clef].append(file)
+ else :
+ self.liste[clef]=[file]
+ break
qui demande a l'application d'ouvrir trois jeux de commandes.
-Le premier (aa) a un include (11,iii) et est la suite du fichier poursuite ppp
+Le premier (aa) a un include (11,iii) et est la suite du fichier poursuite ppp
qui a lui meme un include (22,ii).
Le deuxieme bb est un jeu de commandes simple.
qui est parse par le module Configparser.
Chaque section du fichier decrit un jeu de commandes.
Un include est specifie par: numero logique=nom du fichier
-Une poursuite est specifiee par: poursuite=reference a un jeu de commande
+Une poursuite est specifiee par: poursuite=reference a un jeu de commande
Cette reference correspond a un nom de section decrivant le jeu de commandes.
Le jeu de commandes maitre est donne par l'entree globale jdc dans la section jdc.
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
+ from builtins import str
except :
- pass
+ pass
try:
- import optparse
- from optparse import OptionValueError
+ import optparse
+ from optparse import OptionValueError
except:
- from Tools import optparse
- from Tools.optparse import OptionValueError
+ from Tools import optparse
+ from Tools.optparse import OptionValueError
import os,traceback
import six.moves.configparser
#
#
#
-# Les informations (dictionnaire) associees au fichier de commandes en cours de traitement
+# Les informations (dictionnaire) associees au fichier de commandes en cours de traitement
# sont stockees dans parser.values.current
# En general, il faut utiliser current et pas parser.values.studies car les informations
# sont stockees hierarchiquement
def checkComm(option, opt_str, value, parser):
if not hasattr(parser.values,"studies"):
- parser.values.studies=[]
- parser.values.comm=[]
+ parser.values.studies=[]
+ parser.values.comm=[]
if not os.path.isfile(value):
- raise OptionValueError(tr("le fichier de commandes %s n'existe pas", 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
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))
+ 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}
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]))
+ raise OptionValueError(tr("include mal defini %s", parser.rargs[0:2]))
del parser.rargs[0]
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]))
+ raise OptionValueError(tr("le fichier include %s n'existe pas", args[1]))
comm=parser.values.current
comm[args[0]]=args[1]
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")
- 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
- continue
-
- try:
- unit=int(o)
- # si le parametre est un entier, il s'agit d'un include
- inc=config.get(jdc,o)
- except EficasException:
- continue
- if not os.path.isfile(inc):
- 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
+ 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")
+ 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
+ continue
+
+ try:
+ unit=int(o)
+ # si le parametre est un entier, il s'agit d'un include
+ inc=config.get(jdc,o)
+ except EficasException:
+ continue
+ if not os.path.isfile(inc):
+ 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
return d_study
def checkFich(option, opt_str, fich, parser):
"""
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
"""
if not os.path.isfile(fich):
- raise OptionValueError(tr(" le fichier jdc %s n'existe pas", str(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
+ parser.values.studies=[]
+ parser.values.comm=[]
+ # Python 2 to 3
try :
- import ConfigParser
- config=ConfigParser.ConfigParser()
+ import ConfigParser
+ config=ConfigParser.ConfigParser()
except :
- import configparser
- config=configparser.configparser()
+ 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)))
+ 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}))
+ 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)
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)})))
+ 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)})))
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+"++")
+ # 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+"++")
def printDEnv():
if d_env.studies is None:return
for study in d_env.studies:
- print((tr("nom etude : %s", study["comm"])))
- printPours(study,dec="++")
+ print((tr("nom etude : %s", study["comm"])))
+ printPours(study,dec="++")
def createparser():
# creation du parser des options de la ligne de commande
action="callback", callback=checkPoursuite,
help=tr("nom du fichier poursuite"))
- parser.add_option(u"-i","--include",
+ parser.add_option(u"-i","--include",
action="callback", callback=checkInclude,
nargs=2, help=tr("numero d'unite suivi du nom du fichier include"))
parser=createparser()
(options,args)=parser.parse_args(args[1:])
if not hasattr(options,"studies"):
- options.studies=[]
- options.comm=[]
+ 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 : import pyxb
+ except : print ('Please, source pyxb environment'); exit()
try:
- del parser.values.current
+ del parser.values.current
except:
- pass
+ pass
for file in args:
- if os.path.isfile(file):
+ 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)):
+ 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()
parser.error(tr("Nombre incorrect d'arguments"))
options.comm.append(file)
options.studies.append({"comm":file})
- elif len(args) == 2 :
+ elif len(args) == 2 :
if options.locale:
- print((tr("Localisation specifiee pour l'application.")))
+ print((tr("Localisation specifiee pour l'application.")))
else:
- parser.error(tr("Nombre incorrect d'arguments"))
- else:
+ parser.error(tr("Nombre incorrect d'arguments"))
+ else:
parser.error(tr("Nombre incorrect d'arguments"))
global d_env
[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)
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
+ # 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
+ if k in (u"pours","comm"): continue
+ text=appliEficas.getSource(v)
+ d[k]=v,text,d
return d
inistylefile=os.path.join(prefsCode.repIni,"style.py")
if os.path.isfile(inistylefile):
- exec(compile(open(inistylefile).read(), inistylefile, 'exec'))
+ exec(compile(open(inistylefile).read(), inistylefile, 'exec'))
import fontes
for attr in dir(style):
- if attr[0]=='_':continue
- if not hasattr(fontes,attr):continue
- setattr(fontes,attr,getattr(style,attr))
-
-
+ if attr[0]=='_':continue
+ if not hasattr(fontes,attr):continue
+ setattr(fontes,attr,getattr(style,attr))
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module sert a construire les structures de donnees porteuses
+ 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
- """
- 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
- """
- # L'attribut parent stocke le lien vers l'objet ENTITE relie a UIINFO
- 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",)
- if type(self.groupes) != tuple:
- self.groupes=(self.groupes,)
+ """
+ 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):
+ """
+ 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
+ if groupes == None:
+ # L'entite n'a pas de groupe associe. On lui associe le groupe "DEFAUT"
+ self.groupes=("DEFAUT",)
+ if type(self.groupes) != tuple:
+ self.groupes=(self.groupes,)
def traiteCommande(commande,niveau):
"""
niveau.dict_groupes[grp].append(commande.nom)
def traiteNiveau(niveau):
- if niveau.l_niveaux == ():
- # Il n'y a pas de sous niveaux. niveau.entites ne contient que des commandes
- niveau.dict_groupes={}
- for oper in niveau.entites:
- 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())
- # 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
- else:
- for niv in niveau.l_niveaux:
- traiteNiveau(niv)
+ if niveau.l_niveaux == ():
+ # Il n'y a pas de sous niveaux. niveau.entites ne contient que des commandes
+ niveau.dict_groupes={}
+ for oper in niveau.entites:
+ 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())
+ # 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
+ else:
+ for niv in niveau.l_niveaux:
+ 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
- """
- #dict_groupes["CACHE"]=[]
- #XXX Ne doit pas marcher avec les niveaux
- if cata.JdC.l_niveaux == ():
- # 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={}
- for commande in cata.JdC.commandes:
- 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())
- # 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
- else:
- # Le catalogue de commandes contient des definitions de niveau
- for niv in cata.JdC.l_niveaux:
- traiteNiveau(niv)
-
-
-
+ """
+ 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 == ():
+ # 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={}
+ for commande in cata.JdC.commandes:
+ 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())
+ # 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
+ else:
+ # Le catalogue de commandes contient des definitions de niveau
+ for niv in cata.JdC.l_niveaux:
+ traiteNiveau(niv)
