def __init__(self):
number_entite(self)
- def get_docu(self):
+ def getDocu(self):
if hasattr(self,'docu') :
if self.docu != "" : return self.docu
else:
if hasattr(self,'pere'):
- return self.pere.get_docu()
+ return self.pere.getDocu()
else:
return None
else:
regle.enregistreXML(moi,catalogueXml)
catalogueXml.reglesUtilisees.append(self.regles)
- if ((self.get_docu() !="" and self.get_docu() !=None) or \
+ if ((self.getDocu() !="" and self.getDocu() !=None) or \
(self.fr != "" and self.fr != None) or \
(self.ang != "" and self.ang != None) ):
dico={}
- if self.get_docu() !=None : dico["docu"]=self.get_docu()
+ if self.getDocu() !=None : dico["docu"]=self.getDocu()
if self.fr != None : dico["fr"]=six.text_type(self.fr,"iso-8859-1")
if self.ang != None : dico["ang"]=self.ang
doc=ET.SubElement(moi,'doc')
return ''
return sdname
- def is_reentrant(self):
+ def isReentrant(self):
"""
Indique si la commande est reentrante
"""
return self.definition.reentrant == 'o'
- def init_modif(self):
+ def initModif(self):
"""
Met l'etat de l'etape a : modifie
Propage la modification au parent
"""
- # init_modif doit etre appele avant de realiser une modification
+ # initModif doit etre appele avant de realiser une modification
# La validite devra etre recalculee apres cette modification
# mais dans l'appel a fin_modif pour preserver l'etat modified
# de tous les objets entre temps
- #print "init_modif",self,self.parent
+ #print "initModif",self,self.parent
self.state = 'modified'
if self.parent:
- self.parent.init_modif()
+ self.parent.initModif()
def fin_modif(self):
"""
if self.parent:
self.parent.fin_modif()
- def nomme_sd(self,nom) :
+ def nommeSd(self,nom) :
"""
Cette methode a pour fonction de donner un nom (nom) au concept
produit par l'etape (self).
if not concept_re.match(nom):
return 0, tr("Un nom de concept doit etre un identificateur Python")
+ # pour eviter que le nom du concept soit le nom de la classe --> souci pour utiliser le concept
+ if (nom == self.definition.nom) : return (0, tr("un concept de type ")+ nom + tr(" ne peut pas se nommer ") + nom)
+ if ( nom in dir(self.jdc.cata[0])) : return (0, nom + tr("est un not reserve"))
+ #if (not isinstance(nom,str)) : return (0, tr("Le nom ") + nom + tr(" est un mot reserve"))
#if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
# return 0, tr("Nom de concept trop long (maxi 8 caracteres)")
- self.init_modif()
+ self.initModif()
#
# On verifie d'abord si les mots cles sont valides
#
- if not self.isvalid(sd='non') : return 0,"Nommage du concept refuse : l'operateur n'est pas valide"
+ if not self.isValid(sd='non') : return 0,"Nommage du concept refuse : l'operateur n'est pas valide"
#
# Cas particulier des operateurs obligatoirement reentrants
#
if self.definition.reentrant == 'f' :
sd = self.jdc.get_sd_avant_etape(nom,self)
if sd != None :
- if isinstance(sd,self.get_type_produit()) :
+ if isinstance(sd,self.getType_produit()) :
self.sd = self.reuse = sd
self.sdnom = sd.nom
self.fin_modif()
# On peut donc creer le concept retourne
# Il est cree sans nom mais enregistre dans la liste des concepts existants
try:
- self.get_sd_prod()
+ self.getSdProd()
# Renommage du concept : Il suffit de changer son attribut nom pour le nommer
self.sd.nom = nom
self.sdnom=nom
- self.parent.update_concept_after_etape(self,self.sd)
+ self.parent.updateConceptAfterEtape(self,self.sd)
self.fin_modif()
return 1, tr("Nommage du concept effectue")
except:
#Un concept produit preexiste
old_nom=self.sd.nom
if old_nom.find('sansnom') :
- # Dans le cas ou old_nom == sansnom, isvalid retourne 0 alors que ...
+ # Dans le cas ou old_nom == sansnom, isValid retourne 0 alors que ...
# par contre si le concept existe et qu'il s'appelle sansnom c'est que l'etape est valide
# on peut donc le nommer sans test prealable
if self.parent.get_sd_autour_etape(nom,self):
# Renommage du concept : Il suffit de changer son attribut nom pour le nommer
self.sd.nom=nom
self.sdnom=nom
- self.parent.update_concept_after_etape(self,self.sd)
+ self.parent.updateConceptAfterEtape(self,self.sd)
self.fin_modif()
return 1, tr("Nommage du concept effectue")
- if self.isvalid() :
- # Normalement l appel de isvalid a mis a jour le concept produit (son type)
+ if self.isValid() :
+ # Normalement l appel de isValid a mis a jour le concept produit (son type)
# Il suffit de specifier l attribut nom de sd pour le nommer si le nom n est pas
# deja attribue
if self.parent.get_sd_autour_etape(nom,self):
# Renommage du concept : Il suffit de changer son attribut nom pour le nommer
self.sd.nom=nom
self.sdnom=nom
- self.parent.update_concept_after_etape(self,self.sd)
+ self.parent.updateConceptAfterEtape(self,self.sd)
self.fin_modif()
return 1, tr("Nommage du concept effectue")
else:
# Normalement on ne devrait pas passer ici
return 0, 'Normalement on ne devrait pas passer ici'
- def get_sdprods(self,nom_sd):
+ def getSdprods(self,nom_sd):
"""
Fonction : retourne le concept produit par l etape de nom nom_sd
s il existe sinon None
"""
if self.actif:return
self.actif = 1
- self.init_modif()
+ self.initModif()
if self.sd :
try:
self.jdc.append_sdprod(self.sd)
et de la liste des sd
"""
self.actif = 0
- self.init_modif()
+ self.initModif()
if self.sd :
self.jdc.del_sdprod(self.sd)
- self.jdc.delete_concept_after_etape(self,self.sd)
+ self.jdc.deleteConceptAfterEtape(self,self.sd)
CONNECTOR.Emit(self,"supp",None)
CONNECTOR.Emit(self,"valid")
- def control_sdprods(self,d):
+ def controlSdprods(self,d):
"""
Cette methode doit verifier que ses concepts produits ne sont pas
deja definis dans le contexte
Si c'est le cas, les concepts produits doivent etre supprimes
"""
- #print "control_sdprods",d.keys(),self.sd and self.sd.nom,self.nom
+ #print "controlSdprods",d.keys(),self.sd and self.sd.nom,self.nom
if self.sd:
if self.sd.nom in d :
# Le concept est deja defini
# Redefinition du concept, on l'annule
#XXX on pourrait simplement annuler son nom pour conserver les objets
# l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
- self.init_modif()
+ self.initModif()
sd=self.sd
self.sd=self.reuse=self.sdnom=None
#supprime les references a sd dans les etapes suivantes
- self.parent.delete_concept_after_etape(self,sd)
+ self.parent.deleteConceptAfterEtape(self,sd)
self.fin_modif()
def supprime_sdprod(self,sd):
"""
if sd is not self.sd:return
if self.sd != None :
- self.init_modif()
+ self.initModif()
self.parent.del_sdprod(sd)
self.sd=None
self.fin_modif()
- self.parent.delete_concept(sd)
+ self.parent.deleteConcept(sd)
- def supprime_sdprods(self):
+ def supprimeSdProds(self):
"""
Fonction:
Lors d'une destruction d'etape, detruit tous les concepts produits
Une procedure n'en a aucun
Une macro en a en general plus d'un
"""
- #print "supprime_sdprods",self
+ #print "supprimeSdProds",self
if self.reuse is self.sd :return
# l'etape n'est pas reentrante
# le concept retourne par l'etape est a supprimer car il etait
# cree par l'etape
if self.sd != None :
self.parent.del_sdprod(self.sd)
- self.parent.delete_concept(self.sd)
+ self.parent.deleteConcept(self.sd)
def close(self):
return
- def update_concept(self,sd):
+ def updateConcept(self,sd):
for child in self.mc_liste :
- child.update_concept(sd)
+ child.updateConcept(sd)
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
"""
Inputs :
- sd=concept detruit
"""
if self.reuse and self.reuse == sd:
self.sd=self.reuse=None
- self.init_modif()
+ self.initModif()
for child in self.mc_liste :
- child.delete_concept(sd)
+ child.deleteConcept(sd)
- def replace_concept(self,old_sd,sd):
+ def replaceConcept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplace
"""
if self.reuse and self.reuse == old_sd:
self.sd=self.reuse=sd
- self.init_modif()
+ self.initModif()
for child in self.mc_liste :
- child.replace_concept(old_sd,sd)
+ child.replaceConcept(old_sd,sd)
- def reset_context(self):
+ def resetContext(self):
pass
- def get_noms_sd_oper_reentrant(self):
+ def getNomsSdOperReentrant(self):
"""
Retourne la liste des noms de concepts utilisesa l'interieur de la commande
qui sont du type que peut retourner cette commande
liste_sd = self.get_sd_utilisees()
l_noms = []
if type(self.definition.sd_prod) == types.FunctionType:
- d=self.cree_dict_valeurs(self.mc_liste)
+ d=self.creeDictValeurs(self.mc_liste)
try:
classe_sd_prod = self.definition.sd_prod(*(), **d)
except:
l_noms.sort()
return l_noms
- def get_genealogie_precise(self):
+ def getGenealogie_precise(self):
return [self.nom]
- def get_genealogie(self):
+ def getGenealogie(self):
"""
Retourne la liste des noms des ascendants de l'objet self
en s'arretant a la premiere ETAPE rencontree
"""
return [self.nom]
- def verif_existence_sd(self):
+ def verifExistenceSd(self):
"""
Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
avant etape, sinon enleve la referea ces concepts
"""
- #print "verif_existence_sd",self.sd
+ #print "verifExistenceSd",self.sd
for motcle in self.mc_liste :
- motcle.verif_existence_sd()
+ motcle.verifExistenceSd()
def update_mc_global(self):
"""
self.mc_globaux={}
I_MCCOMPO.MCCOMPO.update_mc_global(self)
- def update_condition_bloc(self):
+ def updateConditionBloc(self):
"""
Realise l'update des blocs conditionnels fils de self
"""
- self._update_condition_bloc()
+ self._updateConditionBloc()
- def get_objet_commentarise(self,format):
+ def getObjetCommentarise(self,format):
"""
Cette methode retourne un objet commande commentarisee
representant la commande self
commande_comment = commande_comm.COMMANDE_COMM(texte=texte_commande,
reg='non',
parent=parent)
- self.parent.suppentite(self)
- parent.addentite(commande_comment,pos)
+ self.parent.suppEntite(self)
+ parent.addEntite(commande_comment,pos)
return commande_comment
def modified(self):
"""Le contenu de l'etape (mots cles, ...) a ete modifie"""
if self.nom=="DETRUIRE":
- self.parent.control_context_apres(self)
+ self.parent.controlContextApres(self)
Surcharge la methode make_register du package Noyau
"""
if self.parent :
- self.jdc = self.parent.get_jdc_root()
+ self.jdc = self.parent.getJdcRoot()
self.id= self.parent.register(self)
self.UserError=self.jdc.UserError
if self.definition.niveau :
def report(self):
cr= Validation.V_ETAPE.ETAPE.report(self)
#rafraichisst de la validite de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles)
- self.isvalid()
- if not self.isvalid() and self.nom == "INCLUDE" :
+ self.isValid()
+ if not self.isValid() and self.nom == "INCLUDE" :
self.cr.fatal(('Etape : %s ligne : %r %s'),
self.nom, self.appel[0], tr("\n Include Invalide. \n ne sera pas pris en compte"))
return cr
from . import I_REGLE
class EXCLUS(I_REGLE.REGLE):
- def purge_liste(self,liste_a_purger,liste_mc_presents):
+ def purge_liste(self,liste_a_purger,listeMcPresents):
regle_active=0
- for mc_present in liste_mc_presents:
+ for mc_present in listeMcPresents:
if mc_present in self.mcs:
regle_active=1
break
for mc in self.mcs:
# Il ne faut pas purger un mot cle present. Sa cardinalite est verifiee par ailleurs
- if mc in liste_a_purger and mc not in liste_mc_presents:
+ if mc in liste_a_purger and mc not in listeMcPresents:
liste_a_purger.remove(mc)
return liste_a_purger
l_args=None
return type_retourne,l_args,corps
- def get_nom(self):
+ def getNom(self):
"""
Retourne le nom de la FORMULE, cad le nom de la SD si elle existe,
la string vide sinon
(nom,type_retourne,arguments,corps)
"""
t,a,c = self.analyse_formule()
- n = self.get_nom()
+ n = self.getNom()
return (n,t,a,c)
- def verif_arguments(self,arguments = None):
+ def verifArguments(self,arguments = None):
"""
Verifie si les arguments passes en argument (si aucun prend les arguments courants)
sont des arguments valide pour une FORMULE.
corps = self.corps
if not arguments :
arguments = self.arguments
- formule=(self.get_nom(),self.type_retourne,arguments,corps)
+ formule=(self.getNom(),self.type_retourne,arguments,corps)
# on recupere la liste des constantes et des autres fonctions predefinies
# et qui peuvent etre utilisees dans le corps de la formule courante
l_ctes,l_form = self.jdc.get_parametres_fonctions_avant_etape(self)
except :
traceback.print_exc()
return 0,tr("Impossible de realiser la verification de la formule")
- return verificateur.isvalid(),verificateur.report()
+ return verificateur.isValid(),verificateur.report()
- def verif_nom(self,nom=None):
+ def verifNom(self,nom=None):
"""
Verifie si le nom passe en argument (si aucun prend le nom courant)
est un nom valide pour une FORMULE.
- un message d'erreurs ('' si illicite)
"""
if not nom :
- nom = self.get_nom()
+ nom = self.getNom()
if nom == "" :
return 0,tr("Pas de nom donne a la FORMULE")
if len(nom) > 8 :
return 0,tr("Une formule ne peut retourner une valeur de type : %s" %type)
return 1,''
- def verif_formule(self,formule=None):
+ def verifFormule(self,formule=None):
"""
Verifie la validite de la formule passee en argument.
Cette nouvelle formule est passee sous la forme d'un tuple : (nom,type_retourne,arguments,corps)
"""
if not formule :
formule = (None,None,None,None)
- test_nom,erreur_nom = self.verif_nom(formule[0])
+ test_nom,erreur_nom = self.verifNom(formule[0])
test_type,erreur_type = self.verif_type(formule[1])
if formule[2]:
args = '('+formule[2]+')'
else:
args = None
- test_arguments,erreur_arguments = self.verif_arguments(args)
+ test_arguments,erreur_arguments = self.verifArguments(args)
test_corps,erreur_corps = self.verif_corps(corps = formule[3], arguments = args)
# test global = produit des tests partiels
test = test_nom*test_type*test_arguments*test_corps
erreur = erreur+(len(mess) > 0)*'\n'+mess
return test,erreur
- def verif_formule_python(self,formule=None):
+ def verifFormule_python(self,formule=None):
"""
Pour l instant ne fait qu un compile python
il serait possible d ajouter des tests sur les arguments
"""
if not formule :
formule = (None,None,None,None)
- test_nom,erreur_nom = self.verif_nom(formule[0])
+ test_nom,erreur_nom = self.verifNom(formule[0])
if formule[2]:
args = '('+formule[2]+')'
else:
args = None
- test_arguments,erreur_arguments = self.verif_arguments(args)
+ test_arguments,erreur_arguments = self.verifArguments(args)
corps=formule[3]
erreur_formule= ''
test_formule=1
self.valeur = {}
self.valeur[self.type_retourne] = self.arguments+' = ' + self.corps
self.McBuild()
- sd = self.get_sd_prod()
+ sd = self.getSdProd()
if sd:
sd.nom = formule[0]
self.corps = formule[2]
self.type_retourne = formule[1]
- sd = self.get_sd_prod()
+ sd = self.getSdProd()
if sd:
sd.nom = formule[0]
- self.init_modif()
+ self.initModif()
return 1
def active(self):
Il faut ajouter la formule au contexte global du JDC
"""
self.actif = 1
- self.init_modif()
- nom = self.get_nom()
+ self.initModif()
+ nom = self.getNom()
if nom == '' : return
try:
self.jdc.append_fonction(self.sd)
Il faut supprimer la formule du contexte global du JDC
"""
self.actif = 0
- self.init_modif()
+ self.initModif()
if not self.sd : return
self.jdc.del_fonction(self.sd)
- def update_concept(self,sd):
+ def updateConcept(self,sd):
return
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
"""
Inputs :
- sd=concept detruit
sauf les objets FORM_ETAPE qui doivent verifier que le concept detruit n'est pas
utilise dans le corps de la fonction
"""
- self.init_modif()
+ self.initModif()
- def replace_concept(self,old_sd,sd):
+ def replaceConcept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplace
Les objets FORM_ETAPE devraient verifier que le concept remplace n'est pas
utilise dans le corps de la fonction
"""
- self.init_modif()
+ self.initModif()
self.old_recorded_units={}
- def get_index(self,objet):
+ def getIndex(self,objet):
"""
Retourne la position d'objet dans la liste self
"""
return self.etapes.index(objet)
- def get_sd_avant_du_bon_type(self,etape,types_permis):
+ def getSdAvantDuBonType(self,etape,types_permis):
"""
Retourne la liste des concepts avant etape d'un type acceptable
"""
- d=self.get_contexte_avant(etape)
+ d=self.getContexte_avant(etape)
l=[]
# Matrix.state='arecalculer'
# Correlation=Matrix.get_child('CorrelationMatrix')
# if Correlation !=None : Correlation.state='arecalculer'
- # Correlation.isvalid()
- # Matrix.isvalid()
+ # Correlation.isValid()
+ # Matrix.isValid()
# etapeTraitee.state='arecalculer'
- # if etapeTraitee.state=='arecalculer': etapeTraitee.isvalid()
+ # if etapeTraitee.state=='arecalculer': etapeTraitee.isValid()
def recalcule_etat_correlation(self):
for etapeTraitee in self.etapes :
Correlation=etapeTraitee.get_child('CorrelationMatrix')
if Correlation !=None :
Correlation.state='arecalculer'
- Correlation.isvalid()
- etapeTraitee.isvalid()
+ Correlation.isValid()
+ etapeTraitee.isValid()
def recalcule_validite_apres_changement_global_jdc(self):
#print "je passe dans recalcule_validite_apres_changement_global_jdc"
try :
- liste=self.get_jdc_root().cata[0].liste_condition
+ liste=self.getJdcRoot().cata[0].liste_condition
except :
liste=()
for etapeTraitee in self.etapes :
if etapeTraitee.nom not in liste: continue
self.forceRecalculBloc(etapeTraitee)
etapeTraitee.state='arecalculer'
- etapeTraitee.isvalid()
+ etapeTraitee.isValid()
def forceRecalculBloc(self,objet):
# Attention : certains objets deviennent None quand on recalcule
# les conditions d existence des blocs
if objet != None: objet.state='arecalculer'
- if hasattr(objet,'liste_mc_presents'):
- for childNom in objet.liste_mc_presents():
+ if hasattr(objet,'listeMcPresents'):
+ for childNom in objet.listeMcPresents():
child=objet.get_child(childNom)
- if hasattr(objet,'_update_condition_bloc'):objet._update_condition_bloc()
+ if hasattr(objet,'_updateConditionBloc'):objet._updateConditionBloc()
self.forceRecalculBloc(child)
- def get_sd_avant_du_bon_type_pour_type_de_base(self,etape,type):
+ def getSdAvantDuBonTypePourTypeDeBase(self,etape,type):
"""
Retourne la liste des concepts avant etape d'1 type de base acceptable
Attention different de la routine precedente : 1 seul type passe en parametre
Teste sur issubclass et par sur le type permis
"""
- d=self.get_contexte_avant(etape)
+ d=self.getContexte_avant(etape)
l=[]
try :
typeverif=self.cata[0].__dict__[type]
return l
def cherche_list_avant(self,etape,valeur):
- d=self.get_contexte_avant(etape)
+ d=self.getContexte_avant(etape)
for k,v in d.items():
if issubclass(v.__class__,LASSD):
if k == valeur :
return 1
return 0
- def addentite(self,name,pos):
+ def addEntite(self,name,pos):
"""
Ajoute une entite :
Si name est le nom d une commande ou un commentaire ajoute
une etape au JDC
Sinon remonte une erreur
"""
- self.init_modif()
+ self.initModif()
self.editmode=1
if name == "COMMENTAIRE" :
from Extensions import commentaire
objet.nom = "_comm_"+repr(ind)
if pos == None : pos = 0
self.etapes.insert(pos,objet)
- self.reset_context()
+ self.resetContext()
self.editmode=0
- self.active_etapes()
+ self.activeEtapes()
CONNECTOR.Emit(self,"add",objet)
self.fin_modif()
return objet
objet = parametre.PARAMETRE(nom=nom_param)
if pos == None : pos = 0
self.etapes.insert(pos,objet)
- self.reset_context()
+ self.resetContext()
self.editmode=0
- self.active_etapes()
+ self.activeEtapes()
CONNECTOR.Emit(self,"add",objet)
self.fin_modif()
return objet
objet = parametre_eval.PARAMETRE_EVAL(nom=nom_param)
if pos == None : pos = 0
self.etapes.insert(pos,objet)
- self.reset_context()
+ self.resetContext()
self.editmode=0
- self.active_etapes()
+ self.activeEtapes()
CONNECTOR.Emit(self,"add",objet)
self.fin_modif()
return objet
objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet)
objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition]
self.etapes.insert(pos,objet)
- self.reset_context()
+ self.resetContext()
# il faut verifier que les concepts utilises par objet existent bien
# a ce niveau d'arborescence
- objet.verif_existence_sd()
+ objet.verifExistenceSd()
objet.update_mc_global()
self.editmode=0
- self.active_etapes()
+ self.activeEtapes()
CONNECTOR.Emit(self,"add",objet)
self.fin_modif()
return objet
if pos == None : pos = 0
self.etapes.insert(pos,e)
self.reset_current_step()
- self.reset_context()
+ self.resetContext()
self.editmode=0
- self.active_etapes()
+ self.activeEtapes()
CONNECTOR.Emit(self,"add",e)
self.fin_modif()
return e
def reset_current_step(self):
CONTEXT.unset_current_step()
- def liste_mc_presents(self):
+ def listeMcPresents(self):
return []
def get_sd_avant_etape(self,nom_sd,etape):
- return self.get_contexte_avant(etape).get(nom_sd,None)
+ return self.getContexte_avant(etape).get(nom_sd,None)
- def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
+ def getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec='non'):
"""
Cette methode retourne la SD sd de nom nom_sd qui est eventuellement
definie apres etape en tenant compte des concepts detruits
Si avec vaut 'non' exclut etape de la recherche
"""
- #print "JDC.get_sd_apres_etape_avec_detruire",nom_sd,sd
+ #print "JDC.getSdApresEtapeAvecDetruire",nom_sd,sd
ietap=self.etapes.index(etape)
if avec == 'non':ietap=ietap+1
d={nom_sd:sd}
for e in self.etapes[ietap:]:
- if e.isactif():
- e.update_context(d)
+ if e.isActif():
+ e.updateContext(d)
autre_sd=d.get(nom_sd,None)
if autre_sd is None:
# Le concept a ete detruit. On interrompt la recherche car il n'y a
# concept initial
return sd
- def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
+ def getSdApresEtape(self,nom_sd,etape,avec='non'):
"""
Cette methode retourne la SD de nom nom_sd qui est eventuellement
definie apres etape
ietap=self.etapes.index(etape)
if avec == 'non':ietap=ietap+1
for e in self.etapes[ietap:]:
- sd=e.get_sdprods(nom_sd)
+ sd=e.getSdprods(nom_sd)
if sd:
if hasattr(e,'reuse'):
if e.reuse != sd:
"""
sd=self.get_sd_avant_etape(nom_sd,etape)
if sd:return sd
- return self.get_sd_apres_etape(nom_sd,etape,avec)
+ return self.getSdApresEtape(nom_sd,etape,avec)
- def get_contexte_apres(self,etape):
+ def getContexte_apres(self,etape):
"""
Retourne le dictionnaire des concepts connus apres etape
On tient compte des commandes qui modifient le contexte
comme DETRUIRE ou les macros
Si etape == None, on retourne le contexte en fin de JDC
"""
- if not etape: return self.get_contexte_avant(etape)
+ if not etape: return self.getContexte_avant(etape)
- d=self.get_contexte_avant(etape)
- if etape.isactif():etape.update_context(d)
+ d=self.getContexte_avant(etape)
+ if etape.isActif():etape.updateContext(d)
self.index_etape_courante=self.index_etape_courante+1
return d
- def active_etapes(self):
+ def activeEtapes(self):
"""
Cette methode a pour fonction de desactiver les etapes qui doivent
l'etre cad, dans le cas d'ASTER, les etapes qui ne sont pas
self.etapes2=self.etapes[0:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:]
self.etapes=self.etapes2
if indexNoeudACopier < indexNoeudOuColler :
- self.delete_concept_entre_etapes(indexNoeudACopier,indexNoeudOuColler,sd)
- self.reset_context()
+ self.deleteConcept_entre_etapes(indexNoeudACopier,indexNoeudOuColler,sd)
+ self.resetContext()
for e in self.etapes :
e.state = 'modified'
- self.control_context_apres(None)
+ self.controlContextApres(None)
return 1
- def suppentite(self,etape) :
+ def suppEntite(self,etape) :
"""
Cette methode a pour fonction de supprimer une etape dans
un jeu de commandes
#PN correction de bugs
if etape not in self.etapes: return 0
- self.init_modif()
+ self.initModif()
index_etape=self.etapes.index(etape)
self.etapes.remove(etape)
# Il faut la desenregistrer
etape.niveau.unregister(etape)
- etape.supprime_sdprods()
+ etape.supprimeSdProds()
etape.close()
etape.supprime()
- self.active_etapes()
+ self.activeEtapes()
# Apres suppression de l'etape il faut controler que les etapes
# suivantes ne produisent pas des concepts DETRUITS dans op_init de etape
etape=self.etapes[index_etape]
else:
etape=None
- self.control_context_apres(etape)
+ self.controlContextApres(etape)
- self.reset_context()
+ self.resetContext()
CONNECTOR.Emit(self,"supp",etape)
self.fin_modif()
return 1
- def control_context_apres(self,etape):
+ def controlContextApres(self,etape):
"""
Cette methode verifie que les etapes apres l'etape etape
ont bien des concepts produits acceptables (pas de conflit de
Effectue les verifications sur les etapes du jdc mais aussi sur les
jdc parents s'ils existent.
"""
- #print "control_context_apres",self,etape
+ #print "controlContextApres",self,etape
#Regularise les etapes du jdc apres l'etape etape
self.control_jdc_context_apres(etape)
def control_jdc_context_apres(self,etape):
"""
- Methode semblable a control_context_apres mais ne travaille
+ Methode semblable a controlContextApres mais ne travaille
que sur les etapes et sous etapes du jdc
"""
#print "control_jdc_context_apres",self,etape
#derniere etape du jdc : rien a faire
return
- context=self.get_contexte_avant(etape)
+ context=self.getContexte_avant(etape)
for e in self.etapes[index_etape:]:
- e.control_sdprods(context)
- e.update_context(context)
+ e.controlSdprods(context)
+ e.updateContext(context)
def analyse(self):
self.compile()
if not self.cr.estvide():return
self.exec_compile()
- self.active_etapes()
+ self.activeEtapes()
def register_parametre(self,param):
"""
l_fonctions = []
# on recupere le contexte avant etape
# on ne peut mettre dans les deux listes que des elements de ce contexte
- d=self.get_contexte_avant(etape)
+ d=self.getContexte_avant(etape)
# construction de l_constantes
for param in self.params:
nom = param.nom
nb=nb+len(niv.etapes)
return nb
- def init_modif(self):
+ def initModif(self):
"""
Methode appelee au moment ou une modification va etre faite afin de
declencher d'eventuels traitements pre-modification
"""
- #print "init_modif",self
+ #print "initModif",self
self.state = 'modified'
def fin_modif(self):
#print "fin_modif",self
CONNECTOR.Emit(self,"valid")
- self.isvalid()
+ self.isValid()
pass
- def deep_update_condition_bloc(self):
+ def deep_updateConditionBloc(self):
# pour le moment, on ne fait rien
- self.get_jdc_root().recalcule_validite_apres_changement_global_jdc()
+ self.getJdcRoot().recalcule_validite_apres_changement_global_jdc()
#raise EficasException(tr("Pas implemente"))
- def update_condition_bloc(self):
+ def updateConditionBloc(self):
# pour le moment, on ne fait rien
raise EficasException(tr("Pas implemente"))
# cette liste a le format suivant : [etape,(bloc,mcfact,...),nom_mc,valeur_mc]
l_mc = []
for etape in self.etapes :
- if etape.isactif() :
- if not etape.isvalid() :
+ if etape.isActif() :
+ if not etape.isValid() :
l = etape.get_liste_mc_inconnus()
if l : l_mc.extend(l)
return l_mc
- def get_genealogie_precise(self):
+ def getGenealogie_precise(self):
return []
- def get_genealogie(self):
+ def getGenealogie(self):
"""
Retourne la liste des noms des ascendants de l'objet self
jusqu'a la premiere ETAPE parent.
"""
return []
- def get_liste_cmd(self):
+ def getListeCmd(self):
"""
Retourne la liste des commandes du catalogue
"""
- return self.niveau.definition.get_liste_cmd()
+ return self.niveau.definition.getListeCmd()
def get_groups(self):
"""
"""
self._etape_context=etape
- def reset_context(self):
+ def resetContext(self):
"""
Cette methode reinitialise le contexte glissant pour pouvoir
tenir compte des modifications de l'utilisateur : craation
de commandes, nommage de concepts, etc.
"""
- #print "reset_context",self,self.nom
+ #print "resetContext",self,self.nom
self.current_context={}
self.index_etape_courante=0
ind={}
self.index_etapes=ind
# for etape in self.etapes:
- # etape.reset_context()
+ # etape.resetContext()
def del_sdprod(self,sd):
"""
if fonction not in self.fonctions : self.fonctions.append(fonction)
self.g_context[fonction.nom]=fonction
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
"""
Inputs :
- sd=concept detruit
que de transmettre aux fils
"""
for etape in self.etapes :
- etape.delete_concept(sd)
+ etape.deleteConcept(sd)
#PN PN PN pour les matrices ????
#self.get_variables_avant(etape)
- def replace_concept_after_etape(self,etape,old_sd,sd):
+ def replaceConceptAfterEtape(self,etape,old_sd,sd):
"""
Met a jour les etapes du JDC qui sont apres etape en fonction
du remplacement du concept sd
if index == len(self.etapes) :
return # etape est la derniere etape du jdc ...on ne fait rien !
for child in self.etapes[index:]:
- child.replace_concept(old_sd,sd)
+ child.replaceConcept(old_sd,sd)
- def update_concept_after_etape(self,etape,sd):
+ def updateConceptAfterEtape(self,etape,sd):
"""
Met a jour les etapes du JDC qui sont apres etape en fonction
de la modification (principalement nommage) du concept sd
if index == len(self.etapes) :
return # etape est la derniere etape du jdc ...on ne fait rien !
for child in self.etapes[index:]:
- child.update_concept(sd)
+ child.updateConcept(sd)
def dump_state(self):
print(("JDC.state: ",self.state))
#contexte initial du jdc
context=self.condition_context.copy()
#contexte courant des concepts. Il contient les parametres
- context.update(self.get_contexte_avant(etape))
+ context.update(self.getContexte_avant(etape))
try :
objet = eval(valeur,context)
return objet
A quoi sert editmode ?
- Si editmode vaut 1, on est en mode edition de JDC. On cherche
a enregistrer une etape que l'on a creee avec eficas (en passant
- par addentite) auquel cas on ne veut recuperer que son numero
- d'enregistrement et c'est addentite qui l'enregistre dans
+ par addEntite) auquel cas on ne veut recuperer que son numero
+ d'enregistrement et c'est addEntite qui l'enregistre dans
self.etapes a la bonne place...
- Si editmode vaut 0, on est en mode relecture d'un fichier de
commandes et on doit enregistrer l'etape a la fin de self.etapes
# XXX En mode editeur dans EFICAS, le nommage doit etre gere differemment
# Le dictionnaire g_context ne represente pas le contexte
# effectif avant une etape.
- # Il faut utiliser get_contexte_avant avec indication de l'etape
+ # Il faut utiliser getContexte_avant avec indication de l'etape
# traitee.
# Cette etape est indiquee par l'attribut _etape_context qui a ete
# positionne prealablement par un appel a set_etape_context
if CONTEXT.debug : print(("JDC.NommerSdprod ",sd,sdnom))
if self._etape_context:
- o=self.get_contexte_avant(self._etape_context).get(sdnom,None)
+ o=self.getContexte_avant(self._etape_context).get(sdnom,None)
else:
o=self.sds_dict.get(sdnom,None)
if restrict == 'non':
self.g_context[sdnom]=sd
- def delete_concept_entre_etapes(self,index1,index2,sd):
+ def deleteConcept_entre_etapes(self,index1,index2,sd):
if index2 <= index1 :return
for child in self.etapes[index1:index2]:
- child.delete_concept(sd)
+ child.deleteConcept(sd)
- def delete_concept_after_etape(self,etape,sd):
+ def deleteConceptAfterEtape(self,etape,sd):
"""
Met a jour les etapes du JDC qui sont apres etape en fonction
de la disparition du concept sd
if index == len(self.etapes) :
return # etape est la derniere etape du jdc ...on ne fait rien !
for child in self.etapes[index:]:
- child.delete_concept(sd)
+ child.deleteConcept(sd)
#ATTENTION SURCHARGE : les methodes ci-dessus surchargent des methodes de Noyau et Validation : a reintegrer
- def get_file(self,unite=None,fic_origine=''):
+ def getFile(self,unite=None,fic_origine=''):
"""
Retourne le nom du fichier correspondant a un numero d'unite
logique (entier) ainsi que le source contenu dans le fichier
"""
if self.appli is not None:
# Si le JDC est relie a une application maitre, on delegue la recherche
- file,text= self.appli.get_file(unite,fic_origine)
+ file,text= self.appli.getFile(unite,fic_origine)
else:
file = None
if unite != None:
linecache.cache[file]=0,0,text.split('\n'),file
return file,text
- def isvalid(self,cr='non'):
+ def isValid(self,cr='non'):
if hasattr(self,'valid'): old_valid=self.valid
else:old_valid=0
- valid=Validation.V_JDC.JDC.isvalid(self,cr)
+ valid=Validation.V_JDC.JDC.isValid(self,cr)
if valid != old_valid:
CONNECTOR.Emit(self,"valid")
return valid
- def get_l_noms_etapes(self):
+ def getLNomsEtapes(self):
"""
Retourne la liste des noms des etapes de self
"""
def __init__(self):
self.l_noms_entites=[]
- def get_liste_cmd(self):
+ def getListeCmd(self):
self.l_noms_entites.sort()
return self.l_noms_entites
- def get_docu(self):
+ def getDocu(self):
return
self.text_error=""
self.recorded_units={}
- def get_sdprods(self,nom_sd):
+ def getSdprods(self,nom_sd):
"""
Fonction : retourne le concept produit par l etape de nom nom_sd
s il existe sinon None
return d.get(nom_sd,None)
return None
- def get_contexte_jdc(self,fichier,text):
+ def getContexte_jdc(self,fichier,text):
"""
Interprete text comme un texte de jdc et retourne le contexte final.
ou leve une exception
--> utilisee par ops.POURSUITE et INCLUDE
"""
- #print ("get_contexte_jdc",self,self.nom)
+ #print ("getContexte_jdc",self,self.nom)
# On recupere l'etape courante
step=CONTEXT.get_current_step()
try:
#if 1 :
# on essaie de creer un objet JDC auxiliaire avec un contexte initial
- # Attention get_contexte_avant retourne un dictionnaire qui contient
+ # Attention getContexte_avant retourne un dictionnaire qui contient
# le contexte courant. Ce dictionnaire est reactualise regulierement.
# Si on veut garder l'etat du contexte fige, il faut en faire une copie.
- context_ini = self.parent.get_contexte_avant(self).copy()
- #print "get_contexte_jdc",context_ini.keys()
+ context_ini = self.parent.getContexte_avant(self).copy()
+ #print "getContexte_jdc",context_ini.keys()
# Indispensable avant de creer un nouveau JDC
CONTEXT.unset_current_step()
# mais on n'insere pas les concepts
# On retablit l'etape courante step
#print j.cr
- #print j.isvalid()
+ #print j.isValid()
CONTEXT.unset_current_step()
CONTEXT.set_current_step(step)
raise EficasException(tr("Impossible de relire le fichier %s \n ")+ six.text_type(j.cr))
- if not j.isvalid():
+ if not j.isValid():
# L'INCLUDE n'est pas valide.
# on produit un rapport d'erreurs
cr=j.report()
# Si aucune erreur rencontree
# On recupere le contexte de l'include verifie
try:
- j_context=j.get_verif_contexte()
+ j_context=j.getVerifContexte()
#print j_context.keys()
#print j.g_context.keys()
except:
#print "reevalue_sd_jdc"
l_sd_supp,l_sd_repl = self.diff_contextes()
for sd in l_sd_supp:
- self.parent.delete_concept_after_etape(self,sd)
+ self.parent.deleteConceptAfterEtape(self,sd)
for old_sd,sd in l_sd_repl:
- self.parent.replace_concept_after_etape(self,old_sd,sd)
+ self.parent.replaceConceptAfterEtape(self,old_sd,sd)
def diff_contextes(self):
"""
l_sd_replaced.append((self.old_contexte_fichier_init[old_key],self.contexte_fichier_init[old_key]))
return l_sd_suppressed,l_sd_replaced
- def control_sdprods(self,d):
+ def controlSdprods(self,d):
"""
Cette methode doit verifier que les concepts produits par la
commande ne sont pas incompatibles avec le contexte fourni (d).
Si la macro a elle meme des etapes, elle doit propager
le traitement (voir methode control_jdc_context_apres de I_JDC)
"""
- #print ("I_MACRO_ETAPE.control_sdprods",d.keys(),self,self.nom,self.sd and self.sd.nom)
+ #print ("I_MACRO_ETAPE.controlSdprods",d.keys(),self,self.nom,self.sd and self.sd.nom)
if self.sd:
if self.sd.nom in d:
# Le concept est deja defini
# Redefinition du concept, on l'annule
#XXX on pourrait simplement annuler son nom pour conserver les objets
# l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
- self.init_modif()
+ self.initModif()
sd=self.sd
self.sd=self.reuse=self.sdnom=None
- self.parent.delete_concept_after_etape(self,sd)
+ self.parent.deleteConceptAfterEtape(self,sd)
self.fin_modif()
# On verifie les concepts a droite du signe =
- self.init_modif()
+ self.initModif()
sdprods=self.sdprods[:]
self.sdprods=[]
for co in sdprods:
if co.nom in d and co is not d[co.nom] :
#nettoie les mots cles de l'etape qui ont comme valeur co
- self.delete_concept(co)
+ self.deleteConcept(co)
#supprime les references a co dans les etapes suivantes
- self.parent.delete_concept_after_etape(self,co)
+ self.parent.deleteConceptAfterEtape(self,co)
else:
self.sdprods.append(co)
self.fin_modif()
for e in self.etapes:
- e.control_sdprods(d)
- e.update_context(d)
+ e.controlSdprods(d)
+ e.updateContext(d)
def supprime_sdprod(self,sd):
"""
Supprime le concept produit sd s'il est produit par l'etape
"""
if sd in self.sdprods:
- self.init_modif()
+ self.initModif()
self.parent.del_sdprod(sd)
self.sdprods.remove(sd)
self.fin_modif()
- self.parent.delete_concept(sd)
+ self.parent.deleteConcept(sd)
return
if sd is not self.sd :return
if self.sd is not None :
- self.init_modif()
+ self.initModif()
self.parent.del_sdprod(sd)
self.sd=None
self.fin_modif()
- self.parent.delete_concept(sd)
+ self.parent.deleteConcept(sd)
- def supprime_sdprods(self):
+ def supprimeSdProds(self):
"""
Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
Un operateur n a qu un concept produit
Une procedure n'en a aucun
Une macro en a en general plus d'un
"""
- #print "supprime_sdprods"
+ #print "supprimeSdProds"
if self.reuse is not self.sd :
# l'etape n'est pas reentrante
# le concept retourne par l'etape est a supprimer car il etait
# cree par l'etape
if self.sd != None :
self.parent.del_sdprod(self.sd)
- self.parent.delete_concept(self.sd)
+ self.parent.deleteConcept(self.sd)
# On detruit les concepts a droite du signe =
for co in self.sdprods:
self.parent.del_sdprod(co)
- self.parent.delete_concept(co)
+ self.parent.deleteConcept(co)
# Si la macro a des etapes et des concepts inclus, on les detruit
for nom_sd,co in self.g_context.items():
if not isinstance(co,ASSD):continue
self.parent.del_sdprod(co)
- self.parent.delete_concept(co)
+ self.parent.deleteConcept(co)
# On met g_context a blanc
self.g_context={}
# La macro a un jdc auxiliaire inclus. On demande sa fermeture
self.jdc_aux.close()
- def reset_context(self):
+ def resetContext(self):
if hasattr(self,"jdc_aux") and self.jdc_aux:
# La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte
- self.jdc_aux.reset_context()
+ self.jdc_aux.resetContext()
- def update_concept(self,sd):
- I_ETAPE.ETAPE.update_concept(self,sd)
+ def updateConcept(self,sd):
+ I_ETAPE.ETAPE.updateConcept(self,sd)
for etape in self.etapes:
- etape.update_concept(sd)
+ etape.updateConcept(sd)
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
"""
Fonction : Mettre a jour les mots cles de l etape et eventuellement
le concept produit si reuse suite a la disparition du concept sd
Seuls les mots cles simples MCSIMP font un traitement autre
que de transmettre aux fils
"""
- #print "delete_concept",sd
- I_ETAPE.ETAPE.delete_concept(self,sd)
+ #print "deleteConcept",sd
+ I_ETAPE.ETAPE.deleteConcept(self,sd)
for etape in self.etapes:
- etape.delete_concept(sd)
+ etape.deleteConcept(sd)
- def replace_concept(self,old_sd,sd):
+ def replaceConcept(self,old_sd,sd):
"""
Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
suite au remplacement du concept old_sd par sd
"""
- #print "replace_concept",old_sd,sd
- I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
+ #print "replaceConcept",old_sd,sd
+ I_ETAPE.ETAPE.replaceConcept(self,old_sd,sd)
for etape in self.etapes:
- etape.replace_concept(old_sd,sd)
+ etape.replaceConcept(old_sd,sd)
def change_fichier_init(self,new_fic,text):
"""
# L'evaluation de text dans un JDC auxiliaire s'est bien passe
# on peut poursuivre le traitement
- self.init_modif()
+ self.initModif()
self.state="undetermined"
self.fichier_err=None
# On enregistre la modification de fichier
self.record_unite()
# Le contexte du parent doit etre reinitialise car les concepts produits ont change
- self.parent.reset_context()
+ self.parent.resetContext()
# Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
self.old_contexte_fichier_init=self.old_context
# On ajoute egalement le concept produit dans le sds_dict du parent
# sans verification car on est sur (verification integree) que
# le nommage est possible
- j_context=self.jdc_aux.get_contexte_avant(None)
+ j_context=self.jdc_aux.getContexte_avant(None)
self.g_context.clear()
context_ini=self.jdc_aux.context_ini
for k,v in j_context.items():
self.fichier_err = None
# On enregistre la modification de fichier
- self.init_modif()
+ self.initModif()
self.state="undetermined"
self.record_unite()
# Le contexte du parent doit etre reinitialise car les concepts produits ont change
- self.parent.reset_context()
+ self.parent.resetContext()
# On remplace les anciens concepts par les nouveaux (y compris ajouts
# et suppression) et on propage les modifications aux etapes precedentes et suivantes
if self.old_jdc_aux:
self.old_jdc_aux.close()
- self.jdc_aux.force_contexte(self.g_context)
+ self.jdc_aux.forceContexte(self.g_context)
def build_include(self,fichier,text):
import Extensions.jdc_include
# Attention fonctionne pour import_Zone de MT
# a adapter eventuellement
try :
- contexte = self.get_contexte_jdc(None,text)
+ contexte = self.getContexte_jdc(None,text)
except EficasException:
return 0
self.g_context={}
self.etapes=[]
- self.jdc.reset_context()
+ self.jdc.resetContext()
self.jdc_aux=None
CONTEXT.unset_current_step()
return 1
def build_jdcauxInclude(self,text):
try :
- contexte = self.get_contexte_jdc(None,text)
+ contexte = self.getContexte_jdc(None,text)
except EficasException:
pass
index=self.jdc.etapes.index(self)
self.fichier_unite=None
self.fichier_err = None
try:
- contexte = self.get_contexte_jdc(fichier,text)
+ contexte = self.getContexte_jdc(fichier,text)
if contexte is None :
# Impossible de construire le jdc auxiliaire (sortie par None)
# On simule une sortie par exception
else:
# La construction du jdc auxiliaire est allee au bout
self.contexte_fichier_init = contexte
- self.init_modif()
+ self.initModif()
self.fin_modif()
except:
# Impossible de construire le jdc auxiliaire (sortie par exception)
l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
if self.jdc.appli is not None:
- self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+ self.jdc.appli.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
message= tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
self.g_context={}
self.jdc_aux=None
self.fichier_err = ''.join(l)
self.contexte_fichier_init={}
- self.init_modif()
+ self.initModif()
self.fin_modif()
raise EficasException(" ")
"""
print ("make_contexte_include",fichier)
# on recupere le contexte d'un nouveau jdc dans lequel on interprete text
- contexte = self.get_contexte_jdc(fichier,text)
+ contexte = self.getContexte_jdc(fichier,text)
print ("make_contexte_include",fichier)
if contexte == None :
raise EficasException("Impossible de construire le jeu de commandes correspondant au fichier")
# l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
# l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
# en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
- # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
+ # existants en debut de macro contenus dans context_ini (dans getContexte_jdc)
# g_context est utilise pour avoir les concepts produits par la macro
# contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro
self.contexte_fichier_init = contexte
elif unite != self.fichier_unite :
# L'unite etait definie precedemment. On remplace l'include
#
- f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
+ f,text=self.getFileMemo(unite=unite,fic_origine=self.parent.nom)
if f is None:
# Le fichier associe n'a pas pu etre defini
# on change l'unite associee mais pas l'include
self.parent.record_unit(unite,self)
# Le contexte du parent doit etre reinitialise car les concepts
# produits ont change
- self.parent.reset_context()
+ self.parent.resetContext()
# Si des concepts ont disparu lors du changement de fichier, on
# demande leur suppression
self.reevalue_sd_jdc()
if hasattr(self,'fichier_unite') :
self.parent.record_unit(self.fichier_unite,self)
- def get_file_memo(self, unite=None, fname=None, fic_origine=''):
+ def getFileMemo(self, unite=None, fname=None, fic_origine=''):
"""Retourne le nom du fichier et le source correspondant a l'unite unite
Initialise en plus recorded_units
"""
- #print "get_file_memo",unite,fic_origine,self,self.parent
+ #print "getFileMemo",unite,fic_origine,self,self.parent
#print self.parent.recorded_units
if unite is None:
# On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
f = fname
text = open(fname, 'r').read()
else:
- f,text=self.jdc.get_file(unite=unite, fic_origine=fic_origine)
+ f,text=self.jdc.getFile(unite=unite, fic_origine=fic_origine)
else:
f,text=None,None
self.recorded_units=units
if f is None and self.jdc.appli:
- self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+ self.jdc.appli.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
message= tr("Ce fichier ne sera pas pris en compte\nLe fichier associe n'est pas defini"))
return f,text
- def update_context(self,d):
+ def updateContext(self,d):
"""
Met a jour le contexte contenu dans le dictionnaire d
Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
Une fonction enregistree dans op_init peut egalement modifier le contexte
"""
- #print ("update_context",self,self.nom,d.keys())
+ #print ("updateContext",self,self.nom,d.keys())
if hasattr(self,"jdc_aux") and self.jdc_aux:
- #ATTENTION: update_context NE DOIT PAS appeler reset_context
- # car il appelle directement ou indirectement update_context
- # equivalent a reset_context. Evite les recursions
+ #ATTENTION: updateContext NE DOIT PAS appeler resetContext
+ # car il appelle directement ou indirectement updateContext
+ # equivalent a resetContext. Evite les recursions
self.jdc_aux.context_ini=d.copy()
self.jdc_aux.current_context={}
self.jdc_aux.index_etape_courante=0
- #ATTENTION: il ne faut pas utiliser self.jdc_aux.get_contexte_avant
+ #ATTENTION: il ne faut pas utiliser self.jdc_aux.getContexte_avant
#car cet appel conduit a des remontees multiples incoherentes dans le
# ou les parents.
- #get_context_avant appelle update_context qui NE DOIT PAS appeler get_contexte_avant
+ #get_context_avant appelle updateContext qui NE DOIT PAS appeler getContexte_avant
#On n'a besoin que d'un update local connaissant
# le contexte amont : d qui sert a reinitialiser self.context_ini
for e in self.etapes:
- e.update_context(d)
+ e.updateContext(d)
return
if type(self.definition.op_init) == types.FunctionType:
if self.sd != None :d[self.sd.nom]=self.sd
for co in self.sdprods:
d[co.nom]=co
- #print "update_context.fin",d.keys()
+ #print "updateContext.fin",d.keys()
#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
def copy(self):
Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self)
#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
- def get_file(self,unite=None,fic_origine=''):
+ def getFile(self,unite=None,fic_origine=''):
"""Retourne le nom du fichier et le source correspondant a l'unite unite
"""
if self.jdc :
- f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
+ f,text=self.jdc.getFile(unite=unite,fic_origine=fic_origine)
else:
f,text=None,None
return f,text
if hasattr(self,'old_context_fichier_init' ):
reevalue=1
for concept in self.old_context_fichier_init.values():
- self.jdc.delete_concept(concept)
+ self.jdc.deleteConcept(concept)
if fichier == None :
- fichier=str(self.jdc.appli.get_file_dictDonnees())
+ fichier=str(self.jdc.appli.getFile_dictDonnees())
if fichier == str("") :
self.fichier_ini="badfile"
self.fichier_text=""
self.parent.record_unit(999,self)
try :
MCFils=self.get_child('FileName')
- MCFils.set_valeur(None)
+ MCFils.setValeur(None)
except :
pass
raise EficasException(self.fichier_err)
self.parent.record_unit(unite,self)
try :
MCFils=self.get_child('FileName')
- #MCFils.set_valeur(fichier)
- #on appelle pas set_valeur qui modifie le contexte ce qui fout le bazar
+ #MCFils.setValeur(fichier)
+ #on appelle pas setValeur qui modifie le contexte ce qui fout le bazar
#pas de modification de bloc
MCFils.valeur=fichier
MCFils.val=fichier
if hasattr(self,'old_context_fichier_init' ):
reevalue=1
for concept in self.old_context_fichier_init.values():
- self.jdc.delete_concept(concept)
+ self.jdc.deleteConcept(concept)
if fichier == None :
- fichier=str(self.jdc.appli.get_file_variable())
+ fichier=str(self.jdc.appli.getFileVariable())
if fichier == str("") :
self.fichier_ini="badfile"
self.fichier_text=""
self.parent.record_unit(999,self)
try :
MCFils=self.get_child('FileName')
- MCFils.set_valeur(None)
+ MCFils.setValeur(None)
except :
pass
raise EficasException(self.fichier_err)
self.parent.record_unit(unite,self)
try :
MCFils=self.get_child('FileName')
- MCFils.set_valeur(fichier)
+ MCFils.setValeur(fichier)
except :
pass
except:
mcFeuille.state="modified"
except :
pass
- e.isvalid()
+ e.isValid()
def make_incl2_except(self,mess=None):
l=traceback.format_exception_only(tr("Fichier invalide"),sys.exc_info()[1])
if self.jdc.appli is not None:
if mess == None :
- self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+ self.jdc.appli.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
message= tr("Le contenu de ce fichier ne sera pas pris en compte\n %s",\
''.join(l)))
else :
- self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+ self.jdc.appli.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
message=tr(mess))
#self.parent.record_unit(unite,self)
self.g_context={}
self.contexte_fichier_init={}
try :
MCFils=self.get_child('FileName')
- MCFils.set_valeur(None)
+ MCFils.setValeur(None)
except :
pass
if not hasattr(self,'fichier_ini') :
# Si le fichier n'est pas defini on le demande
- f,text=self.get_file_memo(unite=unite, fname=fname, fic_origine=self.parent.nom)
+ f,text=self.getFileMemo(unite=unite, fname=fname, fic_origine=self.parent.nom)
# On memorise le fichier retourne
self.fichier_ini = f
self.fichier_text = text
except:
l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
if self.jdc.appli:
- self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+ self.jdc.appli.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
message=tr("Le contenu de ce fichier ne sera pas pris en compte\n"+''.join(l)))
self.parent.record_unit(unite,self)
self.g_context={}
#print "make_poursuite"
if not hasattr(self,'fichier_ini') :
# Si le fichier n'est pas defini on le demande
- f,text=self.get_file_memo(fic_origine=self.parent.nom)
+ f,text=self.getFileMemo(fic_origine=self.parent.nom)
# On memorise le fichier retourne
self.fichier_ini = f
self.fichier_unite = None
except:
l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
if self.jdc.appli:
- self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier poursuite"),
+ self.jdc.appli.afficheAlerte(tr("Erreur lors de l'evaluation du fichier poursuite"),
message=tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
self.parent.record_unit(None,self)
self.g_context={}
"""
return self.nom
- def get_liste_mc_ordonnee(self,liste,dico):
+ def getListeMcOrdonnee(self,liste,dico):
"""
Retourne la liste ordonnee (suivant le catalogue) des mots-cles
d'une entite composee dont le chemin complet est donne sous forme
il faut encore rearranger cette liste (certains mots-cles deja
presents ne doivent plus etre proposes, regles ...)
"""
- return self.filtre_liste_mc(self.get_liste_mc_ordonnee_brute(liste,dico))
+ return self.filtre_liste_mc(self.getListeMcOrdonnee_brute(liste,dico))
- def get_liste_mc_ordonnee_brute(self,liste,dico):
+ def getListeMcOrdonnee_brute(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
etre repetes
"""
liste = copy(liste_brute)
- liste_mc_presents = self.liste_mc_presents()
+ listeMcPresents = self.listeMcPresents()
# on enleve les mots-cles non permis par les regles
for regle in self.definition.regles:
# la methode purge_liste est a developper pour chaque regle qui
# influe sur la liste de choix a proposer a l'utilisateur
# --> EXCLUS,UN_PARMI,PRESENT_ABSENT
- liste = regle.purge_liste(liste,liste_mc_presents)
+ liste = regle.purge_liste(liste,listeMcPresents)
# on enleve les mots-cles dont l'occurrence est deja atteinte
liste_copy = copy(liste)
for k in liste_copy:
# Pour corriger les exces qui pourraient etre commis dans la methode purge_liste
# des regles, on essaie de compenser comme suit :
# on ajoute les mots cles facteurs presents dont l'occurence n'est pas atteinte
- for k in liste_mc_presents:
+ for k in listeMcPresents:
if k in liste:continue
objet = self.get_child(k,restreint = 'oui')
if isinstance(objet,MCFACT):
liste.append(k)
return liste
- def liste_mc_presents(self):
+ def listeMcPresents(self):
"""
Retourne la liste des noms des mots-cles fils de self presents construite
a partir de self.mc_liste
l.append(k)
return l
- def get_index_child(self,nom_fils):
+ def getIndex_child(self,nom_fils):
"""
Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
Permet de savoir a quelle position il faut ajouter un nouveau mot-cle
"""
cata_ordonne = self.jdc.cata_ordonne_dico
- liste_noms_mc_ordonnee = self.get_liste_mc_ordonnee_brute(self.get_genealogie(),cata_ordonne)
- liste_noms_mc_presents = self.liste_mc_presents()
+ liste_noms_mc_ordonnee = self.getListeMcOrdonnee_brute(self.getGenealogie(),cata_ordonne)
+ liste_noms_mc_presents = self.listeMcPresents()
index=0
for nom in liste_noms_mc_ordonnee:
if nom == nom_fils:break
# on la retourne
return liste
- def suppentite(self,objet) :
+ def suppEntite(self,objet) :
"""
Supprime le fils 'objet' de self :
Retourne 1 si la suppression a pu etre effectuee,
# Impossible de supprimer objet. Il n'est pas dans mc_liste
return 0
- self.init_modif()
+ self.initModif()
self.mc_liste.remove(objet)
CONNECTOR.Emit(self,"supp",objet)
objet.delete_mc_global()
- objet.update_condition_bloc()
+ objet.updateConditionBloc()
objet.supprime()
self.etape.modified()
self.fin_modif()
return 1
- def isoblig(self):
+ def isOblig(self):
return 0
- def addentite(self,name,pos=None):
+ def addEntite(self,name,pos=None):
"""
Ajoute le mot-cle name a la liste des mots-cles de
l'objet MCCOMPOSE
"""
- self.init_modif()
+ self.initModif()
if type(name)==bytes :
# on est en mode creation d'un motcle
if self.ispermis(name) == 0 : return 0
# Appel de la methode qui fait le menage dans les references
# sur les concepts produits (verification que les concepts existent
# dans le contexte de la commande courante).
- objet.verif_existence_sd()
+ objet.verifExistenceSd()
# On verifie que l'ajout d'objet est autorise
if self.ispermis(objet) == 0:
- self.jdc.appli.affiche_alerte(tr("Erreur"),
+ self.jdc.appli.afficheAlerte(tr("Erreur"),
tr("L'objet %(v_1)s ne peut etre un fils de %(v_2)s",\
{'v_1': objet.nom, 'v_2': self.nom}))
self.fin_modif()
objet.reparent(self)
CONNECTOR.Emit(self,"add",objet)
objet.update_mc_global()
- objet.update_condition_bloc()
+ objet.updateConditionBloc()
self.fin_modif()
return objet
else:
# Le mot cle existe deja. Si le mot cle est repetable,
# on cree une liste d'objets. Dans le cas contraire,
# on emet un message d'erreur.
- if not old_obj.isrepetable():
- self.jdc.appli.affiche_alerte(tr("Erreur"),tr("L'objet %s ne peut pas etre repete", objet.nom))
+ if not old_obj.isRepetable():
+ self.jdc.appli.afficheAlerte(tr("Erreur"),tr("L'objet %s ne peut pas etre repete", objet.nom))
self.fin_modif()
return 0
else:
# une liste d'objets de meme type existe deja
- old_obj.addentite(objet)
+ old_obj.addEntite(objet)
self.fin_modif()
return old_obj
if fils.parent.nom != self.nom : return 0
return 1
- def update_concept(self,sd):
+ def updateConcept(self,sd):
for child in self.mc_liste :
- child.update_concept(sd)
+ child.updateConcept(sd)
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
"""
Inputs :
- sd=concept detruit
de transmettre aux fils
"""
for child in self.mc_liste :
- child.delete_concept(sd)
+ child.deleteConcept(sd)
- def replace_concept(self,old_sd,sd):
+ def replaceConcept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplace
concept old_sd
"""
for child in self.mc_liste :
- child.replace_concept(old_sd,sd)
+ child.replaceConcept(old_sd,sd)
def get_liste_mc_inconnus(self):
"""
for k,v in self.reste_val.items() :
l_mc.append([self,k,v])
for child in self.mc_liste :
- if child.isvalid() : continue
+ if child.isValid() : continue
l_child = child.get_liste_mc_inconnus()
for mc in l_child:
l = [self]
l_mc.append(l)
return l_mc
- def deep_update_condition_bloc(self):
+ def deep_updateConditionBloc(self):
"""
Parcourt l'arborescence des mcobject et realise l'update
- des blocs conditionnels par appel de la methode update_condition_bloc
+ des blocs conditionnels par appel de la methode updateConditionBloc
"""
- self._update_condition_bloc()
+ self._updateConditionBloc()
for mcobj in self.mc_liste:
- if hasattr(mcobj,"deep_update_condition_bloc"):
- mcobj.deep_update_condition_bloc()
+ if hasattr(mcobj,"deep_updateConditionBloc"):
+ mcobj.deep_updateConditionBloc()
- def update_condition_bloc(self):
+ def updateConditionBloc(self):
"""
Realise l'update des blocs conditionnels fils de self
et propage au parent
"""
- self._update_condition_bloc()
- if self.parent:self.parent.update_condition_bloc()
+ self._updateConditionBloc()
+ if self.parent:self.parent.updateConditionBloc()
- def _update_condition_bloc(self):
+ def _updateConditionBloc(self):
"""
Realise l'update des blocs conditionnels fils de self
"""
# le bloc doit etre present
# mais le bloc n'est pas present et il doit etre cree
#print "AJOUT BLOC",k
- pos=self.get_index_child(k)
- self.addentite(k,pos)
+ pos=self.getIndex_child(k)
+ self.addEntite(k,pos)
if not presence and bloc:
# le bloc devrait etre absent
# le bloc est present : il faut l'enlever
#print "SUPPRESSION BLOC",k,bloc
- self.suppentite(bloc)
+ self.suppEntite(bloc)
- def verif_condition_bloc(self):
+ def verifConditionBloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
(en fonction du catalogue donc de la definition) de self
liste_retraits.append(k)
return liste_ajouts,liste_retraits
- def verif_existence_sd(self):
+ def verifExistenceSd(self):
"""
Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
avant etape, sinon enleve la reference a ces concepts
"""
for motcle in self.mc_liste :
- motcle.verif_existence_sd()
+ motcle.verifExistenceSd()
def update_mc_global(self):
"""
except :
pass
- def init_modif_up(self):
- Validation.V_MCCOMPO.MCCOMPO.init_modif_up(self)
+ def initModifUp(self):
+ Validation.V_MCCOMPO.MCCOMPO.initModifUp(self)
CONNECTOR.Emit(self,"valid")
import Noyau
class MCFACT(I_MCCOMPO.MCCOMPO):
- def isrepetable(self):
+ def isRepetable(self):
"""
Indique si l'objet est repetable.
Retourne 1 si le mot-cle facteur self peut etre repete
else :
return 0
- def isoblig(self):
+ def isOblig(self):
if self.definition.statut != 'o' : return 0
objet = self.parent.get_child(self.nom)
if len(objet) > 1 : return 0
try:
if len(objet) > 1 :
- index = objet.get_index(self)+1 # + 1 a cause de la numerotation qui commence a 0
+ index = objet.getIndex(self)+1 # + 1 a cause de la numerotation qui commence a 0
return self.nom +'_'+repr(index)+':'
else:
return self.nom
except:
return tr("Erreur - mot cle facteur de nom : %s", self.nom)
- def get_genealogie_precise(self):
+ def getGenealogie_precise(self):
nom=self.getlabeltext()
if nom[-1]==':' : nom=nom[0:-1]
if self.parent:
- l=self.parent.get_genealogie_precise()
+ l=self.parent.getGenealogie_precise()
l.append(nom.strip())
return l
else:
return [nom.strip()]
- def init_modif(self):
+ def initModif(self):
"""
Met l'etat de l'objet a modified et propage au parent
qui vaut None s'il n'existe pas
self.state = 'modified'
parent= hasattr(self,"alt_parent") and self.alt_parent or self.parent
if parent:
- parent.init_modif()
+ parent.initModif()
def fin_modif(self):
"""
"""
return 1
- def get_index(self,objet):
+ def getIndex(self,objet):
"""
Retourne la position d'objet dans la liste self
"""
return self.data.index(objet)
- def ajout_possible(self):
+ def ajoutPossible(self):
"""
Methode booleenne qui retourne 1 si on peut encore ajouter une occurrence
de l'element que contient self, 0 sinon
else:
return 0
- def isrepetable(self):
+ def isRepetable(self):
"""
Indique si l'objet est repetable.
Retourne 1 si le mot-cle facteur self peut etre repete
else :
return 0
- def isoblig(self):
+ def isOblig(self):
"""
Une MCList n'est jamais obligatoire (meme si le MCFACT qu'elle represente l'est
"""
return self.data[0].definition.statut=='o'
- def suppentite(self,obj):
+ def suppEntite(self,obj):
"""
Supprime le mot cle facteur obj de la MCLIST
"""
if obj not in self:
return 0
- self.init_modif()
+ self.initModif()
self.remove(obj)
CONNECTOR.Emit(self,"supp",obj)
- self.update_condition_bloc()
+ self.updateConditionBloc()
obj.supprime()
self.etape.modified()
self.fin_modif()
return 1
- def addentite(self,obj,pos=None):
+ def addEntite(self,obj,pos=None):
"""
Ajoute le mot cle facteur obj a la MCLIST a la position pos
Retourne None si l'ajout est impossible
# on est en mode creation d'un motcle
raise EficasException(tr("traitement non-prevu"))
- if not self.ajout_possible():
- self.jdc.appli.affiche_alerte(tr("Erreur"),
+ if not self.ajoutPossible():
+ self.jdc.appli.afficheAlerte(tr("Erreur"),
tr("L'objet %s ne peut pas etre ajoute", obj.nom))
return None
if obj.isMCList():
obj=obj.data[0]
- # Traitement du copier coller seulement
+ # traitement du copier coller seulement
# Les autres cas d'ajout sont traites dans MCFACT
- self.init_modif()
- obj.verif_existence_sd()
+ self.initModif()
+ obj.verifExistenceSd()
obj.reparent(self.parent)
if pos is None:
self.append(obj)
self.insert(pos,obj)
CONNECTOR.Emit(self,"add",obj)
self.fin_modif()
- self.update_condition_bloc()
+ self.updateConditionBloc()
return obj
- def liste_mc_presents(self):
+ def listeMcPresents(self):
return []
- def update_concept(self,sd):
+ def updateConcept(self,sd):
for child in self.data :
- child.update_concept(sd)
+ child.updateConcept(sd)
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
"""
Inputs :
- sd=concept detruit
que de transmettre aux fils
"""
for child in self.data :
- child.delete_concept(sd)
+ child.deleteConcept(sd)
- def replace_concept(self,old_sd,sd):
+ def replaceConcept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplace
du concept old_sd
"""
for child in self.data :
- child.replace_concept(old_sd,sd)
+ child.replaceConcept(old_sd,sd)
- def get_docu(self):
- return self.data[0].definition.get_docu()
+ def getDocu(self):
+ return self.data[0].definition.getDocu()
def get_liste_mc_inconnus(self):
"""
"""
l_mc = []
for mcfact in self.data :
- if mcfact.isvalid() : continue
+ if mcfact.isValid() : continue
l_child = mcfact.get_liste_mc_inconnus()
for mc in l_child:
l = [self]
l_mc.append(l)
return l_mc
- def verif_condition_regles(self,liste_presents):
+ def verifConditionRegles(self,liste_presents):
"""
Retourne la liste des mots-cles a rajouter pour satisfaire les regles
en fonction de la liste des mots-cles presents
# Sans objet pour une liste de mots cles facteurs
return []
- def deep_update_condition_bloc(self):
+ def deep_updateConditionBloc(self):
"""
Parcourt l'arborescence des mcobject et realise l'update
- des blocs conditionnels par appel de la methode update_condition_bloc
+ des blocs conditionnels par appel de la methode updateConditionBloc
"""
- #print "deep_update_condition_bloc",self
+ #print "deep_updateConditionBloc",self
for mcfact in self.data :
- mcfact.deep_update_condition_bloc()
+ mcfact.deep_updateConditionBloc()
- def update_condition_bloc(self):
+ def updateConditionBloc(self):
"""
Propage la mise a jour des conditions au parent.
Une liste ne fait pas de traitement sur les conditions
"""
- if self.parent: self.parent.update_condition_bloc()
+ if self.parent: self.parent.updateConditionBloc()
- def verif_condition_bloc(self):
+ def verifConditionBloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
(en fonction du catalogue donc de la definition) de self et
# Sans objet pour une liste de mots cles facteurs (a voir !!!)
return [],[]
- def init_modif(self):
+ def initModif(self):
"""
Met l'etat de l'objet a modified et propage au parent
qui vaut None s'il n'existe pas
"""
self.state = 'modified'
if self.parent:
- self.parent.init_modif()
+ self.parent.initModif()
def fin_modif(self):
"""
if self.parent:
self.parent.fin_modif()
- def get_genealogie_precise(self):
+ def getGenealogie_precise(self):
if self.parent:
- return self.parent.get_genealogie_precise()
+ return self.parent.getGenealogie_precise()
else:
return []
- def get_genealogie(self):
+ def getGenealogie(self):
"""
Retourne la liste des noms des ascendants.
Un objet MCList n'est pas enregistre dans la genealogie.
XXX Meme si le MCFACT fils ne l'est pas lui non plus ????
"""
if self.parent:
- return self.parent.get_genealogie()
+ return self.parent.getGenealogie()
else:
return []
- def get_liste_mc_ordonnee_brute(self,liste,dico):
+ def getListeMcOrdonnee_brute(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
dico=objet_cata.entites
return objet_cata.ordre_mc
- def verif_existence_sd(self):
+ def verifExistenceSd(self):
"""
Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
avant etape, sinon enleve la reference a ces concepts
"""
for motcle in self.data :
- motcle.verif_existence_sd()
+ motcle.verifExistenceSd()
- def get_fr(self):
+ def getFr(self):
"""
Retourne la chaine d'aide contenue dans le catalogue
en tenant compte de la langue
"""
try :
- return self.data[0].get_fr()
+ return self.data[0].getFr()
except:
return ''
class MCSIMP(I_OBJECT.OBJECT):
- def isvalid(self,cr='non'):
+ def isValid(self,cr='non'):
if self.state == 'unchanged':
return self.valid
for type_permis in self.definition.type:
return self.valideMatrice(cr=cr)
if self.definition.siValide != None :
self.definition.siValide(self)
- return Validation.V_MCSIMP.MCSIMP.isvalid(self,cr=cr)
+ return Validation.V_MCSIMP.MCSIMP.isValid(self,cr=cr)
def GetNomConcept(self):
p=self
p=p.parent
return ""
- def GetText(self):
+ def getText(self):
"""
Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
pointe par self
if self.valeur == None :
return None
elif type(self.valeur) == float :
- # Traitement d'un flottant isole
+ # traitement d'un flottant isole
txt = str(self.valeur)
clefobj=self.GetNomConcept()
if clefobj in self.jdc.appli.appliEficas.dict_reels :
txt=self.jdc.appli.appliEficas.dict_reels[clefobj][self.valeur]
elif type(self.valeur) in (list,tuple) :
if self.valeur==[] or self.valeur == (): return str(self.valeur)
- # Traitement des listes
+ # traitement des listes
txt='('
sep=''
for val in self.valeur:
if isinstance(val,tuple) and len(self.valeur) == 1 : txt=txt+','
txt=txt+')'
else:
- # Traitement des autres cas
+ # traitement des autres cas
txt = str(self.valeur)
# txt peut etre une longue chaine sur plusieurs lignes.
s=s+' )'
return s
- def wait_bool(self):
+ def waitBool(self):
for typ in self.definition.type:
try :
if typ == bool: return True
pass
return False
- def wait_co(self):
+ def waitCo(self):
"""
Methode booleenne qui retourne 1 si l'objet attend un objet ASSD
qui n'existe pas encore (type CO()), 0 sinon
return 1
return 0
- def wait_assd(self):
+ def waitAssd(self):
"""
Methode booleenne qui retourne 1 si le MCS attend un objet de type ASSD
ou derive, 0 sinon
return 1
return 0
- def wait_assd_or_geom(self):
+ def waitAssdOrGeom(self):
"""
Retourne 1 si le mot-cle simple attend un objet de type
assd, ASSD, geom ou GEOM
return 1
return 0
- def wait_geom(self):
+ def waitGeom(self):
"""
Retourne 1 si le mot-cle simple attend un objet de type GEOM
Retourne 0 dans le cas contraire
return 0
- def wait_TXM(self):
+ def waitTxm(self):
"""
Retourne 1 si le mot-cle simple attend un objet de type TXM
Retourne 0 dans le cas contraire
else:
return [self.valeur]
- def isoblig(self):
+ def isOblig(self):
return self.definition.statut=='o'
def isImmuable(self):
def valid_valeur(self,new_valeur):
"""
Verifie que la valeur passee en argument (new_valeur) est valide
- sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
+ sans modifier la valeur courante (evite d'utiliser setValeur et est plus performant)
"""
validite,mess=self.valid_val(new_valeur)
return validite
self.intoProto.adapt(val)
#on ne verifie pas la cardinalite
if self.definition.validators:
- validite=self.definition.validators.valide_liste_partielle(new_valeur)
+ validite=self.definition.validators.valideListePartielle(new_valeur)
except ValError as e:
validite=0
return validite
- def update_condition_bloc(self):
+ def updateConditionBloc(self):
""" Met a jour les blocs conditionnels dependant du mot cle simple self
"""
if self.definition.position == 'global' :
- self.etape.deep_update_condition_bloc()
+ self.etape.deep_updateConditionBloc()
elif self.definition.position == 'global_jdc' :
- self.jdc.deep_update_condition_bloc()
+ self.jdc.deep_updateConditionBloc()
else:
- self.parent.update_condition_bloc()
+ self.parent.updateConditionBloc()
- def set_valeur(self,new_valeur,evaluation='oui'):
- #print "set_valeur",new_valeur
- self.init_modif()
+ def setValeur(self,new_valeur,evaluation='oui'):
+ #print "setValeur",new_valeur
+ self.initModif()
self.valeur = new_valeur
self.val = new_valeur
- self.update_condition_bloc()
+ self.updateConditionBloc()
self.etape.modified()
self.fin_modif()
return 1
- def eval_valeur(self,new_valeur):
+ def evalValeur(self,new_valeur):
"""
Essaie d'evaluer new_valeur comme une SD, une declaration Python
ou un EVAL: Retourne la valeur evaluee (ou None) et le test de reussite (1 ou 0)
"""
sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
- #sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
+ #sd = self.jdc.getContexte_avant(self.etape).get(new_valeur,None)
#print sd
if sd is not None:
return sd,1
indice=new_valeur[new_valeur.find(u"[")+1:new_valeur.find(u"]")]
for p in self.jdc.params:
if p.nom == nomparam :
- if int(indice) < len(p.get_valeurs()):
+ if int(indice) < len(p.getValeurs()):
itparam=parametre.ITEM_PARAMETRE(p,int(indice))
return itparam
return None
except:
return None
- def update_concept(self,sd):
+ def updateConcept(self,sd):
if type(self.valeur) in (list,tuple) :
if sd in self.valeur:
- self.init_modif()
+ self.initModif()
self.fin_modif()
else:
if sd == self.valeur:
- self.init_modif()
+ self.initModif()
self.fin_modif()
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
"""
Inputs :
- sd=concept detruit
"""
if type(self.valeur) == tuple :
if sd in self.valeur:
- self.init_modif()
+ self.initModif()
self.valeur=list(self.valeur)
self.valeur.remove(sd)
self.fin_modif()
elif type(self.valeur) == list:
if sd in self.valeur:
- self.init_modif()
+ self.initModif()
self.valeur.remove(sd)
self.fin_modif()
else:
if self.valeur == sd:
- self.init_modif()
+ self.initModif()
self.valeur=None
self.val=None
self.fin_modif()
# a voir en python 3
if type_permis.__class__.__name__ == 'Matrice' :
self.state="changed"
- self.isvalid()
+ self.isValid()
- def replace_concept(self,old_sd,sd):
+ def replaceConcept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplace
Met a jour la valeur du mot cle simple suite au remplacement
du concept old_sd
"""
- #print "replace_concept",old_sd,sd
+ #print "replaceConcept",old_sd,sd
if type(self.valeur) == tuple :
if old_sd in self.valeur:
- self.init_modif()
+ self.initModif()
self.valeur=list(self.valeur)
i=self.valeur.index(old_sd)
self.valeur[i]=sd
self.fin_modif()
elif type(self.valeur) == list:
if old_sd in self.valeur:
- self.init_modif()
+ self.initModif()
i=self.valeur.index(old_sd)
self.valeur[i]=sd
self.fin_modif()
else:
if self.valeur == old_sd:
- self.init_modif()
+ self.initModif()
self.valeur=sd
self.val=sd
self.fin_modif()
- def set_valeur_co(self,nom_co):
+ def setValeurCo(self,nom_co):
"""
Affecte a self l'objet de type CO et de nom nom_co
"""
- #print "set_valeur_co",nom_co
+ #print "setValeurCo",nom_co
step=self.etape.parent
if nom_co == None or nom_co == '':
new_objet=None
new_objet = Accas.CO(nom_co)
CONTEXT.unset_current_step()
CONTEXT.set_current_step(cs)
- self.init_modif()
+ self.initModif()
self.valeur = new_objet
self.val = new_objet
# On force l'enregistrement de new_objet en tant que concept produit
- # de la macro en appelant get_type_produit avec force=1
- self.etape.get_type_produit(force=1)
+ # de la macro en appelant getType_produit avec force=1
+ self.etape.getType_produit(force=1)
self.fin_modif()
- step.reset_context()
- #print "set_valeur_co",new_objet
+ step.resetContext()
+ #print "setValeurCo",new_objet
return 1,tr("Concept cree")
- def verif_existence_sd(self):
+ def verifExistenceSd(self):
"""
Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
avant etape, sinon enleve la referea ces concepts
"""
- #print "verif_existence_sd"
+ #print "verifExistenceSd"
# Attention : possible probleme avec include
# A priori il n'y a pas de raison de retirer les concepts non existants
# avant etape. En fait il s'agit uniquement eventuellement de ceux crees par une macro
- l_sd_avant_etape = list(self.jdc.get_contexte_avant(self.etape).values())
+ l_sd_avant_etape = list(self.jdc.getContexte_avant(self.etape).values())
if type(self.valeur) in (tuple,list) :
l=[]
for sd in self.valeur:
if isinstance(sd,ASSD) :
- if sd in l_sd_avant_etape or self.etape.get_sdprods(sd.nom) is sd:
+ if sd in l_sd_avant_etape or self.etape.getSdprods(sd.nom) is sd:
l.append(sd)
else:
l.append(sd)
if len(l) < len(self.valeur):
- self.init_modif()
+ self.initModif()
self.valeur=tuple(l)
self.fin_modif()
else:
if isinstance(self.valeur,ASSD) :
- if self.valeur not in l_sd_avant_etape and self.etape.get_sdprods(self.valeur.nom) is None:
- self.init_modif()
+ if self.valeur not in l_sd_avant_etape and self.etape.getSdprods(self.valeur.nom) is None:
+ self.initModif()
self.valeur = None
self.fin_modif()
return self.definition.min,self.definition.max
- def get_type(self):
+ def getType(self):
"""
Retourne le type attendu par le mot-cle simple
"""
self.jdc.mc_globaux[self.nom]=self
def nbrColonnes(self):
- genea = self.get_genealogie()
+ genea = self.getGenealogie()
if "VALE_C" in genea and "DEFI_FONCTION" in genea : return 3
if "VALE" in genea and "DEFI_FONCTION" in genea : return 2
return 0
- def valide_item(self,item):
+ def valideItem(self,item):
"""Valide un item isole. Cet item est candidata l'ajout a la liste existante"""
valid=1
try:
return 0
- def NbDeVariables(self):
+ def nbDeVariables(self):
listeVariables=self.jdc.get_variables(self.etape)
self.monType.nbLigs=len(listeVariables)
self.monType.nbCols=len(listeVariables)
self.valeur=a
- def NbDeDistributions(self):
+ def nNbDeDistributions(self):
listeVariables=self.jdc.get_distributions(self.etape)
self.monType.nbLigs=len(listeVariables)
self.monType.nbCols=len(listeVariables)
verif=verif+self.verif_typeihm(v,cr)
return verif
- def init_modif_up(self):
- Validation.V_MCSIMP.MCSIMP.init_modif_up(self)
+ def initModifUp(self):
+ Validation.V_MCSIMP.MCSIMP.initModifUp(self)
CONNECTOR.Emit(self,"valid")
"""
return 0
- def get_regles(self):
+ def getRegles(self):
"""
Retourne les regles de self
"""
else :
return []
- def init_modif(self):
+ def initModif(self):
"""
Met l'etat de l'objet a modified et propage au parent
qui vaut None s'il n'existe pas
"""
self.state = 'modified'
if self.parent:
- self.parent.init_modif()
+ self.parent.initModif()
def fin_modif(self):
"""
if self.parent:
self.parent.fin_modif()
- def isrepetable(self):
+ def isRepetable(self):
"""
Indique si l'objet est repetable
"""
return 0
- def liste_mc_presents(self):
+ def listeMcPresents(self):
"""
Retourne la liste des noms des mots cles presents
"""
return []
- def get_docu(self):
- return self.definition.get_docu()
+ def getDocu(self):
+ return self.definition.getDocu()
def get_liste_mc_inconnus(self):
"""
"""
return []
- def verif_condition_regles(self,liste_presents):
+ def verifConditionRegles(self,liste_presents):
"""
Retourne la liste des mots-cles a rajouter pour satisfaire les regles
en fonction de la liste des mots-cles presents
liste=regle.verif_condition_regle(liste,liste_presents)
return liste
- def verif_condition_bloc(self):
+ def verifConditionBloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
(en fonction du catalogue donc de la definition) de self et
"""
return [],[]
- def get_genealogie_precise(self):
+ def getGenealogie_precise(self):
if self.parent:
- l=self.parent.get_genealogie_precise()
+ l=self.parent.getGenealogie_precise()
l.append(self.nom.strip())
return l
else:
return [self.nom.strip()]
- def get_genealogie(self):
+ def getGenealogie(self):
"""
Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC
ou ETAPE) de self jusqu'au premier objet etape rencontre
"""
if self.parent:
- l=self.parent.get_genealogie()
+ l=self.parent.getGenealogie()
l.append(self.nom.strip())
return l
else:
return [self.nom.strip()]
- def get_fr(self):
+ def getFr(self):
"""
Retourne la chaine d'aide contenue dans le catalogue
en tenant compte de la langue
except :
return ''
- def update_concept(self,sd):
+ def updateConcept(self,sd):
pass
def normalize(self):
from . import I_REGLE
class PRESENT_ABSENT(I_REGLE.REGLE):
- def purge_liste(self,liste_a_purger,liste_mc_presents):
+ def purge_liste(self,liste_a_purger,listeMcPresents):
regle_active=0
- if self.mcs[0] in liste_mc_presents:regle_active=1
+ if self.mcs[0] in listeMcPresents:regle_active=1
if not regle_active : return liste_a_purger
# Il ne faut pas purger le mot cle present
def get_sdname(self):
return ""
- def get_sdprods(self,nom_sd):
+ def getSdprods(self,nom_sd):
"""
Fonction : retourne le concept produit par l etape de nom nom_sd
s il existe sinon None
"""
return None
- def supprime_sdprods(self):
+ def supprimeSdProds(self):
"""
Fonction: Lors d'une destruction d'etape, detruit tous les concepts produits
Une procedure n'en a aucun
"""
return
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
"""
Fonction : Mettre a jour les mots cles de l etape
suite a la disparition du concept sd
- sd=concept detruit
"""
for child in self.mc_liste :
- child.delete_concept(sd)
+ child.deleteConcept(sd)
- def replace_concept(self,old_sd,sd):
+ def replaceConcept(self,old_sd,sd):
"""
Fonction : Mettre a jour les mots cles de l etape
suite au remplacement du concept old_sd
- sd=nouveau concept
"""
for child in self.mc_liste :
- child.replace_concept(old_sd,sd)
+ child.replaceConcept(old_sd,sd)
#ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
def Build_sd(self):
text = text + '\t' + mc.strip() + '\n'
return text
- def purge_liste(self,liste_a_purger,liste_mc_presents):
+ def purge_liste(self,liste_a_purger,listeMcPresents):
"""
Cette methode doit retirer de la liste liste_a_purger
les elements qui ne doivent plus apparaitre en fonction du contexte
class UN_PARMI(I_REGLE.REGLE):
- def purge_liste(self,liste_a_purger,liste_mc_presents):
+ def purge_liste(self,liste_a_purger,listeMcPresents):
regle_active=0
- for mc_present in liste_mc_presents:
+ for mc_present in listeMcPresents:
if mc_present in self.mcs:
regle_active=1
break
# Si un des mots cles est present, on les enleve tous
# sauf celui ci
for mc in self.mcs:
- if mc in liste_a_purger and mc not in liste_mc_presents:
+ if mc in liste_a_purger and mc not in listeMcPresents:
liste_a_purger.remove(mc)
return liste_a_purger
from Noyau.N_VALIDATOR import *
class Compulsory(Compulsory):
- def has_into(self):
+ def hasInto(self):
return 0
- def valide_liste_partielle(self,liste_courante=None):
+ def valideListePartielle(self,liste_courante=None):
return 1
class OrdList(OrdList):
- def valide_liste_partielle(self,liste_courante=None):
+ def valideListePartielle(self,liste_courante=None):
"""
Methode de validation de liste partielle pour le validateur OrdList
"""
repIcon=self.appliEficas.repIcon
couleur=self.item.getIconName()
- if not self.editor.configuration.differencieSiDefaut and couleur == 'ast-green-dark-ball' : couleur="ast-green-ball"
+ if not self.editor.maConfiguration.differencieSiDefaut and couleur == 'ast-green-dark-ball' : couleur="ast-green-ball"
monIcone = QIcon(repIcon+"/" + couleur + ".png")
self.setIcon(0,monIcone)
"""
repIcon=self.appliEficas.repIcon
couleur=self.item.getIconName()
- if not self.editor.configuration.differencieSiDefaut and couleur == 'ast-green-dark-ball' : couleur="ast-green-ball"
+ if not self.editor.maConfiguration.differencieSiDefaut and couleur == 'ast-green-dark-ball' : couleur="ast-green-ball"
monIcone = QIcon(repIcon+"/" + couleur + ".png")
self.setIcon(0,monIcone)
def getIconName(self):
- if self.isvalid():
+ if self.isValid():
if self.object.valeur == self.object.definition.defaut :
return "ast-green-dark-ball"
return "ast-green-ball"
from Extensions.i18n import tr
-class CONFIG_BASE(object):
+class configBase(object):
#-------------------------------
def __init__(self,appli,repIni):
else : self.name="editeur.ini"
self.rep_mat = None
self.repIni = repIni
+
+ if self.code == None : self.code=''
if sys.platform[0:5]=="linux" :
- self.rep_user = os.path.join(os.environ['HOME'],'.config/Eficas',appli.code)
+ self.rep_user = os.path.join(os.environ['HOME'],'.config/Eficas',self.code)
else :
- self.rep_user = os.path.join('C:/','.config/Eficas',appli.code)
+ self.rep_user = os.path.join('C:/','.config/Eficas',self.code)
self.setValeursParDefaut()
- self.lecture_fichier_ini_standard()
- self.lecture_fichier_ini_integrateur()
- self.lecture_fichier_ini_utilisateur()
+ if self.code != '' :
+ self.lecture_fichier_ini_standard()
+ self.lecture_fichier_ini_integrateur()
+ self.lecture_fichier_ini_utilisateur()
if self.boutonDsMenuBar:
self.closeAutreCommande = True
f.close()
#
+
Editeur de jdc
"""
- def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
- #----------------------------------------------------------------------------------------------------------#
+ #def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
+ def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 ):
+ #--------------------------------------------------------------------------------------------#
QWidget.__init__(self,None)
- self.i=0
self.setupUi(self)
+
self.inhibeSplitter=0
self.widgetOptionnel=None
self.fenetreCentraleAffichee=None
self.dejaDansPlieTout=False
self.afficheCommandesPliees = True
self.listeDesListesOuvertes=set()
+
self.appliEficas = appli
self.appli = appli #---- attendu par IHM
- self.vm = vm
+ #self.vm = vm
self.fichier = fichier
self.jdc = jdc
self.first = True
# ces attributs sont mis a jour par definitCode appelee par newEditor
self.code = self.appliEficas.maConfiguration.code
+ self.maConfiguration = self.appliEficas.maConfiguration
self.initSplitterSizes()
#self.afficheListesPliees=False
if self.code == "ASTER" or self.code == "monCode" : self.afficheListesPliees =True
if self.code == 'PSEN_N1' : self.afficheListesPliees = False
- self.maConfiguration=self.appliEficas.maConfiguration
self.closeAutreCommande=self.appliEficas.maConfiguration.closeAutreCommande
self.closeFrameRechercheCommande = self.appliEficas.maConfiguration.closeFrameRechercheCommande
self.closeArbre=self.appliEficas.maConfiguration.closeArbre
nameConf='configuration_'+self.code
configuration=__import__(nameConf)
self.maConfiguration = self.appliEficas.maConfiguration
- self.CONFIGStyle = self.appliEficas.CONFIGStyle
try:
self.maConfiguration.generator_module
if self.multi == False :
self.definitCode(code,ssCode)
if code==None: return
+ else :
+ OOOOOOOOOOO
self.suiteTelemac=False
if hasattr (self, 'maConfiguration') :
nameConf='configuration_'+self.code
configuration=__import__(nameConf)
self.maConfiguration = configuration.make_config(self,prefsCode.repIni)
- self.CONFIGStyle = None
- if hasattr(configuration,'make_config_style'):
- self.CONFIGStyle = configuration.make_config_style(self,prefsCode.repIni)
if hasattr (self,'maConfiguration') and self.maConfiguration.translatorFichier :
from Extensions import localisation
double=editor
else :
from .editor import JDCEditor
- editor = JDCEditor(self.appliEficas,fichier, jdc, self.myQtab,units=units,vm = self,include=include)
+ editor = JDCEditor(self.appliEficas,fichier, jdc, self.myQtab,units=units,include=include)
if double != None :
self.doubles[editor]=double
if editor.jdc: # le fichier est bien un jdc
try:
j=self.app.openJDC(file=file)
if err == "":
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
else:
txt=str(j.report())
assert txt == err,cdiff(err,txt)
try:
j=self.app.openJDC(file=file)
if err == "":
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
else:
txt=str(j.report())
assert txt == err,cdiff(err,txt)
from InterfaceTK import appli
def add_param(j,pos,nom,valeur):
- co=j.addentite("PARAMETRE",pos)
- co.set_nom(nom)
+ co=j.addEntite("PARAMETRE",pos)
+ co.setNom(nom)
co.set_valeur(valeur)
return co
def add_mcsimp(obj,nom,valeur):
mcs=obj.get_child(nom,restreint='oui')
if mcs is None:
- pos=obj.get_index_child(nom)
- mcs=obj.addentite(nom,pos)
+ pos=obj.getIndex_child(nom)
+ mcs=obj.addEntite(nom,pos)
mcs.set_valeur(mcs.eval_val(valeur))
return mcs
assert j.cr.get_mess_exception() == ""
if err == "":
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
else:
txt=str(j.report())
assert txt == err,cdiff(err,txt)
from InterfaceTK import appli
def add_param(j,pos,nom,valeur):
- co=j.addentite("PARAMETRE",pos)
- co.set_nom(nom)
+ co=j.addEntite("PARAMETRE",pos)
+ co.setNom(nom)
co.set_valeur(valeur)
return co
def add_mcsimp(obj,nom,valeur):
mcs=obj.get_child(nom,restreint='oui')
if mcs is None:
- pos=obj.get_index_child(nom)
- mcs=obj.addentite(nom,pos)
+ pos=obj.getIndex_child(nom)
+ mcs=obj.addEntite(nom,pos)
mcs.set_valeur(mcs.eval_val(valeur))
return mcs
assert j.cr.get_mess_exception() == ""
if err == "":
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
else:
txt=str(j.report())
assert txt == err,cdiff(err,txt)
from InterfaceTK import appli
def add_param(j,pos,nom,valeur):
- co=j.addentite("PARAMETRE",pos)
- co.set_nom(nom)
+ co=j.addEntite("PARAMETRE",pos)
+ co.setNom(nom)
co.set_valeur(valeur)
return co
def add_mcsimp(obj,nom,valeur):
mcs=obj.get_child(nom,restreint='oui')
if mcs is None:
- pos=obj.get_index_child(nom)
- mcs=obj.addentite(nom,pos)
+ pos=obj.getIndex_child(nom)
+ mcs=obj.addEntite(nom,pos)
mcs.set_valeur(mcs.eval_val(valeur))
return mcs
assert j.cr.get_mess_exception() == ""
if err == "":
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
else:
txt=str(j.report())
assert txt == err,cdiff(err,txt)
def op5_prod(FFT,**args):
if (FFT != None) :
- vale=FFT.get_child('FONCTION').get_valeur()
+ vale=FFT.get_child('FONCTION').getValeur()
if (AsType(vale) == concept ) : return concept
if (AsType(vale) == concept2) : return concept2
raise AsException("type de concept resultat non prevu")
from InterfaceTK import appli
def add_param(j,pos,nom,valeur):
- co=j.addentite("PARAMETRE",pos)
- co.set_nom(nom)
+ co=j.addEntite("PARAMETRE",pos)
+ co.setNom(nom)
co.set_valeur(valeur)
return co
def add_mcsimp(obj,nom,valeur):
mcs=obj.get_child(nom,restreint='oui')
if mcs is None:
- pos=obj.get_index_child(nom)
- mcs=obj.addentite(nom,pos)
+ pos=obj.getIndex_child(nom)
+ mcs=obj.addEntite(nom,pos)
mcs.set_valeur(mcs.eval_val(valeur))
return mcs
app=appli.STANDALONE(version='v9')
j=app.newJDC()
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
# parametres
pos=0
pos=pos+1
co=add_param(j,pos,"P4","[2,3,4]")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur("Pas trouve shellpanel")
# commande LIRE_MAILLAGE
pos=pos+1
- co=j.addentite("LIRE_MAILLAGE",pos)
- test,mess=co.nomme_sd("MAILLA2")
- mcs=co.addentite("UNITE")
+ co=j.addEntite("LIRE_MAILLAGE",pos)
+ test,mess=co.nommeSd("MAILLA2")
+ mcs=co.addEntite("UNITE")
valeur=mcs.eval_val("P4[1]")
test=mcs.set_valeur(valeur)
# formule
pos=pos+1
- co=j.addentite("FORMULE",pos)
+ co=j.addEntite("FORMULE",pos)
co.update_formule_python(("aaa","REEL","a+z","(a,z)"))
# commande LIRE_MAILLAGE
pos=pos+1
- ma=co=j.addentite("LIRE_MAILLAGE",pos)
- test,mess=co.nomme_sd("MAIL")
- mcs=co.addentite("UNITE")
+ ma=co=j.addEntite("LIRE_MAILLAGE",pos)
+ test,mess=co.nommeSd("MAIL")
+ mcs=co.addEntite("UNITE")
valeur,validite=mcs.eval_valeur("P3")
test=mcs.set_valeur(valeur)
#
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'LIRE_MAILLAGE', 'UNITE' --> uniquebasepanel")
# formule
pos=pos+1
- co=j.addentite("FORMULE",pos)
+ co=j.addEntite("FORMULE",pos)
co.update_formule_python(("az","REEL","aaaaa","(ae,inst)"))
# commande AFFE_MODELE
pos=pos+1
- co=j.addentite("AFFE_MODELE",pos)
+ co=j.addEntite("AFFE_MODELE",pos)
mcs=co.get_child("MAILLAGE")
valeur,validite=mcs.eval_valeur("MAIL")
assert valeur == ma.sd
test=mcs.set_valeur(valeur)
assert valeur == co["MAILLAGE"]
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[0].get_child("PHENOMENE")
valeur=mcs.eval_val_item('MECANIQUE')
assert valeur=='MECANIQUE',str(valeur)
assert mcf["MODELISATION"] == 'DIS_T'
mcs=add_mcsimp(mcf[0],"GROUP_MA",('RESSORT','eee',))
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[1].get_child("PHENOMENE")
mcs.set_valeur(mcs.eval_val_item('MECANIQUE'))
mcs=mcf[1].get_child("b_mecanique").get_child("MODELISATION")
mcs.set_valeur(mcs.eval_val_item('DIS_T'))
mcs=add_mcsimp(mcf[1],"GROUP_MA",'MASSES')
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[2].get_child("PHENOMENE")
mcs.set_valeur(mcs.eval_val_item('ACOUSTIQUE'))
mcs=mcf[2].get_child("b_acoustique").get_child("MODELISATION")
#mcs=add_mcsimp(mcf[2],"GROUP_NO",'GNP3,GNP5,GNP6,GNP7,GNP8,GNP9,GNP10,GNP11,GNP12')
mcs=add_mcsimp(mcf[2],"GROUP_NO","'GNP3','GNP5','GNP6','GNP7','GNP8','GNP9','GNP10','GNP11','GNP12'")
- co.nomme_sd("AFFE1")
+ co.nommeSd("AFFE1")
# commande AFFE_MODELE
pos=pos+1
- co=j.addentite("AFFE_MODELE",pos)
+ co=j.addEntite("AFFE_MODELE",pos)
mcs=co.get_child("MAILLAGE")
mcs.set_valeur(mcs.eval_val("MAIL"))
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[0].get_child("PHENOMENE")
valeur=mcs.eval_val_item('MECANIQUE')
test=mcs.set_valeur(valeur)
mcs.set_valeur(mcs.eval_val_item('DIS_T'))
mcs=add_mcsimp(mcf[0],"GROUP_MA",'RESSORT')
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[1].get_child("PHENOMENE")
mcs.set_valeur(mcs.eval_val_item('MECANIQUE'))
mcs=mcf[1].get_child("b_mecanique").get_child("MODELISATION")
mcs.set_valeur(mcs.eval_val_item('DIS_T'))
mcs=add_mcsimp(mcf[1],"GROUP_MA",'MASSES')
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[2].get_child("PHENOMENE")
mcs.set_valeur(mcs.eval_val_item('THERMIQUE'))
mcs=mcf[2].get_child("b_thermique").get_child("MODELISATION")
mcs.set_valeur(mcs.eval_val_item('COQUE'))
mcs=add_mcsimp(mcf[2],"TOUT",'OUI')
- co.nomme_sd("MOD")
+ co.nommeSd("MOD")
#CARA=AFFE_CARA_ELEM(MODELE=MOD,
# POUTRE=_F(GROUP_MA='MA',
# SECTION='CERCLE',
# CARA='R',
# VALE=(3.0,P6,),),);
pos=pos+1
- co=j.addentite("AFFE_CARA_ELEM",pos)
+ co=j.addEntite("AFFE_CARA_ELEM",pos)
mcs=co.get_child("MODELE")
mcs.set_valeur(mcs.eval_val("MOD"))
- mcf=co.addentite("POUTRE")
+ mcf=co.addEntite("POUTRE")
mcs=mcf[0].get_child("SECTION")
mcs.set_valeur(mcs.eval_val('CERCLE'))
assert mcf[0]["SECTION"] == 'CERCLE'
mcs.set_valeur(mcs.eval_val('R'))
mcs=mcf[0].get_child("b_cercle").get_child("b_constant").get_child("VALE")
mcs.set_valeur(mcs.eval_val('3.0,P6'))
- co.nomme_sd("CARA")
+ co.nommeSd("CARA")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
text=""" 'AFFE_MODELE', 'MAILLAGE' --> uniqueassdpanel
AFFE_MODELE', 'AFFE', 'GROUP_MA' --> plusieursbasepanel
'AFFE_MODELE', 'AFFE', 'PHENOMENE' --> uniqueintopanel
#F1=DEFI_FONCTION(NOM_PARA='DX',
# VALE=(5.0,3.0,P4[1],P3,),);
pos=pos+1
- co=j.addentite("DEFI_FONCTION",pos)
+ co=j.addEntite("DEFI_FONCTION",pos)
mcs=co.get_child("NOM_PARA")
mcs.set_valeur(mcs.eval_val("DX"))
- mcs=co.addentite("VALE")
+ mcs=co.addEntite("VALE")
mcs.set_valeur(mcs.eval_val("5.0,3.0,P4[1],P3"))
- co.nomme_sd("F1")
+ co.nommeSd("F1")
#F3=DEFI_FONCTION(NOM_PARA='DRX',
# VALE_C=(5.0,7.0,9.0,9.0,8.0,7.0,),);
pos=pos+1
- co=j.addentite("DEFI_FONCTION",pos)
+ co=j.addEntite("DEFI_FONCTION",pos)
mcs=co.get_child("NOM_PARA")
mcs.set_valeur(mcs.eval_val("DRX"))
- mcs=co.addentite("VALE_C")
+ mcs=co.addEntite("VALE_C")
mcs.set_valeur(mcs.eval_val("5.0,7.0,9.0,9.0,8.0,7.0"))
- co.nomme_sd("F3")
+ co.nommeSd("F3")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'DEFI_FONCTION', 'VALE' --> fonctionpanel ")
#MATER2=DEFI_MATERIAU(ELAS=_F(E=100000000000.0,
# NU=0.0,),
# DT_SIGM_EPSI=0.0,
# SY_T=50000000.0,),);
pos=pos+1
- co=j.addentite("DEFI_MATERIAU",pos)
- mcf=co.addentite("ELAS")
+ co=j.addEntite("DEFI_MATERIAU",pos)
+ mcf=co.addEntite("ELAS")
mcs=mcf[0].get_child("E")
mcs.set_valeur(mcs.eval_val("100000000000.0"))
mcs=mcf[0].get_child("NU")
mcs.set_valeur(mcs.eval_val("0.0"))
- mcf=co.addentite("ECRO_ASYM_LINE")
+ mcf=co.addEntite("ECRO_ASYM_LINE")
mcs=mcf[0].get_child("DC_SIGM_EPSI")
mcs.set_valeur(mcs.eval_val("0.0"))
mcs=mcf[0].get_child("DT_SIGM_EPSI")
mcs.set_valeur(mcs.eval_val("200000000.0"))
mcs=mcf[0].get_child("SY_T")
mcs.set_valeur(mcs.eval_val("50000000.0"))
- co.nomme_sd("MATER2")
+ co.nommeSd("MATER2")
#PS1=DEFI_PARA_SENSI(VALE=1.0,);
#PS2=DEFI_PARA_SENSI(VALE=1.0,);
#PS3=DEFI_PARA_SENSI(VALE=1.0,);
pos=pos+1
- co=j.addentite("DEFI_PARA_SENSI",pos)
+ co=j.addEntite("DEFI_PARA_SENSI",pos)
mcs=co.get_child("VALE")
mcs.set_valeur(mcs.eval_val("1.0"))
- co.nomme_sd("PS1")
+ co.nommeSd("PS1")
pos=pos+1
- co=j.addentite("DEFI_PARA_SENSI",pos)
+ co=j.addEntite("DEFI_PARA_SENSI",pos)
mcs=co.get_child("VALE")
mcs.set_valeur(mcs.eval_val("1.0"))
- co.nomme_sd("PS2")
+ co.nommeSd("PS2")
pos=pos+1
- co=j.addentite("DEFI_PARA_SENSI",pos)
+ co=j.addEntite("DEFI_PARA_SENSI",pos)
mcs=co.get_child("VALE")
mcs.set_valeur(mcs.eval_val("1.0"))
- co.nomme_sd("PS3")
+ co.nommeSd("PS3")
#CHMAT2=AFFE_MATERIAU(MAILLAGE=MAIL,
# AFFE=_F(TOUT='OUI',
# MATER=MATER2,),);
pos=pos+1
- co=j.addentite("AFFE_MATERIAU",pos)
+ co=j.addEntite("AFFE_MATERIAU",pos)
add_mcsimp(co,"MAILLAGE","MAIL")
mcf=co.get_child("AFFE")
add_mcsimp(mcf[0],"TOUT","OUI")
add_mcsimp(mcf[0],"MATER","MATER2")
- co.nomme_sd("CHMAT2")
+ co.nommeSd("CHMAT2")
#AAAZ=AFFE_CHAR_THER(MODELE=AFFE1,
# TEMP_IMPO=_F(TOUT='OUI',
# TEMP=0.0,),);
pos=pos+1
- co=j.addentite("AFFE_CHAR_THER",pos)
+ co=j.addEntite("AFFE_CHAR_THER",pos)
add_mcsimp(co,"MODELE","AFFE1")
- mcf=co.addentite("TEMP_IMPO")
+ mcf=co.addEntite("TEMP_IMPO")
add_mcsimp(mcf[0],"TOUT","OUI")
add_mcsimp(mcf[0],"TEMP","0.0")
- co.nomme_sd("AAAZ")
+ co.nommeSd("AAAZ")
#TH1=THER_LINEAIRE(MODELE=AFFE1,
# CHAM_MATER=CHMAT2,
# EXCIT=_F(CHARGE=AAAZ,),
# SENSIBILITE=(PS1,PS2,),);
pos=pos+1
- co=j.addentite("THER_LINEAIRE",pos)
+ co=j.addEntite("THER_LINEAIRE",pos)
add_mcsimp(co,"MODELE","AFFE1")
add_mcsimp(co,"CHAM_MATER","CHMAT2")
mcf=co.get_child("EXCIT")
add_mcsimp(mcf[0],"CHARGE","AAAZ")
add_mcsimp(co,"SENSIBILITE","PS1,PS2")
- co.nomme_sd("TH1")
+ co.nommeSd("TH1")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'THER_LINEAIRE', 'SENSIBILITE' --> plusieursassdpanel")
#ACA1=AFFE_CHAR_ACOU(MODELE=AFFE1,
# PRES_IMPO=_F(TOUT='OUI',
# PRES=('RI',3.0,3.0,),),);
pos=pos+1
- co=j.addentite("AFFE_CHAR_ACOU",pos)
+ co=j.addEntite("AFFE_CHAR_ACOU",pos)
add_mcsimp(co,"MODELE","AFFE1")
- mcf=co.addentite("PRES_IMPO")
+ mcf=co.addEntite("PRES_IMPO")
add_mcsimp(mcf[0],"TOUT","OUI")
add_mcsimp(mcf[0],"PRES","'RI',3.0,3.0")
- co.nomme_sd("ACA1")
+ co.nommeSd("ACA1")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'AFFE_CHAR_ACOU', 'PRES_IMPO', 'PRES' --> uniquecomppanel")
# 'AFFE_CHAR_ACOU', 'PRES_IMPO', 'PRES' --> uniquecomppanel
# MATR_ASSE=_F(MATRICE=CO('MAT1'),
# OPTION='RIGI_THER',),);
pos=pos+1
- co=j.addentite("MACRO_MATR_ASSE",pos)
+ co=j.addEntite("MACRO_MATR_ASSE",pos)
add_mcsimp(co,"MODELE","AFFE1")
mcs=co.get_child("NUME_DDL")
mcs.set_valeur_co('DDL1')
mcs.set_valeur_co('MAT1')
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'MACRO_MATR_ASSE', 'MATR_ASSE', 'MATRICE' --> uniquesdcopanel")
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
text1=app.get_text_JDC(j,'python')
file=os.path.join(prefs.INSTALLDIR,"Tests/testelem/az.comm")
app=appli.STANDALONE(version='v9')
j=app.newJDC()
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
#parametre
pos=0
pos=pos+1
co=add_param(j,pos,"P2","sin(P1)")
# formule
pos=pos+1
- co=j.addentite("FORMULE",pos)
+ co=j.addEntite("FORMULE",pos)
co.update_formule_python(("aaa","REEL","a+z","(a,z)"))
#parametre de formule
pos=pos+1
co=add_param(j,pos,"P3","aaa(P1,2.)")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","1.,2.,3.")
- co.nomme_sd("LI1")
+ co.nommeSd("LI1")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","sin(1.)")
- co.nomme_sd("LI2")
+ co.nommeSd("LI2")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","aaa(1.,2.)")
- co.nomme_sd("LI3")
+ co.nommeSd("LI3")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","sin(1.,2)")
- co.nomme_sd("LI4")
+ co.nommeSd("LI4")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","aaa(1.)")
- co.nomme_sd("LI5")
+ co.nommeSd("LI5")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","1,sin(1.),2")
- co.nomme_sd("LI6")
+ co.nommeSd("LI6")
expected="""DEBUT CR validation : SansNom
Etape : DEFI_LIST_REEL ligne : ...
co=OP1(traitement=mcf,WWWW='WWWW')
mcfact=co.etape['traitement']
self.assertEqual(mcfact['TYPE_RAFFINEMENT_LIBRE']['DERAFFINEMENT'] , None)
- dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste)
+ dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
self.assertEqual(dico['DERAFFINEMENT'] , None)
self.assertEqual(dico['RAFFINEMENT'] , None)
self.assertEqual(dico['WWWW'] , 'WWWW')
self.assertRaises(IndexError, mcfact.__getitem__, 'NITER')
mcfact=co.etape['trait'][0]
- dico=mcfact.cree_dict_valeurs(mcfact.mc_liste)
+ dico=mcfact.creeDictValeurs(mcfact.mc_liste)
self.assertEqual(dico['DERAFFINEMENT'] , None)
self.assertEqual(dico['RAFFINEMENT'] , None)
self.assertEqual(dico['WWWW'] , 'WWWW')
def test003(self):
co=MACR_BIDON(NOM_CHAM='ACCE',RESULTAT=_F(VAL2=3.4))
mcfact=co.etape['RESULTAT']
- self.assertEqual(co.etape.isvalid(), 0)
+ self.assertEqual(co.etape.isValid(), 0)
def test004(self):
mcf={'VVVV':'',
'NOM_MED_MAILLAGE_NP1':'',
}
co=OP1(traitement=mcf,WWWW="WWWW",trait={'N':1})
- val=co.etape.isvalid()
+ val=co.etape.isValid()
if not val:msg=co.etape.report()
else:msg=""
- self.assertEqual(co.etape.isvalid() , 1,msg=msg)
+ self.assertEqual(co.etape.isValid() , 1,msg=msg)
co=OP1(traitement=mcf,WWWW="WWWW")
- val=co.etape.isvalid()
+ val=co.etape.isValid()
if not val:msg=co.etape.report()
else:msg=""
- self.assertEqual(co.etape.isvalid() , 0,msg=msg)
+ self.assertEqual(co.etape.isValid() , 0,msg=msg)
co=OP1(traitement=mcf,WWWW="WW",trait={'N':1})
- val=co.etape.isvalid()
+ val=co.etape.isValid()
if not val:msg=co.etape.report()
else:msg=""
- self.assertEqual(co.etape.isvalid() , 0,msg=msg)
+ self.assertEqual(co.etape.isValid() , 0,msg=msg)
co=OP1(traitement=mcf,WWWW="WW",trait={'FFFF':'X'})
- val=co.etape.isvalid()
+ val=co.etape.isValid()
if not val:msg=co.etape.report()
else:msg=""
- self.assertEqual(co.etape.isvalid() , 1,msg=msg)
+ self.assertEqual(co.etape.isValid() , 1,msg=msg)
co=OP1(traitement=mcf,WWWW="WW",)
- val=co.etape.isvalid()
+ val=co.etape.isValid()
if not val:msg=co.etape.report()
else:msg=""
- self.assertEqual(co.etape.isvalid() , 1,msg=msg)
+ self.assertEqual(co.etape.isValid() , 1,msg=msg)
def test005(self):
OP1 = OPER(nom='OP1',op=1, sd_prod=concept,
)
co=OP1()
msg=co.etape.report()
- self.assertEqual(co.etape.isvalid() , 1,msg=msg)
+ self.assertEqual(co.etape.isValid() , 1,msg=msg)
co=OP1(MASS={},MODE=1)
msg=co.etape.report()
- self.assertEqual(co.etape.isvalid() , 1,msg=msg)
+ self.assertEqual(co.etape.isValid() , 1,msg=msg)
co=OP1(MASS=({},{}),MODE=1,XX=1)
msg=co.etape.report()
- self.assertEqual(co.etape.isvalid() , 1,msg=msg)
+ self.assertEqual(co.etape.isValid() , 1,msg=msg)
co=OP1(MASS=({'Y':1},{}),MODE=1,XX=1,YY=1)
msg=co.etape.report()
- self.assertEqual(co.etape.isvalid() , 1,msg=msg)
+ self.assertEqual(co.etape.isValid() , 1,msg=msg)
co=OP1(MASS=({'Y':1,'Z':{'T':1}},{}),MODE=1,XX=1,YY=1,ZZ=1)
msg=co.etape.report()
- self.assertEqual(co.etape.isvalid() , 1,msg=msg)
+ self.assertEqual(co.etape.isValid() , 1,msg=msg)
)
for valeur,valid in liste:
o=cata(valeur,'mcf',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
def test032(self):
cata=FACT(max=3,a=SIMP(typ='I',statut='o'),)
)
for valeur,valid in liste:
o=cata(valeur,'mcf',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
)
mcfact=cata({},'mcf',None)
valeur_attendue={'ZORGLUB':'OOO','TOTO':'AAA'}
- dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste)
- #dico=mcfact.cree_dict_valeurs(mcfact.mc_liste)
+ dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
+ #dico=mcfact.creeDictValeurs(mcfact.mc_liste)
self.assertEqual(dico , valeur_attendue)
self.assertEqual(mcfact[0].get_mocle('TOTO') , 'AAA')
self.assertEqual(mcfact[0].get_mocle('ZORGLUB') , 'OOO')
)
mcfact=cata({},'mcf',None)
valeur_attendue={'ZORGLUB':'OOO'}
- dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste)
- #dico=mcfact.cree_dict_valeurs(mcfact.mc_liste)
+ dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
+ #dico=mcfact.creeDictValeurs(mcfact.mc_liste)
self.assertEqual(dico , valeur_attendue)
self.assertEqual(mcfact[0].get_mocle('ZORGLUB') , 'OOO')
)
mcfact=cata({'ZORGLUB':'ZZZ'},'mcf',None)
valeur_attendue={'ZORGLUB':'ZZZ', 'TOTO':'AAA'}
- dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste)
+ dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
self.assertEqual(dico , valeur_attendue)
self.assertEqual(mcfact[0].get_mocle('ZORGLUB') , 'ZZZ')
self.assertEqual(mcfact['TOTO'] , 'AAA')
)
mcfact=cata({},'mcf',None)
valeur_attendue={'ZORGLUB':'OOO','TOTO':None}
- dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste)
+ dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
self.assertEqual(dico , valeur_attendue)
self.assertEqual(mcfact[0].get_mocle('TOTO') , None)
- self.assertEqual(mcfact[0].get_child('ZORGLUB').get_valeur() , 'OOO')
- self.assertEqual(mcfact[0].get_child('b_unit1').get_child('TOTO').get_valeur() , None)
+ self.assertEqual(mcfact[0].get_child('ZORGLUB').getValeur() , 'OOO')
+ self.assertEqual(mcfact[0].get_child('b_unit1').get_child('TOTO').getValeur() , None)
self.assertEqual(mcfact['TOTO'] , None)
def test005(self):
),
)
mcfact=cata({},'mcf',None)
- dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste)
+ dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
self.assertNotEqual(dico["TOTO"] , None)
def test010(self):
)
mcfact=cata({'TOTO' : 'BBB'},'mcf',None)
valeur_attendue={'UNITE':25, 'ZORGLUB':'OOO','TOTO':'BBB'}
- dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste)
+ dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
self.assertEqual(dico , valeur_attendue)
def test011(self):
'TOTO2': 'AAA',
'TOTO4': 'AAA', 'UNITE4': 25,
}
- dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste)
+ dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
self.assertEqual(dico , valeur_attendue)
- self.assertEqual(mcfact[0].get_child('TATA').get_valeur() , 'AAA')
- self.assertEqual(mcfact[0].get_child('TITI').get_valeur() , 'AAA')
- self.assertEqual(mcfact[0].get_child('TUTU').get_valeur() , 'AAA')
- self.assertEqual(mcfact[0].get_child('TOTO').get_valeur() , 'BBB')
+ self.assertEqual(mcfact[0].get_child('TATA').getValeur() , 'AAA')
+ self.assertEqual(mcfact[0].get_child('TITI').getValeur() , 'AAA')
+ self.assertEqual(mcfact[0].get_child('TUTU').getValeur() , 'AAA')
+ self.assertEqual(mcfact[0].get_child('TOTO').getValeur() , 'BBB')
self.assertEqual(mcfact['TITI'] , 'AAA')
self.assertEqual(mcfact['TUTU'] , 'AAA')
self.assertEqual(mcfact['TATA'] , 'AAA')
self.assertRaises(IndexError, mcfact[0].get_mocle, 'UNITE2')
self.assertRaises(IndexError, mcfact[0].get_mocle, 'UNITE3')
- self.assertEqual(mcfact[0].get_child('b_unit4').get_child('TOTO4').get_valeur(),'AAA')
- self.assertEqual(mcfact[0].get_child('b_unit4').get_valeur(),{'TOTO4': 'AAA', 'UNITE4': 25})
+ self.assertEqual(mcfact[0].get_child('b_unit4').get_child('TOTO4').getValeur(),'AAA')
+ self.assertEqual(mcfact[0].get_child('b_unit4').getValeur(),{'TOTO4': 'AAA', 'UNITE4': 25})
def add_param(j,pos,nom,valeur):
- co=j.addentite("PARAMETRE",pos)
- co.set_nom(nom)
+ co=j.addEntite("PARAMETRE",pos)
+ co.setNom(nom)
co.set_valeur(valeur)
return co
def add_mcsimp(obj,nom,valeur):
mcs=obj.get_child(nom,restreint='oui')
if mcs is None:
- pos=obj.get_index_child(nom)
- mcs=obj.addentite(nom,pos)
+ pos=obj.getIndex_child(nom)
+ mcs=obj.addEntite(nom,pos)
mcs.set_valeur(mcs.eval_val(valeur))
return mcs
def test001(self):
"""Test comploader"""
- composants=comploader.charger_composants()
+ composants=comploader.chargerComposants()
itemtype=comploader.gettreeitem({'a':1})
assert itemtype is Objecttreeitem.ObjectTreeItem
file=os.path.join(prefs.INSTALLDIR,"Tests/testelem/az.comm")
j=app.openJDC(file=file)
item=app.create_item(j)
- assert item.isvalid(),item.report()
+ assert item.isValid(),item.report()
# on commente la commande LIRE_MAILLAGE
- commands=item.GetSubList()
+ commands=item.getSubList()
for it in commands:
if it.nom == "LIRE_MAILLAGE" and it.sd.nom == "MAIL":break
pos=commands.index(it)
- cco=it.get_objet_commentarise()
- commands=item.GetSubList()
- commands[pos].uncomment()
- commands=item.GetSubList()
+ cco=it.getObjetCommentarise()
+ commands=item.getSubList()
+ commands[pos].unComment()
+ commands=item.getSubList()
# on reaffecte l'objet MAIL
for it in commands:
if it.nom in ("AFFE_MODELE","AFFE_MATERIAU") :
- for mc in it.GetSubList():
+ for mc in it.getSubList():
if mc.nom == "MAILLAGE":
valeur,validite=mc.eval_valeur("MAIL")
test = mc.set_valeur(valeur)
#from Editeur import appli
def add_param(j,pos,nom,valeur):
- co=j.addentite("PARAMETRE",pos)
- co.set_nom(nom)
+ co=j.addEntite("PARAMETRE",pos)
+ co.setNom(nom)
co.set_valeur(valeur)
return co
def add_mcsimp(obj,nom,valeur):
mcs=obj.get_child(nom,restreint='oui')
if mcs is None:
- pos=obj.get_index_child(nom)
- mcs=obj.addentite(nom,pos)
+ pos=obj.getIndex_child(nom)
+ mcs=obj.addEntite(nom,pos)
mcs.set_valeur(mcs.eval_val(valeur))
return mcs
j=app.newJDC()
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
co=add_param(j,1,"P1",None)
x=co.valeur or "coucou"
assert x == "coucou"
cr=str(j.report())
assert cr == expected, cr + "!=" + expected
co=j.etapes[1]
- mcs=co.addentite("INFO")
+ mcs=co.addEntite("INFO")
cr=app.get_text_JDC(j,'python')
expected="""
FIN();
"""
assert cr == expected, cr + "!=" + expected
- co=j.addentite("LIRE_MAILLAGE",2)
- test,mess=co.nomme_sd("MA2")
+ co=j.addEntite("LIRE_MAILLAGE",2)
+ test,mess=co.nommeSd("MA2")
assert test == 1
cr=app.get_text_JDC(j,'python')
app=appli.STANDALONE(version=version)
j=app.newJDC()
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
# parametres
pos=0
pos=pos+1
co=add_param(j,pos,"P4","[2,3,4]")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur("Pas trouve shellpanel")
# commande LIRE_MAILLAGE
pos=pos+1
- co=j.addentite("LIRE_MAILLAGE",pos)
- test,mess=co.nomme_sd("MAILLA2")
- mcs=co.addentite("UNITE")
+ co=j.addEntite("LIRE_MAILLAGE",pos)
+ test,mess=co.nommeSd("MAILLA2")
+ mcs=co.addEntite("UNITE")
valeur=mcs.eval_val("P4[1]")
test=mcs.set_valeur(valeur)
# formule
pos=pos+1
- co=j.addentite("FORMULE",pos)
+ co=j.addEntite("FORMULE",pos)
co.update_formule_python(("aaa","REEL","a+z","(a,z)"))
# commande LIRE_MAILLAGE
pos=pos+1
- ma=co=j.addentite("LIRE_MAILLAGE",pos)
- test,mess=co.nomme_sd("MAIL")
- mcs=co.addentite("UNITE")
+ ma=co=j.addEntite("LIRE_MAILLAGE",pos)
+ test,mess=co.nommeSd("MAIL")
+ mcs=co.addEntite("UNITE")
valeur,validite=mcs.eval_valeur("P3")
test=mcs.set_valeur(valeur)
#
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'LIRE_MAILLAGE', 'UNITE' --> uniquebasepanel")
# formule
pos=pos+1
- co=j.addentite("FORMULE",pos)
+ co=j.addEntite("FORMULE",pos)
co.update_formule_python(("az","REEL","aaaaa","(ae,inst)"))
# commande AFFE_MODELE
pos=pos+1
- co=j.addentite("AFFE_MODELE",pos)
+ co=j.addEntite("AFFE_MODELE",pos)
mcs=co.get_child("MAILLAGE")
valeur,validite=mcs.eval_valeur("MAIL")
assert valeur == ma.sd
test=mcs.set_valeur(valeur)
assert valeur == co["MAILLAGE"]
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[0].get_child("PHENOMENE")
valeur=mcs.eval_val_item('MECANIQUE')
assert valeur=='MECANIQUE',str(valeur)
assert mcf["MODELISATION"] == 'DIS_T'
mcs=add_mcsimp(mcf[0],"GROUP_MA",('RESSORT','eee',))
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[1].get_child("PHENOMENE")
mcs.set_valeur(mcs.eval_val_item('MECANIQUE'))
mcs=mcf[1].get_child("b_mecanique").get_child("MODELISATION")
mcs.set_valeur(mcs.eval_val_item('DIS_T'))
mcs=add_mcsimp(mcf[1],"GROUP_MA",'MASSES')
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[2].get_child("PHENOMENE")
mcs.set_valeur(mcs.eval_val_item('ACOUSTIQUE'))
mcs=mcf[2].get_child("b_acoustique").get_child("MODELISATION")
#mcs=add_mcsimp(mcf[2],"GROUP_NO",'GNP3,GNP5,GNP6,GNP7,GNP8,GNP9,GNP10,GNP11,GNP12')
mcs=add_mcsimp(mcf[2],"GROUP_NO","'GNP3','GNP5','GNP6','GNP7','GNP8','GNP9','GNP10','GNP11','GNP12'")
- co.nomme_sd("AFFE1")
+ co.nommeSd("AFFE1")
# commande AFFE_MODELE
pos=pos+1
- co=j.addentite("AFFE_MODELE",pos)
+ co=j.addEntite("AFFE_MODELE",pos)
mcs=co.get_child("MAILLAGE")
mcs.set_valeur(mcs.eval_val("MAIL"))
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[0].get_child("PHENOMENE")
valeur=mcs.eval_val_item('MECANIQUE')
test=mcs.set_valeur(valeur)
mcs.set_valeur(mcs.eval_val_item('DIS_T'))
mcs=add_mcsimp(mcf[0],"GROUP_MA",'RESSORT')
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[1].get_child("PHENOMENE")
mcs.set_valeur(mcs.eval_val_item('MECANIQUE'))
mcs=mcf[1].get_child("b_mecanique").get_child("MODELISATION")
mcs.set_valeur(mcs.eval_val_item('DIS_T'))
mcs=add_mcsimp(mcf[1],"GROUP_MA",'MASSES')
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[2].get_child("PHENOMENE")
mcs.set_valeur(mcs.eval_val_item('THERMIQUE'))
mcs=mcf[2].get_child("b_thermique").get_child("MODELISATION")
mcs.set_valeur(mcs.eval_val_item('COQUE'))
mcs=add_mcsimp(mcf[2],"TOUT",'OUI')
- co.nomme_sd("MOD")
+ co.nommeSd("MOD")
#CARA=AFFE_CARA_ELEM(MODELE=MOD,
# POUTRE=_F(GROUP_MA='MA',
# SECTION='CERCLE',
# CARA='R',
# VALE=(3.0,P6,),),);
pos=pos+1
- co=j.addentite("AFFE_CARA_ELEM",pos)
+ co=j.addEntite("AFFE_CARA_ELEM",pos)
mcs=co.get_child("MODELE")
mcs.set_valeur(mcs.eval_val("MOD"))
- mcf=co.addentite("POUTRE")
+ mcf=co.addEntite("POUTRE")
mcs=mcf[0].get_child("SECTION")
mcs.set_valeur(mcs.eval_val('CERCLE'))
assert mcf[0]["SECTION"] == 'CERCLE'
mcs.set_valeur(mcs.eval_val('R'))
mcs=mcf[0].get_child("b_cercle").get_child("b_constant").get_child("VALE")
mcs.set_valeur(mcs.eval_val('3.0,P6'))
- co.nomme_sd("CARA")
+ co.nommeSd("CARA")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
text=""" 'AFFE_MODELE', 'MAILLAGE' --> uniqueassdpanel
AFFE_MODELE', 'AFFE', 'GROUP_MA' --> plusieursbasepanel
'AFFE_MODELE', 'AFFE', 'PHENOMENE' --> uniqueintopanel
#F1=DEFI_FONCTION(NOM_PARA='DX',
# VALE=(5.0,3.0,P4[1],P3,),);
pos=pos+1
- co=j.addentite("DEFI_FONCTION",pos)
+ co=j.addEntite("DEFI_FONCTION",pos)
mcs=co.get_child("NOM_PARA")
mcs.set_valeur(mcs.eval_val("DX"))
- mcs=co.addentite("VALE")
+ mcs=co.addEntite("VALE")
mcs.set_valeur(mcs.eval_val("5.0,3.0,P4[1],P3"))
- co.nomme_sd("F1")
+ co.nommeSd("F1")
#F3=DEFI_FONCTION(NOM_PARA='DRX',
# VALE_C=(5.0,7.0,9.0,9.0,8.0,7.0,),);
pos=pos+1
- co=j.addentite("DEFI_FONCTION",pos)
+ co=j.addEntite("DEFI_FONCTION",pos)
mcs=co.get_child("NOM_PARA")
mcs.set_valeur(mcs.eval_val("DRX"))
- mcs=co.addentite("VALE_C")
+ mcs=co.addEntite("VALE_C")
mcs.set_valeur(mcs.eval_val("5.0,7.0,9.0,9.0,8.0,7.0"))
- co.nomme_sd("F3")
+ co.nommeSd("F3")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'DEFI_FONCTION', 'VALE' --> fonctionpanel ")
#MATER2=DEFI_MATERIAU(ELAS=_F(E=100000000000.0,
# NU=0.0,),
# DT_SIGM_EPSI=0.0,
# SY_T=50000000.0,),);
pos=pos+1
- co=j.addentite("DEFI_MATERIAU",pos)
- mcf=co.addentite("ELAS")
+ co=j.addEntite("DEFI_MATERIAU",pos)
+ mcf=co.addEntite("ELAS")
mcs=mcf[0].get_child("E")
mcs.set_valeur(mcs.eval_val("100000000000.0"))
mcs=mcf[0].get_child("NU")
mcs.set_valeur(mcs.eval_val("0.0"))
- mcf=co.addentite("ECRO_ASYM_LINE")
+ mcf=co.addEntite("ECRO_ASYM_LINE")
mcs=mcf[0].get_child("DC_SIGM_EPSI")
mcs.set_valeur(mcs.eval_val("0.0"))
mcs=mcf[0].get_child("DT_SIGM_EPSI")
mcs.set_valeur(mcs.eval_val("200000000.0"))
mcs=mcf[0].get_child("SY_T")
mcs.set_valeur(mcs.eval_val("50000000.0"))
- co.nomme_sd("MATER2")
+ co.nommeSd("MATER2")
#PS1=DEFI_PARA_SENSI(VALE=1.0,);
#PS2=DEFI_PARA_SENSI(VALE=1.0,);
#PS3=DEFI_PARA_SENSI(VALE=1.0,);
pos=pos+1
- co=j.addentite("DEFI_PARA_SENSI",pos)
+ co=j.addEntite("DEFI_PARA_SENSI",pos)
mcs=co.get_child("VALE")
mcs.set_valeur(mcs.eval_val("1.0"))
- co.nomme_sd("PS1")
+ co.nommeSd("PS1")
pos=pos+1
- co=j.addentite("DEFI_PARA_SENSI",pos)
+ co=j.addEntite("DEFI_PARA_SENSI",pos)
mcs=co.get_child("VALE")
mcs.set_valeur(mcs.eval_val("1.0"))
- co.nomme_sd("PS2")
+ co.nommeSd("PS2")
pos=pos+1
- co=j.addentite("DEFI_PARA_SENSI",pos)
+ co=j.addEntite("DEFI_PARA_SENSI",pos)
mcs=co.get_child("VALE")
mcs.set_valeur(mcs.eval_val("1.0"))
- co.nomme_sd("PS3")
+ co.nommeSd("PS3")
#CHMAT2=AFFE_MATERIAU(MAILLAGE=MAIL,
# AFFE=_F(TOUT='OUI',
# MATER=MATER2,),);
pos=pos+1
- co=j.addentite("AFFE_MATERIAU",pos)
+ co=j.addEntite("AFFE_MATERIAU",pos)
add_mcsimp(co,"MAILLAGE","MAIL")
mcf=co.get_child("AFFE")
add_mcsimp(mcf[0],"TOUT","OUI")
add_mcsimp(mcf[0],"MATER","MATER2")
- co.nomme_sd("CHMAT2")
+ co.nommeSd("CHMAT2")
#AAAZ=AFFE_CHAR_THER(MODELE=AFFE1,
# TEMP_IMPO=_F(TOUT='OUI',
# TEMP=0.0,),);
pos=pos+1
- co=j.addentite("AFFE_CHAR_THER",pos)
+ co=j.addEntite("AFFE_CHAR_THER",pos)
add_mcsimp(co,"MODELE","AFFE1")
- mcf=co.addentite("TEMP_IMPO")
+ mcf=co.addEntite("TEMP_IMPO")
add_mcsimp(mcf[0],"TOUT","OUI")
add_mcsimp(mcf[0],"TEMP","0.0")
- co.nomme_sd("AAAZ")
+ co.nommeSd("AAAZ")
#TH1=THER_LINEAIRE(MODELE=AFFE1,
# CHAM_MATER=CHMAT2,
# EXCIT=_F(CHARGE=AAAZ,),
# SENSIBILITE=(PS1,PS2,),);
pos=pos+1
- co=j.addentite("THER_LINEAIRE",pos)
+ co=j.addEntite("THER_LINEAIRE",pos)
add_mcsimp(co,"MODELE","AFFE1")
add_mcsimp(co,"CHAM_MATER","CHMAT2")
mcf=co.get_child("EXCIT")
add_mcsimp(mcf[0],"CHARGE","AAAZ")
add_mcsimp(co,"SENSIBILITE","PS1,PS2")
- co.nomme_sd("TH1")
+ co.nommeSd("TH1")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'THER_LINEAIRE', 'SENSIBILITE' --> plusieursassdpanel")
#ACA1=AFFE_CHAR_ACOU(MODELE=AFFE1,
# PRES_IMPO=_F(TOUT='OUI',
# PRES=('RI',3.0,3.0,),),);
pos=pos+1
- co=j.addentite("AFFE_CHAR_ACOU",pos)
+ co=j.addEntite("AFFE_CHAR_ACOU",pos)
add_mcsimp(co,"MODELE","AFFE1")
- mcf=co.addentite("PRES_IMPO")
+ mcf=co.addEntite("PRES_IMPO")
add_mcsimp(mcf[0],"TOUT","OUI")
add_mcsimp(mcf[0],"PRES","'RI',3.0,3.0")
- co.nomme_sd("ACA1")
+ co.nommeSd("ACA1")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'AFFE_CHAR_ACOU', 'PRES_IMPO', 'PRES' --> uniquecomppanel")
# 'AFFE_CHAR_ACOU', 'PRES_IMPO', 'PRES' --> uniquecomppanel
# MATR_ASSE=_F(MATRICE=CO('MAT1'),
# OPTION='RIGI_THER',),);
pos=pos+1
- co=j.addentite("MACRO_MATR_ASSE",pos)
+ co=j.addEntite("MACRO_MATR_ASSE",pos)
add_mcsimp(co,"MODELE","AFFE1")
mcs=co.get_child("NUME_DDL")
mcs.set_valeur_co('DDL1')
mcs.set_valeur_co('MAT1')
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'MACRO_MATR_ASSE', 'MATR_ASSE', 'MATRICE' --> uniquesdcopanel")
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
text1=app.get_text_JDC(j,'python')
file=os.path.join(prefs.INSTALLDIR,"Tests/testelem/az.comm")
app=appli.STANDALONE(version=version)
j=app.newJDC()
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
#parametre
pos=0
pos=pos+1
co=add_param(j,pos,"P2","sin(P1)")
# formule
pos=pos+1
- co=j.addentite("FORMULE",pos)
+ co=j.addEntite("FORMULE",pos)
co.update_formule_python(("aaa","REEL","a+z","(a,z)"))
#parametre de formule
pos=pos+1
co=add_param(j,pos,"P3","aaa(P1,2.)")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","1.,2.,3.")
- co.nomme_sd("LI1")
+ co.nommeSd("LI1")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","sin(1.)")
- co.nomme_sd("LI2")
+ co.nommeSd("LI2")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","aaa(1.,2.)")
- co.nomme_sd("LI3")
+ co.nommeSd("LI3")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","sin(1.,2)")
- co.nomme_sd("LI4")
+ co.nommeSd("LI4")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","aaa(1.)")
- co.nomme_sd("LI5")
+ co.nommeSd("LI5")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","1,sin(1.),2")
- co.nomme_sd("LI6")
+ co.nommeSd("LI6")
expected="""DEBUT CR validation : SansNom
Etape : DEFI_LIST_REEL ligne : ...
from Accas import AsException
def add_param(j,pos,nom,valeur):
- co=j.addentite("PARAMETRE",pos)
- co.set_nom(nom)
+ co=j.addEntite("PARAMETRE",pos)
+ co.setNom(nom)
co.set_valeur(valeur)
return co
def add_mcsimp(obj,nom,valeur):
mcs=obj.get_child(nom,restreint='oui')
if mcs is None:
- pos=obj.get_index_child(nom)
- mcs=obj.addentite(nom,pos)
+ pos=obj.getIndex_child(nom)
+ mcs=obj.addEntite(nom,pos)
mcs.set_valeur(mcs.eval_val(valeur))
return mcs
app=appli.STANDALONE(version=version)
file=os.path.join(prefs.INSTALLDIR,"Tests/testelem/az.comm")
j=app.openJDC(file=file)
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
# on commente la commande LIRE_MAILLAGE
for co in j.etapes:
if co.nom == "LIRE_MAILLAGE" and co.sd.nom == "MAIL":break
- cco=co.get_objet_commentarise(format=app.format_fichier.get())
+ cco=co.getObjetCommentarise(format=app.format_fichier.get())
# on decommente la commande LIRE_MAILLAGE
- commande,nom = cco.uncomment()
+ commande,nom = cco.unComment()
# on reaffecte l'objet MAIL
for co in j.etapes:
if co.nom in ("AFFE_MODELE","AFFE_MATERIAU") :
app=appli.STANDALONE(version=version)
file=os.path.join(prefs.INSTALLDIR,"Tests/testelem/az.comm")
j=app.openJDC(file=file)
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
# on commente la commande MACRO_MATR_ASSE
for co in j.etapes:
if co.nom == "MACRO_MATR_ASSE" :break
- cco=co.get_objet_commentarise(format=app.format_fichier.get())
+ cco=co.getObjetCommentarise(format=app.format_fichier.get())
# on decommente la commande MACRO_MATR_ASSE
- commande,nom = cco.uncomment()
- assert j.isvalid(),j.report()
+ commande,nom = cco.unComment()
+ assert j.isValid(),j.report()
def test003(self):
""" Test de commentarisation/decommentarisation de commandes dans fichier az.comm"""
FIN()
"""
j=app.openTXT(text)
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
# on commente la commande LIRE_MAILLAGE
co=j.etapes[1]
- cco=co.get_objet_commentarise(format=app.format_fichier.get())
- co=j.addentite("LIRE_MAILLAGE",2)
- test,mess=co.nomme_sd("MA")
+ cco=co.getObjetCommentarise(format=app.format_fichier.get())
+ co=j.addEntite("LIRE_MAILLAGE",2)
+ test,mess=co.nommeSd("MA")
# on decommente la commande LIRE_MAILLAGE
- commande,nom = cco.uncomment()
+ commande,nom = cco.unComment()
expected="""DEBUT CR validation : TEXT
Etape : LIRE_MAILLAGE ligne : ...
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
j=app.openTXT(text)
# on commente la commande LIRE_MAILLAGE
co=j.etapes[1]
- cco=co.get_objet_commentarise(format=app.format_fichier.get())
+ cco=co.getObjetCommentarise(format=app.format_fichier.get())
# on commente la commande AFFE_MODELE
co=j.etapes[2]
- cco2=co.get_objet_commentarise(format=app.format_fichier.get())
+ cco2=co.getObjetCommentarise(format=app.format_fichier.get())
# on decommente la commande AFFE_MODELE
- commande,nom = cco2.uncomment()
+ commande,nom = cco2.unComment()
assert commande["MAILLAGE"] == None
def test005(self):
j=app.openTXT(text)
# on commente la commande AFFE_MODELE
co=j.etapes[2]
- cco2=co.get_objet_commentarise(format=app.format_fichier.get())
+ cco2=co.getObjetCommentarise(format=app.format_fichier.get())
# on commente la commande LIRE_MAILLAGE
co=j.etapes[1]
- cco=co.get_objet_commentarise(format=app.format_fichier.get())
+ cco=co.getObjetCommentarise(format=app.format_fichier.get())
# on decommente la commande AFFE_MODELE
- self.assertRaises(AsException, cco2.uncomment, )
+ self.assertRaises(AsException, cco2.unComment, )
from Accas import AsException
def add_param(j,pos,nom,valeur):
- co=j.addentite("PARAMETRE",pos)
- co.set_nom(nom)
+ co=j.addEntite("PARAMETRE",pos)
+ co.setNom(nom)
co.set_valeur(valeur)
return co
def add_mcsimp(obj,nom,valeur):
mcs=obj.get_child(nom,restreint='oui')
if mcs is None:
- pos=obj.get_index_child(nom)
- mcs=obj.addentite(nom,pos)
+ pos=obj.getIndex_child(nom)
+ mcs=obj.addEntite(nom,pos)
mcs.set_valeur(mcs.eval_val(valeur))
return mcs
#print file
app=appli.STANDALONE(version=version)
j=app.openJDC(file=file)
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
text1=app.get_text_JDC(j,'python')
f=open(file)
def test06(self):
""" Test fonction sd_prod
- Test sur un mot-clé simple d'un mot-clé facteur : mcf.get_child(mcs).get_valeur()
+ Test sur un mot-clé simple d'un mot-clé facteur : mcf.get_child(mcs).getValeur()
"""
co2=OP1(a=1)
co1=OP5(FFT={'FONCTION':co2})
valeur=(2,0,1)
co1=OP10(a=mylist(valeur))
msg="erreur sur le test " +'\n'+str(co1.etape.report())
- self.assertEqual(co1.etape.isvalid(),0,msg=msg)
+ self.assertEqual(co1.etape.isValid(),0,msg=msg)
co1.etape.supprime()
def futuretest13(self):
valeur=(2,0,1)
co1=OP10(a=mylist(valeur))
msg="erreur sur le test " +'\n'+str(co1.etape.report())
- self.assertEqual(co1.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co1.etape.isValid(),1,msg=msg)
co1.etape.supprime()
def futuretest14(self):
valeur=(2,0,1)
co1=OP10(a=mylist(valeur))
msg="erreur sur le test " +'\n'+str(co1.etape.report())
- self.assertEqual(co1.etape.isvalid(),0,msg=msg)
+ self.assertEqual(co1.etape.isValid(),0,msg=msg)
co1.etape.supprime()
def test15(self):
co1=OP7(FILTRE="coucou")
cr=co1.etape.report()
msg="erreur sur le test " +'\n'+str(cr)
- self.assertEqual(co1.etape.isvalid(),0,msg=msg)
+ self.assertEqual(co1.etape.isValid(),0,msg=msg)
co1.etape.supprime()
def test16(self):
valeur=(2,0,1)
co1=OP10(a=valeur)
msg="erreur sur le test " +'\n'+str(co1.etape.report())
- self.assertEqual(co1.etape.isvalid(),0,msg=msg)
+ self.assertEqual(co1.etape.isValid(),0,msg=msg)
co1.etape.supprime()
expected="""MA=LIRE_MAILLAGE()
"""
- txt = parseur_python.PARSEUR_PYTHON(text).get_texte(appli())
+ txt = parseur_python.PARSEUR_PYTHON(text).getTexte(appli())
assert txt == expected, cdiff(expected,txt)
def test02(self):
MB=LIRE_MAILLAGE()
"""
- txt = parseur_python.PARSEUR_PYTHON(text).get_texte(appli())
+ txt = parseur_python.PARSEUR_PYTHON(text).getTexte(appli())
assert txt == expected, cdiff(expected,txt)
def test03(self):
MB=LIRE_MAILLAGE()
'''
- txt = parseur_python.PARSEUR_PYTHON(text).get_texte(appli())
+ txt = parseur_python.PARSEUR_PYTHON(text).getTexte(appli())
assert txt == expected, cdiff(expected,txt)
def test04(self):
FIN();
'''
- txt = parseur_python.PARSEUR_PYTHON(text).get_texte(appli())
+ txt = parseur_python.PARSEUR_PYTHON(text).getTexte(appli())
assert txt == expected, cdiff(expected,txt)
)
co1=OP10(a=1,c="TABLEAU",b=_F(d='rr'))
msg=co1.etape.report()
- self.assertEqual(co1.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co1.etape.isValid(),1,msg=msg)
def test002(self):
""" Test position=global_jdc
co1=OP10(a=1,c="TABLEAU",)
co2=OP11(b=_F(d='rr'))
msg=co1.etape.report()
- self.assertEqual(co1.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co1.etape.isValid(),1,msg=msg)
msg=co2.etape.report()
- self.assertEqual(co2.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co2.etape.isValid(),1,msg=msg)
def test003(self):
""" Test position=global_jdc
co3=OP11()
co4=OP12(b=_F(d='rr'))
msg=co1.etape.report()
- self.assertEqual(co1.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co1.etape.isValid(),1,msg=msg)
msg=co2.etape.report()
- self.assertEqual(co2.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co2.etape.isValid(),1,msg=msg)
msg=co3.etape.report()
- self.assertEqual(co3.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co3.etape.isValid(),1,msg=msg)
msg=co4.etape.report()
- self.assertEqual(co4.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co4.etape.isValid(),1,msg=msg)
def futuretest004(self):
""" Test position = global
)
co1=OP10(a=1,b=_F(c="TABLEAU"),g=_F(d='rr'))
msg=msg0+str(co1.etape.report())
- self.assertEqual(co1.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co1.etape.isValid(),1,msg=msg)
co2=OP10(a=1,b=_F(c="TABLEAU"),xx=_F(d='rr'))
msg=msg0+str(co2.etape.report())
- self.assertEqual(co2.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co2.etape.isValid(),1,msg=msg)
def test005(self):
""" Test position = global
)
co1=OP10(a=1,g=_F(c="TABLEAU"),d='rr')
msg=co1.etape.report()
- self.assertEqual(co1.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co1.etape.isValid(),1,msg=msg)
def test006(self):
""" Test position = global
)
co1=OP10(a=1,g=_F(a=1),d='rr')
msg=co1.etape.report()
- self.assertEqual(co1.etape.isvalid(),0,msg=msg)
+ self.assertEqual(co1.etape.isValid(),0,msg=msg)
def test007(self):
""" Test position = global
)
co1=OP10(b=_F(d='rr'))
msg=co1.etape.report()
- self.assertEqual(co1.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co1.etape.isValid(),1,msg=msg)
def test008(self):
""" Test position = global
)
co1=OP10(d='rr')
msg=co1.etape.report()
- self.assertEqual(co1.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co1.etape.isValid(),1,msg=msg)
def test009(self):
""" Test position = global
)
co1=OP10(d='rr')
msg=co1.etape.report()
- self.assertEqual(co1.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co1.etape.isValid(),1,msg=msg)
def test010(self):
""" Test position = global
)
co1=OP10(g=_F(a=1),d='rr')
msg=co1.etape.report()
- self.assertEqual(co1.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co1.etape.isValid(),1,msg=msg)
def test011(self):
""" Test position = global
)
co1=OP10(d='rr')
msg=co1.etape.report()
- self.assertEqual(co1.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co1.etape.isValid(),1,msg=msg)
def test012(self):
""" Test position = global
)
co1=OP10(d='rr')
msg=co1.etape.report()
- self.assertEqual(co1.etape.isvalid(),0,msg=msg)
+ self.assertEqual(co1.etape.isValid(),0,msg=msg)
co2=OP10(g=_F(c="TABLEAU"),d='rr')
msg=co2.etape.report()
- self.assertEqual(co2.etape.isvalid(),1,msg=msg)
+ self.assertEqual(co2.etape.isValid(),1,msg=msg)
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
# Chaines
def test040(self):
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test041(self):
cata=SIMP(typ='TXM',statut='o',max=3)
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test042(self):
cata=SIMP(typ='TXM',statut='o',into=("toto","titi"),max=3)
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test043(self):
cata=SIMP(typ='TXM',statut='o',into=("toto","titi"),min=2,max=3)
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
# Reels
def test020(self):
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test021(self):
cata=SIMP(typ='R',statut='o',min=2,max=4)
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test022(self):
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test023(self):
cata=SIMP(typ='R',statut='o',val_min=2,val_max=4,max=4)
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test024(self):
cata=SIMP(typ='R',statut='o')
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
# Entiers
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test031(self):
cata=SIMP(typ='I',statut='o',into=(1,5,8),max=4)
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
# Complexes
def test010(self):
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test011(self):
cata=SIMP(typ='C',statut='o',max=3)
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test012(self):
cata=SIMP(typ='C',statut='o')
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test013(self):
cata=SIMP(typ=('R',maillage),statut='o')
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,
+ self.assertEqual(o.isValid(),valid,
"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test014(self):
cata=SIMP(typ=geom,statut='o')
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,
+ self.assertEqual(o.isValid(),valid,
"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test015(self):
cata=SIMP(typ=assd,statut='o')
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,
+ self.assertEqual(o.isValid(),valid,
"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test016(self):
class LongStr:
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,
+ self.assertEqual(o.isValid(),valid,
"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ if valid: self.assertEqual(o.getValeur(),valeur)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
msg="erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())
- self.assertEqual(o.isvalid(),valid,msg=msg)
+ self.assertEqual(o.isValid(),valid,msg=msg)
def test002(self):
cata=SIMP(statut='f',typ='TXM',defaut="d")
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
msg="erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())
- self.assertEqual(o.isvalid(),valid,msg=msg)
+ self.assertEqual(o.isValid(),valid,msg=msg)
def test003(self):
cata=SIMP(statut='o',typ='R',max=3)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
msg="erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())
- self.assertEqual(o.isvalid(),valid,msg=msg)
+ self.assertEqual(o.isValid(),valid,msg=msg)
def test004(self):
cata=SIMP(statut='f',typ=('R','I'),max=5)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
msg="erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())
- self.assertEqual(o.isvalid(),valid,msg=msg)
+ self.assertEqual(o.isValid(),valid,msg=msg)
def _test005(self):
cata=SIMP(statut='f',typ='I',max=5)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
msg="erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())
- self.assertEqual(o.isvalid(),valid,msg=msg)
+ self.assertEqual(o.isValid(),valid,msg=msg)
o=cata(valeur,'mcs',None)
#print o.val,o.valeur
msg="erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())
- self.assertEqual(o.isvalid(),valid,msg=msg)
+ self.assertEqual(o.isValid(),valid,msg=msg)
def test004(self):
cata=SIMP(typ='C',statut='o',max=10)
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
def test005(self):
t=Variable('t',None)
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
- if valid: self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.isValid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()))
+ if valid: self.assertEqual(o.getValeur(),valeur)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
msg=None
- if valid != o.isvalid() :
+ if valid != o.isValid() :
if not valid:
msg="erreur : le mot cle devrait etre invalide. valeur = %s, valid = %s " % (valeur,valid)
else:
msg="erreur : le mot cle devrait etre valide. valeur = %s, valid = %s " % (valeur,valid) + '\n' + str(o.report())
- self.assertEqual(o.isvalid(),valid,msg)
+ self.assertEqual(o.isValid(),valid,msg)
if valid:
- self.assertEqual(o.get_valeur(),valeur)
+ self.assertEqual(o.getValeur(),valeur)
def test001(self):
cata=SIMP(typ='TXM',validators=LongStr(3,5))
from InterfaceTK import appli
def add_param(j,pos,nom,valeur):
- co=j.addentite("PARAMETRE",pos)
- co.set_nom(nom)
+ co=j.addEntite("PARAMETRE",pos)
+ co.setNom(nom)
co.set_valeur(valeur)
return co
def add_mcsimp(obj,nom,valeur):
mcs=obj.get_child(nom,restreint='oui')
if mcs is None:
- pos=obj.get_index_child(nom)
- mcs=obj.addentite(nom,pos)
+ pos=obj.getIndex_child(nom)
+ mcs=obj.addEntite(nom,pos)
mcs.set_valeur(mcs.eval_val(valeur))
return mcs
app=appli.STANDALONE(version='v7')
j=app.newJDC()
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
# parametres
pos=0
pos=pos+1
co=add_param(j,pos,"P4","[2,3,4]")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur("Pas trouve shellpanel")
# commande LIRE_MAILLAGE
pos=pos+1
- co=j.addentite("LIRE_MAILLAGE",pos)
- test,mess=co.nomme_sd("MAILLA2")
- mcs=co.addentite("UNITE")
+ co=j.addEntite("LIRE_MAILLAGE",pos)
+ test,mess=co.nommeSd("MAILLA2")
+ mcs=co.addEntite("UNITE")
valeur=mcs.eval_val("P4[1]")
test=mcs.set_valeur(valeur)
# formule
pos=pos+1
- co=j.addentite("FORMULE",pos)
+ co=j.addEntite("FORMULE",pos)
co.update_formule_python(("aaa","REEL","a+z","(a,z)"))
# commande LIRE_MAILLAGE
pos=pos+1
- ma=co=j.addentite("LIRE_MAILLAGE",pos)
- test,mess=co.nomme_sd("MAIL")
- mcs=co.addentite("UNITE")
+ ma=co=j.addEntite("LIRE_MAILLAGE",pos)
+ test,mess=co.nommeSd("MAIL")
+ mcs=co.addEntite("UNITE")
valeur,validite=mcs.eval_valeur("P3")
test=mcs.set_valeur(valeur)
#
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'LIRE_MAILLAGE', 'UNITE' --> uniquebasepanel")
# formule
pos=pos+1
- co=j.addentite("FORMULE",pos)
+ co=j.addEntite("FORMULE",pos)
co.update_formule_python(("az","REEL","aaaaa","(ae,inst)"))
# commande AFFE_MODELE
pos=pos+1
- co=j.addentite("AFFE_MODELE",pos)
+ co=j.addEntite("AFFE_MODELE",pos)
mcs=co.get_child("MAILLAGE")
valeur,validite=mcs.eval_valeur("MAIL")
assert valeur == ma.sd
test=mcs.set_valeur(valeur)
assert valeur == co["MAILLAGE"]
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[0].get_child("PHENOMENE")
valeur=mcs.eval_val_item('MECANIQUE')
assert valeur=='MECANIQUE',str(valeur)
assert mcf["MODELISATION"] == 'DIS_T'
mcs=add_mcsimp(mcf[0],"GROUP_MA",('RESSORT','eee',))
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[1].get_child("PHENOMENE")
mcs.set_valeur(mcs.eval_val_item('MECANIQUE'))
mcs=mcf[1].get_child("b_mecanique").get_child("MODELISATION")
mcs.set_valeur(mcs.eval_val_item('DIS_T'))
mcs=add_mcsimp(mcf[1],"GROUP_MA",'MASSES')
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[2].get_child("PHENOMENE")
mcs.set_valeur(mcs.eval_val_item('ACOUSTIQUE'))
mcs=mcf[2].get_child("b_acoustique").get_child("MODELISATION")
#mcs=add_mcsimp(mcf[2],"GROUP_NO",'GNP3,GNP5,GNP6,GNP7,GNP8,GNP9,GNP10,GNP11,GNP12')
mcs=add_mcsimp(mcf[2],"GROUP_NO","'GNP3','GNP5','GNP6','GNP7','GNP8','GNP9','GNP10','GNP11','GNP12'")
- co.nomme_sd("AFFE1")
+ co.nommeSd("AFFE1")
# commande AFFE_MODELE
pos=pos+1
- co=j.addentite("AFFE_MODELE",pos)
+ co=j.addEntite("AFFE_MODELE",pos)
mcs=co.get_child("MAILLAGE")
mcs.set_valeur(mcs.eval_val("MAIL"))
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[0].get_child("PHENOMENE")
valeur=mcs.eval_val_item('MECANIQUE')
test=mcs.set_valeur(valeur)
mcs.set_valeur(mcs.eval_val_item('DIS_T'))
mcs=add_mcsimp(mcf[0],"GROUP_MA",'RESSORT')
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[1].get_child("PHENOMENE")
mcs.set_valeur(mcs.eval_val_item('MECANIQUE'))
mcs=mcf[1].get_child("b_mecanique").get_child("MODELISATION")
mcs.set_valeur(mcs.eval_val_item('DIS_T'))
mcs=add_mcsimp(mcf[1],"GROUP_MA",'MASSES')
- mcf=co.addentite("AFFE")
+ mcf=co.addEntite("AFFE")
mcs=mcf[2].get_child("PHENOMENE")
mcs.set_valeur(mcs.eval_val_item('THERMIQUE'))
mcs=mcf[2].get_child("b_thermique").get_child("MODELISATION")
mcs.set_valeur(mcs.eval_val_item('COQUE'))
mcs=add_mcsimp(mcf[2],"TOUT",'OUI')
- co.nomme_sd("MOD")
+ co.nommeSd("MOD")
#CARA=AFFE_CARA_ELEM(MODELE=MOD,
# POUTRE=_F(GROUP_MA='MA',
# SECTION='CERCLE',
# CARA='R',
# VALE=(3.0,P6,),),);
pos=pos+1
- co=j.addentite("AFFE_CARA_ELEM",pos)
+ co=j.addEntite("AFFE_CARA_ELEM",pos)
mcs=co.get_child("MODELE")
mcs.set_valeur(mcs.eval_val("MOD"))
- mcf=co.addentite("POUTRE")
+ mcf=co.addEntite("POUTRE")
mcs=mcf[0].get_child("SECTION")
mcs.set_valeur(mcs.eval_val('CERCLE'))
assert mcf[0]["SECTION"] == 'CERCLE'
mcs.set_valeur(mcs.eval_val('R'))
mcs=mcf[0].get_child("b_cercle").get_child("b_constant").get_child("VALE")
mcs.set_valeur(mcs.eval_val('3.0,P6'))
- co.nomme_sd("CARA")
+ co.nommeSd("CARA")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
text=""" 'AFFE_MODELE', 'MAILLAGE' --> uniqueassdpanel
AFFE_MODELE', 'AFFE', 'GROUP_MA' --> plusieursbasepanel
'AFFE_MODELE', 'AFFE', 'PHENOMENE' --> uniqueintopanel
#F1=DEFI_FONCTION(NOM_PARA='DX',
# VALE=(5.0,3.0,P4[1],P3,),);
pos=pos+1
- co=j.addentite("DEFI_FONCTION",pos)
+ co=j.addEntite("DEFI_FONCTION",pos)
mcs=co.get_child("NOM_PARA")
mcs.set_valeur(mcs.eval_val("DX"))
- mcs=co.addentite("VALE")
+ mcs=co.addEntite("VALE")
mcs.set_valeur(mcs.eval_val("5.0,3.0,P4[1],P3"))
- co.nomme_sd("F1")
+ co.nommeSd("F1")
#F3=DEFI_FONCTION(NOM_PARA='DRX',
# VALE_C=(5.0,7.0,9.0,9.0,8.0,7.0,),);
pos=pos+1
- co=j.addentite("DEFI_FONCTION",pos)
+ co=j.addEntite("DEFI_FONCTION",pos)
mcs=co.get_child("NOM_PARA")
mcs.set_valeur(mcs.eval_val("DRX"))
- mcs=co.addentite("VALE_C")
+ mcs=co.addEntite("VALE_C")
mcs.set_valeur(mcs.eval_val("5.0,7.0,9.0,9.0,8.0,7.0"))
- co.nomme_sd("F3")
+ co.nommeSd("F3")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'DEFI_FONCTION', 'VALE' --> fonctionpanel ")
#MATER2=DEFI_MATERIAU(ELAS=_F(E=100000000000.0,
# NU=0.0,),
# DT_SIGM_EPSI=0.0,
# SY_T=50000000.0,),);
pos=pos+1
- co=j.addentite("DEFI_MATERIAU",pos)
- mcf=co.addentite("ELAS")
+ co=j.addEntite("DEFI_MATERIAU",pos)
+ mcf=co.addEntite("ELAS")
mcs=mcf[0].get_child("E")
mcs.set_valeur(mcs.eval_val("100000000000.0"))
mcs=mcf[0].get_child("NU")
mcs.set_valeur(mcs.eval_val("0.0"))
- mcf=co.addentite("ECRO_ASYM_LINE")
+ mcf=co.addEntite("ECRO_ASYM_LINE")
mcs=mcf[0].get_child("DC_SIGM_EPSI")
mcs.set_valeur(mcs.eval_val("0.0"))
mcs=mcf[0].get_child("DT_SIGM_EPSI")
mcs.set_valeur(mcs.eval_val("200000000.0"))
mcs=mcf[0].get_child("SY_T")
mcs.set_valeur(mcs.eval_val("50000000.0"))
- co.nomme_sd("MATER2")
+ co.nommeSd("MATER2")
#PS1=DEFI_PARA_SENSI(VALE=1.0,);
#PS2=DEFI_PARA_SENSI(VALE=1.0,);
#PS3=DEFI_PARA_SENSI(VALE=1.0,);
pos=pos+1
- co=j.addentite("DEFI_PARA_SENSI",pos)
+ co=j.addEntite("DEFI_PARA_SENSI",pos)
mcs=co.get_child("VALE")
mcs.set_valeur(mcs.eval_val("1.0"))
- co.nomme_sd("PS1")
+ co.nommeSd("PS1")
pos=pos+1
- co=j.addentite("DEFI_PARA_SENSI",pos)
+ co=j.addEntite("DEFI_PARA_SENSI",pos)
mcs=co.get_child("VALE")
mcs.set_valeur(mcs.eval_val("1.0"))
- co.nomme_sd("PS2")
+ co.nommeSd("PS2")
pos=pos+1
- co=j.addentite("DEFI_PARA_SENSI",pos)
+ co=j.addEntite("DEFI_PARA_SENSI",pos)
mcs=co.get_child("VALE")
mcs.set_valeur(mcs.eval_val("1.0"))
- co.nomme_sd("PS3")
+ co.nommeSd("PS3")
#CHMAT2=AFFE_MATERIAU(MAILLAGE=MAIL,
# AFFE=_F(TOUT='OUI',
# MATER=MATER2,),);
pos=pos+1
- co=j.addentite("AFFE_MATERIAU",pos)
+ co=j.addEntite("AFFE_MATERIAU",pos)
add_mcsimp(co,"MAILLAGE","MAIL")
mcf=co.get_child("AFFE")
add_mcsimp(mcf[0],"TOUT","OUI")
add_mcsimp(mcf[0],"MATER","MATER2")
- co.nomme_sd("CHMAT2")
+ co.nommeSd("CHMAT2")
#AAAZ=AFFE_CHAR_THER(MODELE=AFFE1,
# TEMP_IMPO=_F(TOUT='OUI',
# TEMP=0.0,),);
pos=pos+1
- co=j.addentite("AFFE_CHAR_THER",pos)
+ co=j.addEntite("AFFE_CHAR_THER",pos)
add_mcsimp(co,"MODELE","AFFE1")
- mcf=co.addentite("TEMP_IMPO")
+ mcf=co.addEntite("TEMP_IMPO")
add_mcsimp(mcf[0],"TOUT","OUI")
add_mcsimp(mcf[0],"TEMP","0.0")
- co.nomme_sd("AAAZ")
+ co.nommeSd("AAAZ")
#TH1=THER_LINEAIRE(MODELE=AFFE1,
# CHAM_MATER=CHMAT2,
# EXCIT=_F(CHARGE=AAAZ,),
# SENSIBILITE=(PS1,PS2,),);
pos=pos+1
- co=j.addentite("THER_LINEAIRE",pos)
+ co=j.addEntite("THER_LINEAIRE",pos)
add_mcsimp(co,"MODELE","AFFE1")
add_mcsimp(co,"CHAM_MATER","CHMAT2")
mcf=co.get_child("EXCIT")
add_mcsimp(mcf[0],"CHARGE","AAAZ")
add_mcsimp(co,"SENSIBILITE","PS1,PS2")
- co.nomme_sd("TH1")
+ co.nommeSd("TH1")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'THER_LINEAIRE', 'SENSIBILITE' --> plusieursassdpanel")
#ACA1=AFFE_CHAR_ACOU(MODELE=AFFE1,
# PRES_IMPO=_F(TOUT='OUI',
# PRES=('RI',3.0,3.0,),),);
pos=pos+1
- co=j.addentite("AFFE_CHAR_ACOU",pos)
+ co=j.addEntite("AFFE_CHAR_ACOU",pos)
add_mcsimp(co,"MODELE","AFFE1")
- mcf=co.addentite("PRES_IMPO")
+ mcf=co.addEntite("PRES_IMPO")
add_mcsimp(mcf[0],"TOUT","OUI")
add_mcsimp(mcf[0],"PRES","'RI',3.0,3.0")
- co.nomme_sd("ACA1")
+ co.nommeSd("ACA1")
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'AFFE_CHAR_ACOU', 'PRES_IMPO', 'PRES' --> uniquecomppanel")
# 'AFFE_CHAR_ACOU', 'PRES_IMPO', 'PRES' --> uniquecomppanel
# MATR_ASSE=_F(MATRICE=CO('MAT1'),
# OPTION='RIGI_THER',),);
pos=pos+1
- co=j.addentite("MACRO_MATR_ASSE",pos)
+ co=j.addEntite("MACRO_MATR_ASSE",pos)
add_mcsimp(co,"MODELE","AFFE1")
mcs=co.get_child("NUME_DDL")
mcs.set_valeur_co('DDL1')
mcs.set_valeur_co('MAT1')
# commentaire
pos=pos+1
- co=j.addentite("COMMENTAIRE",pos)
+ co=j.addEntite("COMMENTAIRE",pos)
co.set_valeur(" 'MACRO_MATR_ASSE', 'MATR_ASSE', 'MATRICE' --> uniquesdcopanel")
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
text1=app.get_text_JDC(j,'python')
file=os.path.join(prefs.INSTALLDIR,"Tests/testelem/az.comm")
app=appli.STANDALONE(version='v7')
j=app.newJDC()
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
#parametre
pos=0
pos=pos+1
co=add_param(j,pos,"P2","sin(P1)")
# formule
pos=pos+1
- co=j.addentite("FORMULE",pos)
+ co=j.addEntite("FORMULE",pos)
co.update_formule_python(("aaa","REEL","a+z","(a,z)"))
#parametre de formule
pos=pos+1
co=add_param(j,pos,"P3","aaa(P1,2.)")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","1.,2.,3.")
- co.nomme_sd("LI1")
+ co.nommeSd("LI1")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","sin(1.)")
- co.nomme_sd("LI2")
+ co.nommeSd("LI2")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","aaa(1.,2.)")
- co.nomme_sd("LI3")
+ co.nommeSd("LI3")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","sin(1.,2)")
- co.nomme_sd("LI4")
+ co.nommeSd("LI4")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","aaa(1.)")
- co.nomme_sd("LI5")
+ co.nommeSd("LI5")
#commande defi_list_reel
pos=pos+1
- co=j.addentite("DEFI_LIST_REEL",pos)
+ co=j.addEntite("DEFI_LIST_REEL",pos)
add_mcsimp(co,"VALE","1,sin(1.),2")
- co.nomme_sd("LI6")
+ co.nommeSd("LI6")
expected="""DEBUT CR validation : SansNom
Etape : DEFI_LIST_REEL ligne : ...
def delete_node(panel):
panel.node.delete()
-def uncomment_command(panel):
+def unComment_command(panel):
panel.bouton_unc.invoke()
root.update()
panel=jdcdisplay.panel_courant
init_common(root,jdcdisplay)
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
jdctree=jdcdisplay.tree.tree.children[0]
panel=select_child("DEBUT",jdctree)
panel=select_node(command)
command.collapse()
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
init_common(root,jdcdisplay)
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
jdctree=jdcdisplay.tree.tree.children[0]
panel=select_child("DEBUT",jdctree)
panel=select_node(command)
panel=nomme_concept("MO",panel)
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
init_common(root,jdcdisplay)
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
jdctree=jdcdisplay.tree.tree.children[0]
panel=select_child("DEBUT",jdctree)
panel=select_node(command)
panel=nomme_concept("MA",panel)
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
panel=select_child("MACRO_MATR_ASSE",jdctree)
panel=comment_command(panel)
#decommentariser commande MACRO_MATR_ASSE
- panel=uncomment_command(panel)
+ panel=unComment_command(panel)
#creation commande commentée
panel=create_command("LIRE_MAILLAGE",panel)
panel=comment_command(panel)
panel=change_commandcomm("mm=LIRE_MAILLAGE(INFO=2,UNITE=21)",panel)
- panel=uncomment_command(panel)
+ panel=unComment_command(panel)
panel=select_child("DEFI_FONCTION",jdctree)
delete_node(panel)
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
def delete_node(panel):
panel.node.delete()
-def uncomment_command(panel):
+def unComment_command(panel):
panel.bouton_unc.invoke()
root.update()
panel=jdcdisplay.panel_courant
init_common(root,jdcdisplay)
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
jdctree=jdcdisplay.tree.tree.children[0]
panel=select_child("DEBUT",jdctree)
panel=select_node(command)
command.collapse()
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
init_common(root,jdcdisplay)
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
jdctree=jdcdisplay.tree.tree.children[0]
panel=select_child("DEBUT",jdctree)
panel=select_node(command)
panel=nomme_concept("MO",panel)
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
panel=select_child("MACRO_MATR_ASSE",jdctree)
panel=comment_command(panel)
#decommentariser commande MACRO_MATR_ASSE
- panel=uncomment_command(panel)
+ panel=unComment_command(panel)
#creation commande commentée
panel=create_command("LIRE_MAILLAGE",panel)
panel=comment_command(panel)
panel=change_commandcomm("mm=LIRE_MAILLAGE(INFO=2,UNITE=21)",panel)
- panel=uncomment_command(panel)
+ panel=unComment_command(panel)
panel=select_child("DEFI_FONCTION",jdctree)
delete_node(panel)
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
def delete_node(panel):
panel.node.delete()
-def uncomment_command(panel):
+def unComment_command(panel):
panel.bouton_unc.invoke()
root.update()
panel=jdcdisplay.panel_courant
init_common(root,jdcdisplay)
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
jdctree=jdcdisplay.tree.tree.children[0]
panel=select_child("DEBUT",jdctree)
panel=select_node(command)
command.collapse()
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
init_common(root,jdcdisplay)
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
jdctree=jdcdisplay.tree.tree.children[0]
panel=select_child("DEBUT",jdctree)
panel=select_node(command)
panel=nomme_concept("MO",panel)
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
init_common(root,jdcdisplay)
# commande DEBUT
- co=j.addentite("DEBUT",0)
+ co=j.addEntite("DEBUT",0)
# commande FIN
- co=j.addentite("FIN",1)
+ co=j.addEntite("FIN",1)
jdctree=jdcdisplay.tree.tree.children[0]
panel=select_child("DEBUT",jdctree)
panel=select_node(command)
panel=nomme_concept("MA",panel)
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
panel=select_child("MACRO_MATR_ASSE",jdctree)
panel=comment_command(panel)
#decommentariser commande MACRO_MATR_ASSE
- panel=uncomment_command(panel)
+ panel=unComment_command(panel)
#creation commande commentée
panel=create_command("LIRE_MAILLAGE",panel)
panel=comment_command(panel)
panel=change_commandcomm("mm=LIRE_MAILLAGE(INFO=2,UNITE=21)",panel)
- panel=uncomment_command(panel)
+ panel=unComment_command(panel)
panel=select_child("DEFI_FONCTION",jdctree)
delete_node(panel)
- assert j.isvalid(),j.report()
+ assert j.isValid(),j.report()
def valid_child(self):
""" Cette methode teste la validite des mots cles de l'etape """
for child in self.mc_liste:
- if not child.isvalid():
+ if not child.isValid():
return 0
return 1
valid = 0
return valid
- def get_valid(self):
+ def getValid(self):
if hasattr(self, 'valid'):
return self.valid
else:
return None
def set_valid(self, valid):
- old_valid = self.get_valid()
+ old_valid = self.getValid()
self.valid = valid
self.state = 'unchanged'
if not old_valid or old_valid != self.valid:
- self.init_modif_up()
+ self.initModifUp()
- def isvalid(self, sd='oui', cr='non'):
+ def isValid(self, sd='oui', cr='non'):
"""
Methode pour verifier la validite de l'objet ETAPE. Cette methode
peut etre appelee selon plusieurs modes en fonction de la valeur
"""
if CONTEXT.debug:
- print(("ETAPE.isvalid ", self.nom))
+ print(("ETAPE.isValid ", self.nom))
if self.state == 'unchanged':
return self.valid
else:
"""
sd_prod = self.definition.sd_prod
if type(sd_prod) == types.FunctionType: # Type de concept retourne calcule
- d = self.cree_dict_valeurs(self.mc_liste)
+ d = self.creeDictValeurs(self.mc_liste)
try:
sd_prod = sd_prod(*(), **d)
except:
fin='End Command : ' + tr(self.nom))
self.state = 'modified'
try:
- self.isvalid(cr='oui')
+ self.isValid(cr='oui')
except AsException as e:
if CONTEXT.debug:
traceback.print_exc()
self.cr.debut = "BEGIN validation report : " + self.nom
self.cr.fin = "END validation report :" + self.nom
for e in self.etapes:
- if e.isactif():
+ if e.isActif():
self.cr.add(e.report())
self.state = 'modified'
- self.isvalid(cr='oui')
+ self.isValid(cr='oui')
return self.cr
- def isvalid(self, cr='non'):
+ def isValid(self, cr='non'):
"""
Methode booleenne qui retourne 0 si le JDC est invalide, 1 sinon
"""
valid = 0
if valid:
for e in self.etapes:
- if not e.isactif():
+ if not e.isActif():
continue
- if not e.isvalid():
+ if not e.isValid():
valid = 0
break
self.state = "unchanged"
"""
"""
- def isvalid(self, sd='oui', cr='non'):
+ def isValid(self, sd='oui', cr='non'):
"""
Methode pour verifier la validite de l'objet ETAPE. Cette methode
peut etre appelee selon plusieurs modes en fonction de la valeur
"""
if CONTEXT.debug:
- print(("ETAPE.isvalid ", self.nom))
+ print(("ETAPE.isValid ", self.nom))
if self.state == 'unchanged':
return self.valid
else:
# Si la macro comprend des etapes internes, on teste leur validite
for e in self.etapes:
- if not e.isvalid():
+ if not e.isValid():
valid = 0
break
self.typret = None
if type(sd_prod) == types.FunctionType:
# Type de concept retourne calcule
- d = self.cree_dict_valeurs(self.mc_liste)
+ d = self.creeDictValeurs(self.mc_liste)
try:
# la sd_prod d'une macro a l'objet lui meme en premier argument
# contrairement a une ETAPE ou PROC_ETAPE
txt_nat = u"Bloc :"
- def isvalid(self, sd='oui', cr='non'):
+ def isValid(self, sd='oui', cr='non'):
"""
Methode pour verifier la validite du MCBLOC. Cette methode
peut etre appelee selon plusieurs modes en fonction de la valeur
else:
old_valid = None
for child in self.mc_liste:
- if not child.isvalid():
+ if not child.isValid():
valid = 0
break
# Apres avoir verifie la validite de tous les sous-objets, on verifie
self.valid = valid
self.state = 'unchanged'
if not old_valid or old_valid != self.valid:
- self.init_modif_up()
+ self.initModifUp()
return self.valid
# defini dans les classes derivees
self.txt_nat = ''
- def init_modif_up(self):
+ def initModifUp(self):
"""
Propage l'etat modifie au parent s'il existe et n'est pas l'objet
lui-meme
self.cr.add(child.report())
self.state = 'modified'
try:
- self.isvalid(cr='oui')
+ self.isValid(cr='oui')
except AsException as e:
if CONTEXT.debug:
traceback.print_exc()
txt_nat = "Mot cle Facteur :"
- def isvalid(self, sd='oui', cr='non'):
+ def isValid(self, sd='oui', cr='non'):
"""
Methode pour verifier la validite du MCFACT. Cette methode
peut etre appelee selon plusieurs modes en fonction de la valeur
else:
old_valid = None
for child in self.mc_liste:
- if not child.isvalid():
+ if not child.isValid():
valid = 0
break
# Apres avoir verifie la validite de tous les sous-objets, on verifie
self.valid = valid
self.state = 'unchanged'
if not old_valid or old_valid != self.valid:
- self.init_modif_up()
+ self.initModifUp()
return self.valid
CR = N_CR.CR
txt_nat = "Mot cle Facteur Multiple :"
- def isvalid(self, cr='non'):
+ def isValid(self, cr='non'):
"""
Methode pour verifier la validite du MCList. Cette methode
peut etre appelee selon plusieurs modes en fonction de la valeur
num = 0
for i in self.data:
num = num + 1
- if not i.isvalid():
+ if not i.isValid():
valid = 0
if cr == 'oui' and len(self) > 1:
self.cr.fatal( "L'occurrence numero %d du mot-cle facteur : %s n'est pas valide" % (num, self.nom))
fin="Fin Mot-cle facteur : " + tr(self.nom))
try:
- self.isvalid(cr='oui')
+ self.isValid(cr='oui')
except AsException as e:
if CONTEXT.debug:
traceback.print_exc()
self.cardProto = CardProtocol(
"card", min=self.definition.min, max=self.definition.max)
- def get_valid(self):
+ def getValid(self):
if hasattr(self, 'valid'):
return self.valid
else:
return None
def set_valid(self, valid):
- old_valid = self.get_valid()
+ old_valid = self.getValid()
self.valid = valid
self.state = 'unchanged'
if not old_valid or old_valid != self.valid:
- self.init_modif_up()
+ self.initModifUp()
- def isvalid(self, cr='non'):
+ def isValid(self, cr='non'):
"""
Cette methode retourne un indicateur de validite de l'objet de type MCSIMP
valid = 1
v = self.valeur
# verification presence
- if self.isoblig() and (v == None or v == "" ):
+ if self.isOblig() and (v == None or v == "" ):
if cr == 'oui':
self.cr.fatal( "Mandatory keyword : %s has no value" % tr(self.nom))
valid = 0
# Pour tenir compte des Tuples
if hasattr(self.definition.type[0],'ntuple') :
try :
- if not (type(lval[0]) is tuple) : lval=(lval,)
+ if (not (type(lval[0]) is tuple)) and (not (type(lval[0]) is list)) : lval=(lval,)
except :
pass
-
if lval is None:
valid = 0
if cr == 'oui':
self.set_valid(valid)
return self.valid
- def isoblig(self):
+ def isOblig(self):
""" indique si le mot-cle est obligatoire
"""
return self.definition.statut == 'o'
- def init_modif_up(self):
+ def initModifUp(self):
"""
Propage l'etat modifie au parent s'il existe et n'est l'objet
lui-meme
self.cr.fin = "End Simple Keyword: " + tr(self.nom)
self.state = 'modified'
try:
- self.isvalid(cr='oui')
+ self.isValid(cr='oui')
except AsException as e:
if CONTEXT.debug:
traceback.print_exc()
de ETAPE par heritage.
"""
- def isvalid(self, sd='oui', cr='non'):
+ def isValid(self, sd='oui', cr='non'):
"""
Methode pour verifier la validite de l'objet PROC_ETAPE. Cette methode
peut etre appelee selon plusieurs modes en fonction de la valeur
- propager l'eventuel changement d'etat au parent
"""
if CONTEXT.debug:
- print(("ETAPE.isvalid ", self.nom))
+ print(("ETAPE.isValid ", self.nom))
if self.state == 'unchanged':
return self.valid
else:
