#class LASSD(I_LASSD.LASSD,N_LASSD.LASSD):pass
class LASSD(I_LASSD.LASSD):pass
-class assd(N_ASSD.assd,I_ASSD.ASSD,ASSD):pass
+class assd(N_ASSD.assd,I_ASSD.assd,ASSD):pass
class FONCTION(N_FONCTION.FONCTION,I_FONCTION.FONCTION,ASSD):
def __init__(self,etape=None,sd=None,reg='oui'):
N_FONCTION.FONCTION.__init__(self,etape=etape,sd=sd,reg=reg)
I_FONCTION.FONCTION.__init__(self,etape=etape,sd=sd,reg=reg)
-class formule(N_FONCTION.formule,I_FONCTION.formule,ASSD):
+class formule(I_FONCTION.formule,N_FONCTION.formule,ASSD):
def __init__(self,etape=None,sd=None,reg='oui'):
N_FONCTION.formule.__init__(self,etape=etape,sd=sd,reg=reg)
I_FONCTION.formule.__init__(self,etape=etape,sd=sd,reg=reg)
N_FONCTION.formule.__init__(self,etape=etape,sd=sd,reg=reg)
I_FONCTION.fonction.__init__(self,etape=etape,sd=sd,reg=reg)
-class GEOM(N_GEOM.GEOM,I_ASSD.ASSD,ASSD):pass
-class geom(N_GEOM.geom,I_ASSD.ASSD,ASSD):pass
-class CO(N_CO.CO,I_ASSD.ASSD,ASSD):pass
+class GEOM(N_GEOM.GEOM,I_ASSD.GEOM,ASSD):pass
+class geom(N_GEOM.geom,I_ASSD.geom,ASSD):pass
+class CO(N_CO.CO,I_ASSD.CO,ASSD):pass
import types
from Noyau import N_VALIDATOR
from Ihm import I_VALIDATOR
+from Ihm.I_VALIDATOR import ValidException
class FunctionVal(I_VALIDATOR.FunctionVal,N_VALIDATOR.FunctionVal):pass
class OrVal(I_VALIDATOR.OrVal,N_VALIDATOR.OrVal):pass
from A_VALIDATOR import OrdList,NoRepeat,LongStr,OrVal,AndVal
from A_VALIDATOR import RangeVal, EnumVal, TypeVal, PairVal
from A_VALIDATOR import CardVal, InstanceVal
+from A_VALIDATOR import ValidException
# On remplace la factory des validateurs initialement dans Noyau par celle
# de A_VALIDATOR
rep_macro = os.path.join(prefs.REPINI,'Cata/cataSTA81')
sys.path.insert(0,rep_macro)
from cata import *
+from math import ceil
+from Extensions import param2
+pi=param2.Variable('pi',pi)
pass
#
-__version__="$Name: $"
-__Id__="$Id: cata_aster_v6.py,v 1.12 2001/01/16 15:55:05 iliade Exp $"
+__version__="$Name: BR_dev_mars_06 $"
+__Id__="$Id: cata.py,v 1.3 2005/12/12 09:30:13 eficas Exp $"
#
JdC = JDC_CATA(code='ASTER',
execmodul=None,
def __init__(self,valeur=None,**args):
ASSD.__init__(self,**args)
self.valeur=valeur
+ def __adapt__(self,validator):
+ return validator(self.valeur)
+
# Type geometriques
class no (GEOM):pass
else :
raise AsException("ACTION non prevue : %s" % ACTION)
+def DEFI_FICHIER_ops(self,d):
+ if self.sd is not None:
+ self.sd.valeur=1
+
DEFI_FICHIER=MACRO(nom="DEFI_FICHIER",op=ops.build_DEFI_FICHIER,sd_prod=DEFIC_prod,reentrant='n',
+ op_init=DEFI_FICHIER_ops,
UIinfo={"groupes":("Gestion du travail",)},
fr="Ouvre ou ferme un fichier associé à un numéro d'unité logique",
+# -*- coding: utf-8 -*-
+"""
+Pour modifier le style d'EFICAS il faut ajouter un fichier style.py qui contiendra les
+informations sur le style voulu dans son repertoire Eficas_install.
+
+La methode la plus simple consiste à modifier directement les attributs de l'objet style dans le
+fichier style.py d'Eficas_install. Exemple::
+
+ style.background='yellow'
+
+pour modifier la couleur du background.
+
+Il existe une autre méthode qui peut être utilisée quand on veut modifier plusieurs propriétés à la fois.
+
+Le fichier style.py doit définir une nouvelle classe qui dérive de la classe de base STYLE avec des attributs
+de classe qui définiront le nouveau style (par exemple, si on veut modifier le background)::
+
+ class STYLE(STYLE):
+ background='yellow'
+
+Il faut ensuite instancier cette classe, dans ce meme fichier, en donnant le nom style à l'objet cree::
+
+ style=STYLE()
+
+Tous les attributs de classe possibles sont visibles dans le module Editeur/basestyle.py::
+
+ background='gray90'
+ foreground='black'
+ entry_background='white'
+ list_background='white'
+ list_select_background='#00008b'
+ list_select_foreground='grey'
+ tooltip_background="yellow"
+
+ standard = ("Helvetica",12)
+ standard_italique = ("Helvetica",12,'italic')
+ standard_gras = ("Helvetica",12,'bold')
+ standard_gras_souligne = ("Helvetica",12,'bold','underline')
+
+ canvas = ('Helvetica',10)
+ canvas_italique = ('Helvetica',10,'italic')
+ canvas_gras = ("Helvetica",10,'bold')
+ canvas_gras_italique = ("Helvetica",12,'bold','italic')
+
+ standard12 = ("Helvetica",14)
+ standard12_gras = ("Helvetica",14,'bold')
+ standard12_gras_italique = ( "Helvetica",14,'bold','italic')
+
+ standardcourier10 = ("Courier",14)
+
+
+Le fichier style.py contenu dans le répertoire Aster permet de spécifier des propriétés globales pour une installation.
+Les modifications de style contenues dans ce fichier et dans le fichier style.py d'Eficas_install
+sont prises en compte dans cet ordre.
+"""
+
+
+
from copy import copy,deepcopy
# import du chargeur de composants
-from comploader import gettreeitem,make_objecttreeitem
+from comploader import make_objecttreeitem
import treewidget
from Ihm import CONNECTOR
return self.object.get_genealogie()
def get_index_child(self,nom_fils):
+ """
+ Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
+ Nécessaire pour savoir à quelle position dans la liste des fils il faut ajouter
+ le nouveau mot-clé
+ """
+ return self.object.get_index_child(nom_fils)
+
+ def get_index_child_old(self,nom_fils):
"""
Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
Nécessaire pour savoir à quelle position dans la liste des fils il faut ajouter
Cette methode, globale pour les objets de type item, permet de construire et de retourner un objet
de type item associé à l'object passé en argument.
"""
- c = gettreeitem(object)
- return c(appli,labeltext, object, setfunction)
+ return make_objecttreeitem(appli,labeltext,object,setfunction)
#def __del__(self):
# print "__del__",self
"""
# Modules Python
import os
+import string
import sys
import types
import Pmw
import fontes
import tooltip
import properties
+import convert,generator
+import comploader
+from utils import extension_fichier,stripPath
+
from widgets import Fenetre
from Misc import MakeNomComplet
import session
f.wait()
+class valeur:
+ def __init__(self,v=None):
+ self.v=v
+ def set(self,v):
+ self.v=v
+ def get(self):
+ return self.v
+
+class STANDALONE(APPLI):
+ def __init__ (self,code=prefs.code,fichier=None,version='v8.2') :
+ self.code=code
+ self.top=None
+ self.format_fichier=valeur()
+
+ self.dict_reels={}
+ self.liste_simp_reel=[]
+ # L'attribut test doit valoir 1 si on ne veut pas creer les fenetres
+ self.test=1
+
+ # Lecture des parametres de configuration (fichier global editeur.ini
+ # et utilisateur eficas.ini)
+ self.lecture_parametres()
+
+ self.message=''
+ # Avant la creation du bureau qui lit le catalogue
+ self.version_code=version
+ import readercata
+ self.readercata=readercata.READERCATA(self,None)
+
+ self.dir=None
+
+ def affiche_infos(self,message):
+ return
+
+ def get_text_JDC(self,JDC,format):
+ if generator.plugins.has_key(format):
+ # Le generateur existe on l'utilise
+ g=generator.plugins[format]()
+ jdc_formate=g.gener(JDC,format='beautifie')
+ return jdc_formate
+ else:
+ # Il n'existe pas c'est une erreur
+ return
+
+ def newJDC(self):
+ CONTEXT.unset_current_step()
+ J=self.readercata.cata[0].JdC(procedure="",
+ appli=self,
+ cata=self.readercata.cata,
+ cata_ord_dico=self.readercata.cata_ordonne_dico,
+ rep_mat=self.CONFIGURATION.rep_mat,
+ )
+ J.analyse()
+ return J
+
+ def openJDC(self,file):
+ self.fileName = file
+ e=extension_fichier(file)
+ self.JDCName=stripPath(file)
+ self.initialdir = os.path.dirname(os.path.abspath(file))
+ format=self.format_fichier.get()
+ # Il faut convertir le contenu du fichier en fonction du format
+ if convert.plugins.has_key(format):
+ # Le convertisseur existe on l'utilise
+ p=convert.plugins[format]()
+ p.readfile(file)
+ text=p.convert('exec',self)
+ # On se met dans le repertoire ou se trouve le fichier de commandes
+ # pour trouver les eventuels fichiers include ou autres
+ # localises a cote du fichier de commandes
+ os.chdir(self.initialdir)
+ CONTEXT.unset_current_step()
+ J=self.readercata.cata[0].JdC(procedure=text,
+ appli=self,
+ cata=self.readercata.cata,
+ cata_ord_dico=self.readercata.cata_ordonne_dico,
+ nom=self.JDCName,
+ rep_mat=self.CONFIGURATION.rep_mat,
+ )
+ J.analyse()
+ txt= J.cr.get_mess_exception()
+ if txt:raise ValueError(txt)
+ return J
+
+ def openTXT(self,text):
+ self.JDCName="TEXT"
+ CONTEXT.unset_current_step()
+ J=self.readercata.cata[0].JdC(procedure=text,
+ appli=self,
+ cata=self.readercata.cata,
+ cata_ord_dico=self.readercata.cata_ordonne_dico,
+ nom=self.JDCName,
+ rep_mat=self.CONFIGURATION.rep_mat,
+ )
+ J.analyse()
+ txt= J.cr.get_mess_exception()
+ if txt:raise ValueError(txt)
+ return J
+
+ def create_item(self,obj):
+ return comploader.make_objecttreeitem(self,getattr(obj,"nom","item"),obj)
+
+ def get_file(self,unite=None,fic_origine = ''):
+ """
+ Retourne le nom du fichier correspondant a l unite logique unite (entier)
+ ou d'un fichier poursuite
+ """
+ f,ext=os.path.splitext(fic_origine)
+ if unite :
+ #include
+ finclude=f+".%d" % unite
+ else:
+ #poursuite
+ n=ext[-1]
+ if n == '0':
+ ext=".comm"
+ else:
+ ext=".com%d" % (string.atoi(n)-1)
+ if ext == '.com0' and not os.path.isfile(f+".com0"):
+ ext=".comm"
+ finclude=f+ext
+ ff=open(finclude)
+ text=ff.read()
+ ff.close()
+ return finclude,text
+
+ def affiche_alerte(self,titre,message):
+ print titre+ "\n\n" + message
Cette classe item dépend bien sûr de la nature de object, d'où
l'interrogation du dictionnaire composants
"""
+ # Si la definition de l'objet a un attribut itemeditor, il indique
+ # la classe a utiliser pour l'item
+ try:
+ return object.definition.itemeditor
+ except:
+ pass
-
- if type(object) == types.InstanceType:
- # Si la definition de l'objet a un attribut itemeditor, il indique
- # la classe a utiliser pour l'item
- try:
- return object.definition.itemeditor
- except:
- pass
-
- # On cherche ensuite dans les composants (plugins)
- try:
- itemtype= composants[object.__class__]
- return itemtype
- except:
- pass
-
- try :
- for e in composants.keys():
- if isinstance(object,e):
- itemtype= composants[e]
- return itemtype
- except :
- pass
+ # On cherche ensuite dans les composants (plugins)
+ try:
+ itemtype= composants[object.__class__]
+ return itemtype
+ except:
+ pass
# Puis une eventuelle classe heritee (aleatoire car sans ordre)
for e in composants.keys():
- if isinstance(object,e):
- itemtype= composants[e]
- return itemtype
+ if e and isinstance(object,e):
+ itemtype= composants[e]
+ return itemtype
- # Apres poum ??? Les lignes suivantes sont elles utiles ?
# Si on n'a rien trouve dans les composants on utilise l'objet par defaut
- print itemtype
- itemtype=ObjectTreeItem
+ itemtype=composants[None]
return itemtype
def make_objecttreeitem(appli,labeltext, object, setfunction=None):
--- /dev/null
+import Objecttreeitem
+treeitem = Objecttreeitem.ObjectTreeItem
+objet = None
return self.object.get_noms_sd_oper_reentrant()
def get_objet_commentarise(self):
+ """
+ Cette méthode retourne un objet commentarisé
+ représentatif de self.object
+ """
+ # Format de fichier utilisé
+ format=self.appli.format_fichier.get()
+ return self.object.get_objet_commentarise(format)
+
+ def get_objet_commentarise_BAK(self):
"""
Cette méthode retourne un objet commentarisé
représentatif de self.object
"""
Retourne la valeur de l'objet PARAMETRE cad son texte
"""
- return self.object.valeur or ''
+ if self.object.valeur is None: return ''
+ else: return self.object.valeur
def get_nom(self):
"""
"""
Renomme le paramètre
"""
- self.object.set_attribut('nom',new_nom)
+ self.object.set_nom(new_nom)
+ #self.object.set_attribut('nom',new_nom)
def get_fr(self):
"""
# traite_reel
def eval_valeur(self,valeur):
+ """ Lance l'interprétation de 'valeur' (chaîne de caractères) comme valeur de self :
+ - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
+ - retourne 'valeur' (chaîne de caractères) sinon
+ """
+ newvaleur=self.eval_val(valeur)
+ return newvaleur,1
+
+ def eval_valeur_BAK(self,valeur):
""" Lance l'interprétation de 'valeur' (chaîne de caractères) comme valeur
de l'objet pointé par self :
- retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
+# -*- coding: utf-8 -*-
import os
import prefs
import basestyle
"""
valeur = self.node.item.get_valeur()
if valeur == None or valeur == '' : return # pas de valeur à afficher ...
- self.valeur_choisie.set(valeur.nom)
+ self.valeur_choisie.set(getattr(valeur,"nom","unknown"))
def erase_valeur(self):
pass
#print "uncomment",new_etape.sd
pos=self.parent.etapes.index(self)
+ # L'ordre d'appel est important : suppentite fait le menage des concepts dans les etapes suivantes
self.parent.addentite(new_etape,pos)
self.parent.suppentite(self)
return new_etape,nom_sd
JDC.supprime(self)
self.jdc_pere=None
self.etape_include=None
+ # self.cata_ordonne_dico={}
+ self.appli=None
+ # self.context_ini={}
+ # self.procedure=None
def get_contexte_avant(self,etape):
"""
#Regularise les etapes du jdc apres l'etape etape
self.control_jdc_context_apres(etape)
if self.etape_include:
+ #print "CONTROL_INCLUDE:",self.etape_include,self.etape_include.nom
# il existe un jdc pere. On propage la regularisation
self.etape_include.parent.control_context_apres(self.etape_include)
from __future__ import division
import math
+import Numeric
def mkf(value):
- if type(value) in (type(1), type(1L), type(1.5), type(1j),type("hh")):
+ if type(value) in (type(1), type(1L), type(1.5), type(1j),type("hh")) :
return Constant(value)
elif isinstance(value, Formula):
return value
+ elif type(value) == type([]):
+ return Constant(value)
else:
+# return Constant(value)
raise TypeError, ("Can't make formula from", value)
#class Formula(object):
class Formula:
+ def __len__(self):
+ val=self.eval()
+ if val is None:return 0
+ try:
+ return len(val)
+ except:
+ return 1
def __complex__(self): return complex(self.eval())
def __int__(self): return int(self.eval())
def __long__(self): return long(self.eval())
self.values = mkf(value1), mkf(value2)
def __str__(self):
if self.op == '[]':
- return "(%s[%s])" % (self.values[0], self.values[1])
+ return "%s[%s]" % (self.values[0], self.values[1])
else:
return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
def __repr__(self):
if self.op == '[]':
- return "(%s[%s])" % (self.values[0], self.values[1])
+ return "%s[%s]" % (self.values[0], self.values[1])
else:
return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
def eval(self):
while isinstance(result,Formula):
result=result.eval()
return result
+ def __adapt__(self,validator):
+ return validator(self.eval())
+
+original_sqrt=math.sqrt
+original_ceil=math.ceil
+original_cos=math.cos
+original_sin=math.sin
+original_ncos=Numeric.cos
+original_nsin=Numeric.sin
class Unop(Formula):
opmap = { '-': lambda x: -x,
- 'sin': lambda x: math.sin(x),
- 'cos': lambda x: math.cos(x) }
+ 'sqrt': lambda x: original_sqrt(x),
+ 'ceil': lambda x: original_ceil(x),
+ 'sin': lambda x: original_sin(x),
+ 'cos': lambda x: original_cos(x) ,
+ 'ncos': lambda x: original_ncos(x),
+ 'nsin': lambda x: original_nsin(x),
+ }
def __init__(self, op, arg):
self._op = op
self._arg = mkf(arg)
def __str__(self):
return "%s(%s)" % (self._op, self._arg)
+ def __repr__(self):
+ return "%s(%s)" % (self._op, self._arg)
def eval(self):
return self.opmap[self._op](self._arg.eval())
+ def __adapt__(self,validator):
+ return validator(self.eval())
+
+class Unop2(Unop):
+ def __init__(self, nom, op, arg):
+ self._nom = nom
+ self._op = op
+ self._arg=[]
+ for a in arg:
+ self._arg.append(mkf(a))
+ def __str__(self):
+ s="%s(" % self._nom
+ for a in self._arg:
+ s=s+str(a)+','
+ s=s+")"
+ return s
+ def __repr__(self):
+ s="%s(" % self._nom
+ for a in self._arg:
+ s=s+str(a)+','
+ s=s+")"
+ return s
+ def eval(self):
+ l=[]
+ for a in self._arg:
+ l.append(a.eval())
+ return self._op(*l)
class Constant(Formula):
def __init__(self, value): self._value = value
def eval(self): return self._value
def __str__(self): return str(self._value)
+ def __adapt__(self,validator):
+ return validator(self._value)
class Variable(Formula):
def __init__(self,name,value):
def eval(self): return self._value
def __repr__(self): return "Variable('%s',%s)" % (self._name, self._value)
def __str__(self): return self._name
+ def __adapt__(self,validator):
+ return validator(self._value)
+def cos(f): return Unop('ncos', f)
+def sin(f): return Unop('nsin', f)
+Numeric.cos=cos
+Numeric.sin=sin
+def sqrt(f): return Unop('sqrt', f)
+def ceil(f): return Unop('ceil', f)
def cos(f): return Unop('cos', f)
def sin(f): return Unop('sin', f)
+math.cos=cos
+math.sin=sin
+math.sqrt=sqrt
+math.ceil=ceil
# import de modules Python
import string,types
from math import *
+import traceback
# import de modules Eficas
from Noyau.N_CR import CR
idracine = 'param'
def __init__(self,nom,valeur=None):
- # parent ne peut être qu'un objet de type JDC
- self.dict_valeur=[]
- self.valeur = self.interprete_valeur(valeur)
- self.val=valeur
self.nom = nom
# La classe PARAMETRE n'a pas de définition : on utilise self pour
# complétude
self.definition=self
+ # parent ne peut être qu'un objet de type JDC
self.jdc = self.parent = CONTEXT.get_current_step()
self.niveau=self.parent.niveau
self.actif=1
self.state='undetermined'
self.register()
+ self.dict_valeur=[]
+ #self.valeur = self.interprete_valeur(valeur)
+ #self.val=valeur
+ self.valeur = valeur
+ self.val=repr(valeur)
- def __getitem__(self,key):
- param_item=ITEM_PARAMETRE(self,key)
- return param_item
-
-# def __neg__(self):
-# try:
-# return -1*self.valeur
-# except:
-# print "******* Probleme : pas de valeur négative"
-# return None
-
-# def __add__(self,a):
-# try :
-# return self.valeur+a.valeur
-# except :
-# print "******* Probleme : a l addition"
-# return None
-
-# def __radd__(self,a):
-# try :
-# return self.valeur+a.valeur
-# except :
-# print "******* Probleme : a l addition"
-# return None
-
-# def __sub__(self,a):
-# try :
-# return self.valeur - a.valeur
-# except :
-# print "******* Probleme : a la soustraction"
-# return None
-
-# def __rsub__(self,a):
-# try :
-# return a.valeur - self.valeur
-# except :
-# print "******* Probleme : a la soustraction"
-# return None
-
-
-# def __mul__(self,a):
-# try :
-# return self.valeur*a.valeur
-# except :
-# print "******* Probleme : a la multiplication"
-# return None
-
-# def __rmul__(self,a):
-# try :
-# return self.valeur*a.valeur
-# except :
-# print "******* Probleme : a la multiplication"
-# return None
-
-# def __add__(self,other):
-# try :
-# return self.valeur+other
-# except :
-# print "******* Probleme : a l addition"
-# return None
-
-# def __radd__(self,other):
-# try :
-# return self.valeur+other
-# except :
-# print "******* Probleme : a l addition"
-# return None
-
-# def __sub__(self,other):
-# try :
-# return self.valeur - other
-# except :
-# print "******* Probleme : a la soustraction"
-# return None
-
-# def __rsub__(self,other):
-# try :
-# return other - self.valeur
-# except :
-# print "******* Probleme : a la soustraction"
-# return None
-
-# def __mul__ (self,other):
-# retour=None
-# try :
-# retour = eval(self.valeur) * other
-# except :
-# try :
-# retour = self.valeur * other
-# except :
-# try :
-# retour = eval(self.valeur) * eval(other)
-# except :
-# try :
-# retour = self.valeur * eval(other)
-# except :
-# print other
-# print "******* Probleme : a la multiplication _mul__"
-# return retour
-#
-# def __rmul__ (self,other):
-# retour=None
-# try :
-# retour = eval(self.valeur) * other
-# except :
-# try :
-# retour = self.valeur * other
-# except :
-# try :
-# retour = eval(self.valeur) * eval(other)
-# except :
-# print "******* Probleme : a la multiplication __rmul__"
-# return retour
-#
-#
-# def __div__(self,other):
-# retour=None
-# try:
-# retour = eval(self.valeur) / other
-# except :
-# try :
-# retour = self.valeur / other
-# except :
-# print "******* Probleme : a la division"
-# return retour
-#
-#
-# def cos(self):
-# try :
-# retour=cos(self.valeur)
-# return retour
-# except:
-# print "pb pour cosinus"
-#
-# def sin(self):
-# try :
-# retour=sin(self.valeur)
-# return retour
-# except:
-# print "pb pour sinus"
-#
-# def tan(self):
-# try :
-# retour=tan(self.valeur)
-# return retour
-# except:
-# print "pb pour tangente"
-#
-# def log(self):
-# try :
-# retour=log(self.valeur)
-# return retour
-# except:
-# print "pb pour log"
-#
-# def sqrt(self):
-# try :
-# retour=sqrt(self.valeur)
-# return retour
-# except:
-# print "pb pour sqrt"
-#
def interprete_valeur(self,val):
"""
Essaie d'interpréter val (chaîne de caractères)comme :
- une liste d'items d'un type qui précède
Retourne la valeur interprétée
"""
- if not val : return None
+ #if not val : return None
valeur = None
- # on vérifie si val est un entier
- try :
- valeur = string.atoi(val) # on a un entier
- return valeur
- except :
- pass
- # on vérifie si val est un réel
- try:
- valeur = string.atof(val) # on a un réel
- return valeur
- except :
- pass
- # on vérifie si val est un tuple
- try :
- valeur = eval(val)
- except:
- pass
+
+ if type(val) == types.StringType:
+ # on tente l'evaluation dans un contexte fourni par le parent s'il existe
+ if self.parent:
+ valeur=self.parent.eval_in_context(val,self)
+ else:
+ try :
+ valeur = eval(val)
+ except:
+ #traceback.print_exc()
+ pass
#PN je n ose pas modifier je rajoute
+ # refus des listes heterogenes : ne dvrait pas etre la
if valeur != None :
if type(valeur) == types.TupleType:
l_new_val = []
return val
l_new_val.append(v)
return tuple(l_new_val)
- # PN : commente le print
- #else:
- # on a réussi à évaluer val en autre chose qu'un tuple ...
- #print "on a réussi à évaluer %s en autre chose qu'un tuple ..." %val
- #print 'on trouve : ',str(valeur),' de type : ',type(valeur)
- # on retourne val comme une string car on n'a pas su l'interpréter
+
if valeur != None :
if type(valeur).__name__ == 'list':
self.dict_valeur=[]
for i in range(len(valeur)):
- self.dict_valeur.append(valeur[i])
+ self.dict_valeur.append(valeur[i])
+ return valeur
+ # on retourne val comme une string car on n'a pas su l'interpréter
return val
def get_valeurs(self):
self.valeur = self.interprete_valeur(new_valeur)
self.init_modif()
+ def set_nom(self,new_nom):
+ """
+ Change le nom du parametre
+ """
+ self.init_modif()
+ self.nom=new_nom
+ self.fin_modif()
+
def init_modif(self):
"""
Méthode qui déclare l'objet courant comme modifié et propage
self.parent = None
self.jdc = None
self.definition=None
+ self.niveau=None
def active(self):
"""
"""
Donne un echo de self sous la forme nom = valeur
"""
- return self.nom+' = '+str(self.valeur)
+ if type(self.valeur) == types.StringType:
+ if self.valeur.find('\n') == -1:
+ # pas de retour chariot, on utilise repr
+ return self.nom+' = '+ repr(self.valeur)
+ elif self.valeur.find('"""') == -1:
+ # retour chariot mais pas de triple ", on formatte
+ return self.nom+' = """'+self.valeur+'"""'
+ else:
+ return self.nom+' = '+ repr(self.valeur)
+ else:
+ return self.nom+' = '+ str(self.valeur)
def __str__(self):
"""
pass
def eval(self):
- return self.valeur
+ if isinstance(self.valeur,Formula):
+ return self.valeur.eval()
+ else:
+ return self.valeur
+
+ def __adapt__(self,validator):
+ return validator(self.eval())
class COMBI_PARAMETRE :
def __init__(self,chainevaleur,valeur):
#
# ======================================================================
+from I_VALIDATOR import ValidException
+
class ASSD:
def __repr__(self):
return "concept %s de type %s" % (self.get_name(),self.__class__.__name__)
+ #def __del__(self):
+ # print "__del__",self
+
+class assd(ASSD):
+ def __convert__(cls,valeur):
+ return valeur
+ __convert__=classmethod(__convert__)
+
+class GEOM(ASSD):
+ def __convert__(cls,valeur):
+ return valeur
+ __convert__=classmethod(__convert__)
+
+class geom(GEOM):pass
+
+class CO(ASSD):
+ def __convert__(cls,valeur):
+ if hasattr(valeur,'_etape') :
+ # valeur est un concept CO qui a ete transforme par type_sdprod
+ if valeur.etape == valeur._etape:
+ # le concept est bien produit par l'etape
+ return valeur
+ raise ValidException("Pas un concept CO")
+ __convert__=classmethod(__convert__)
+
# Modules EFICAS
import I_MCCOMPO
import CONNECTOR
+from Extensions import commande_comm
class ETAPE(I_MCCOMPO.MCCOMPO):
"""
#print "fin_modif",self,self.parent
if self.nom == "DETRUIRE":
+ traceback.print_stack(limit=8)
#Il n'est pas conseillé de mettre des traitements dans fin_modif. Ceci est une
# exception qu'il faut supprimer à terme.
#une commande DETRUIRE a été modifiée. Il faut verifier les commandes
#suivantes
#ATTENTION: aux eventuelles recursions
self.parent.control_context_apres(self)
+ pass
CONNECTOR.Emit(self,"valid")
if self.parent:
"""
if self.actif:return
self.actif = 1
+ self.init_modif()
if self.sd :
try:
self.jdc.append_sdprod(self.sd)
et de la liste des sd
"""
self.actif = 0
+ self.init_modif()
if self.sd :
self.jdc.del_sdprod(self.sd)
self.jdc.delete_concept_after_etape(self,self.sd)
Realise l'update des blocs conditionnels fils de self
"""
self._update_condition_bloc()
+
+ def get_objet_commentarise(self,format):
+ """
+ Cette méthode retourne un objet commande commentarisée
+ representant la commande self
+ """
+ import generator
+ g=generator.plugins[format]()
+ texte_commande = g.gener(self,format='beautifie')
+ # Il faut enlever la première ligne vide de texte_commande que
+ # rajoute le generator
+ rebut,texte_commande = string.split(texte_commande,'\n',1)
+ # on construit l'objet COMMANDE_COMM repésentatif de self mais non
+ # enregistré dans le jdc (pas ajouté dans jdc.etapes)
+ parent=self.parent
+ pos=self.parent.etapes.index(self)
+ commande_comment = commande_comm.COMMANDE_COMM(texte=texte_commande,
+ reg='non',
+ parent=parent)
+ self.parent.suppentite(self)
+ parent.addentite(commande_comment,pos)
+
+ return commande_comment
+
#ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
def Build_sd(self,nom):
#
#
# ======================================================================
+import string
from I_ASSD import ASSD
class FONCTION(ASSD):
# modification de C Durand sur la gestion des formules dans le superviseur
# On conserve l'ancienne classe fonction (ceinture et bretelles)
class fonction(FONCTION) : pass
-class formule(FONCTION) : pass
+
+from Extensions import param2
+class formule(FONCTION) :
+ def __call__(self,*val):
+ if len(val) != len(self.nompar):
+ raise TypeError(" %s() takes exactly %d argument (%d given)" % (self.nom,len(self.nompar),len(val)))
+ return param2.Unop2(self.nom,self.real_call,val)
+
+ def real_call(self,*val):
+ if hasattr(self.parent,'contexte_fichier_init'):
+ context=self.parent.contexte_fichier_init
+ else : context={}
+ i=0
+ for param in self.nompar :
+ context[param]=val[i]
+ i=i+1
+ try :
+ res=eval(self.expression,self.jdc.const_context, context)
+ except :
+ print 75*'!'
+ print '! '+string.ljust('Erreur evaluation formule '+self.nom,72)+'!'
+ print 75*'!'
+ raise
+ return res
+
return O
arguments=formule[3]
if arguments[0] == '(' :
- arguments=[1,-1 ]
- if arguments[-1] == '(' :
- arguments=[0,-2 ]
+ arguments=arguments[1:]
+ if arguments[-1] == ')' :
+ arguments=arguments[:-1]
self.arguments=tuple(arguments.split(','))
i=1
Il faut ajouter la formule au contexte global du JDC
"""
self.actif = 1
+ self.init_modif()
nom = self.get_nom()
if nom == '' : return
try:
Il faut supprimer la formule du contexte global du JDC
"""
self.actif = 0
+ self.init_modif()
if not self.sd : return
self.jdc.del_fonction(self.sd)
def changefichier(self,fichier):
self.fin_modif()
+ def eval_in_context(self,valeur,etape):
+ """ Tente d'evaluer valeur dans le contexte courant de etape
+ Retourne le parametre valeur inchange si l'evaluation est impossible
+ """
+ #contexte initial du jdc
+ context=self.condition_context.copy()
+ #contexte courant des concepts. Il contient les parametres
+ context.update(self.get_contexte_avant(etape))
+ try :
+ objet = eval(valeur,context)
+ return objet
+ except:
+ #traceback.print_exc()
+ pass
+ return valeur
+
+#ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
+ def supprime(self):
+ #print "supprime",self
+ Noyau.N_JDC.JDC.supprime(self)
+ # self.appli=None
+ # self.g_context={}
+ # self.const_context={}
+ # self.sds=[]
+ # self.sds_dict={}
+ # self.mc_globaux={}
+ # self.current_context={}
+ # self.condition_context={}
+ # self.etapes_niveaux=[]
+ # self.niveau=None
+ # self.params=[]
+ # self.fonctions=[]
+ # self._etape_context=None
+ # self.etapes=[]
+
#ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
def register(self,etape):
"""
import I_ETAPE
import Noyau
from Noyau.N_ASSD import ASSD
+import convert
# import rajoutés suite à l'ajout de Build_sd --> à résorber
import Noyau, Validation.V_MACRO_ETAPE
# de prendre cette precaution mais ce n'est pas vrai partout.
old_recorded_units=self.recorded_units.copy()
+ # on supprime l'ancien jdc_aux s'il existe
+ if hasattr(self,'jdc_aux') and self.jdc_aux:
+ self.jdc_aux.supprime_aux()
+
if fichier is None:fichier="SansNom"
+
+ # Il faut convertir le texte inclus en fonction du format
+ format=self.jdc.appli.format_fichier.get()
+ if convert.plugins.has_key(format):
+ # Le convertisseur existe on l'utilise
+ p=convert.plugins[format]()
+ p.text=text
+ text=p.convert('exec',self)
+
j=self.JdC_aux( procedure=text, nom=fichier,
appli=self.jdc.appli,
cata=self.jdc.cata,
self.etapes=j.etapes
self.jdc_aux=j
except:
+ traceback.print_exc()
# On retablit l'etape courante step
CONTEXT.unset_current_step()
CONTEXT.set_current_step(step)
# On recupere le contexte de l'include verifie
try:
j_context=j.get_verif_contexte()
+ #print j_context.keys()
+ #print j.g_context.keys()
except:
# On retablit l'etape courante step
CONTEXT.unset_current_step()
Cette méthode sert à créer un contexte en interprétant un texte source
Python
"""
- #print "make_contexte_include"
+ #print "make_contexte_include",fichier
# on récupère le contexte d'un nouveau jdc dans lequel on interprete text
contexte = self.get_contexte_jdc(fichier,text)
if contexte == None :
#print "update_context.fin",d.keys()
#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
+ def copy(self):
+ etape=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.copy(self)
+ if hasattr(etape,"etapes") :etape.etapes=[]
+ if hasattr(etape,"jdc_aux") :
+ etape.jdc_aux=None
+ del etape.fichier_ini
+ return etape
+
def supprime(self):
#print "supprime",self
if hasattr(self,"jdc_aux") and self.jdc_aux:
self.jdc_aux.supprime_aux()
self.jdc_aux=None
Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self)
+ # self.contexte_fichier_init={}
+ # self.old_contexte_fichier_init={}
+ # self.g_context={}
+ # self.current_context={}
+ # self.etapes=[]
+ # self.mc_liste=[]
#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
def get_file(self,unite=None,fic_origine=''):
en interprétant un texte source Python
Elle est appelee par la fonction sd_prd d'INCLUDE_MATERIAU
"""
+ #print "make_contexte",fichier
# On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
# car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
if hasattr(self,'mat'):del self.mat
- self.fichier_ini =fichier
- self.fichier_unite =fichier
- self.fichier_text=text
- self.fichier_err=None
- self.contexte_fichier_init={}
- # On specifie la classe a utiliser pour le JDC auxiliaire
- try:
- import Extensions.jdc_include
- except:
- traceback.print_exc()
- raise
- self.JdC_aux=Extensions.jdc_include.JdC_include
- try:
- self.make_contexte_include(self.fichier_ini ,self.fichier_text)
- #self.parent.record_unit(self.fichier_unite,self)
- except:
- l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
- self.fichier_err = string.join(l)
- #self.parent.record_unit(self.fichier_unite,self)
- self.g_context={}
- self.etapes=[]
- self.jdc_aux=None
+ if not hasattr(self,'fichier_ini') or self.fichier_ini != fichier or self.fichier_mater != self.nom_mater:
+ # le fichier est nouveau ou change
+ self.fichier_ini =fichier
+ self.fichier_unite =fichier
+ self.fichier_mater=self.nom_mater
+ self.fichier_text=text
+ self.fichier_err=None
self.contexte_fichier_init={}
- raise
+ # On specifie la classe a utiliser pour le JDC auxiliaire
+ try:
+ import Extensions.jdc_include
+ self.JdC_aux=Extensions.jdc_include.JdC_include
+ except:
+ traceback.print_exc()
+ raise
+ try:
+ self.make_contexte_include(self.fichier_ini ,self.fichier_text)
+ except:
+ l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+ self.fichier_err = string.join(l)
+ self.g_context={}
+ self.etapes=[]
+ self.jdc_aux=None
+ self.contexte_fichier_init={}
+ raise
+ else:
+ # le fichier est le meme on ne le reevalue pas
+ # et on leve une exception si une erreur a été enregistrée
+ if self.fichier_err is not None: raise Exception(self.fichier_err)
#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
def update_sdprod(self,cr='non'):
import I_OBJECT
import CONNECTOR
+from I_VALIDATOR import ValidException
+
class MCSIMP(I_OBJECT.OBJECT):
def GetNomConcept(self):
sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
#sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
#print sd
- if sd :
+ if sd is not None:
return sd,1
lsd = self.jdc.cherche_list_avant(self.etape,new_valeur)
if lsd :
if CONTEXT.debug : traceback.print_exc()
return None,0
+ def eval_val(self,new_valeur):
+ """
+ Tente d'evaluer new_valeur comme un objet du jdc (par appel a eval_val_item)
+ ou comme une liste de ces memes objets
+ Si new_valeur contient au moins un separateur (,), tente l'evaluation sur
+ la chaine splittee
+ """
+ if type(new_valeur) in (types.ListType,types.TupleType):
+ valeurretour=[]
+ for item in new_valeur :
+ valeurretour.append(self.eval_val_item(item))
+ return valeurretour
+ else:
+ valeur=self.eval_val_item(new_valeur)
+ return valeur
+
+ def eval_val_item(self,new_valeur):
+ """
+ Tente d'evaluer new_valeur comme un concept, un parametre, un objet Python
+ Si c'est impossible retourne new_valeur inchange
+ argument new_valeur : string (nom de concept, de parametre, expression ou simple chaine)
+ """
+ if self.etape and self.etape.parent:
+ valeur=self.etape.parent.eval_in_context(new_valeur,self.etape)
+ return valeur
+ else:
+ try :
+ valeur = eval(val)
+ return valeur
+ except:
+ #traceback.print_exc()
+ return new_valeur
+ pass
+
def cherche_item_parametre (self,new_valeur):
try:
nomparam=new_valeur[0:new_valeur.find("[")]
self.init_modif()
self.valeur = new_objet
self.val = new_objet
- self.fin_modif()
- step.reset_context()
# 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)
+ self.fin_modif()
+ step.reset_context()
#print "set_valeur_co",new_objet
return 1,"Concept créé"
"""
#print "verif_existence_sd"
# 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 = self.jdc.get_contexte_avant(self.etape).values()
if type(self.valeur) in (types.TupleType,types.ListType) :
l=[]
- self.init_modif()
for sd in self.valeur:
if isinstance(sd,ASSD) :
- if sd in l_sd_avant_etape :
+ if sd in l_sd_avant_etape or self.etape.get_sdprods(sd.nom) is sd:
l.append(sd)
else:
l.append(sd)
- self.valeur=tuple(l)
- self.fin_modif()
+ if len(l) < len(self.valeur):
+ self.init_modif()
+ self.valeur=tuple(l)
+ self.fin_modif()
else:
if isinstance(self.valeur,ASSD) :
- if self.valeur not in l_sd_avant_etape :
+ if self.valeur not in l_sd_avant_etape and self.etape.get_sdprods(self.valeur.nom) is None:
self.init_modif()
self.valeur = None
self.fin_modif()
genea = self.get_genealogie()
if "VALE_C" in genea and "DEFI_FONCTION" in genea : return 3
if "VALE" in genea and "DEFI_FONCTION" in genea : return 2
- print dir(self)
return 0
#--------------------------------------------------------------------------------
# Elles doivent etre reintegrees des que possible
+ def convert_card(self,valeur):
+ """
+ Cette methode verifie que la cardinalite de valeur est correcte (comprise entre min et max)
+ Si c'est le cas elle retourne valeur eventuellement convertie
+ Si ce n'est pas le cas, elle leve une exception
+ """
+
+ adapt = getattr(valeur, '__adapt__', None)
+ if adapt is not None:
+ # l'objet valeur peut se verifier lui meme
+ return adapt(self.convert_card)
+
+ min=self.definition.min
+ max=self.definition.max
+
+ if type(valeur) == types.TupleType and valeur[0] in ('RI','MP'):
+ #il s'agit d'un complexe ancienne mode. La cardinalite vaut 1
+ length=1
+ elif valeur == None :
+ # pas de valeur affecte. La cardinalite vaut 0
+ length=0
+ elif type(valeur) == types.StringType :
+ #il s'agit d'une chaine. La cardinalite vaut 1
+ length=1
+ else:
+ try:
+ # si l'objet supporte len, on a la cardinalite
+ length=len(valeur)
+ except:
+ # sinon elle vaut 1
+ length=1
+
+ if length < min or length >max:
+ raise ValidException("Nombre d'arguments de %s incorrect pour %s (min = %s, max = %s)" % (repr(valeur),self.nom,min,max) )
+
+ return valeur
+
+ def verif_card(self,cr='non'):
+ """
+ un mot-clé simple ne peut etre répété :
+ la cardinalité ici s'entend par la vérification que le nombre d'arguments de self.valeur
+ est bien compris entre self.min et self.max dans le cas où il s'agit d'une liste
+ """
+ card = 1
+ try:
+ self.convert_card(self.valeur)
+ except ValidException,e:
+ if cr == 'oui': self.cr.fatal(str(e))
+ card = 0
+ return card
+
+ def convert_into(self,valeur):
+ """
+ Cette methode verifie que valeur est dans la liste des valeurs possibles donnée
+ dans la definition (attribut into) ou dans un intervalle donné dans la definition (attributs
+ val_min, val_max)
+ Si c'est le cas elle retourne valeur eventuellement convertie
+ Si ce n'est pas le cas, elle leve une exception
+ """
+ adapt = getattr(valeur, '__adapt__', None)
+ if adapt is not None:
+ # l'objet valeur peut se verifier lui meme
+ return adapt(self.convert_into)
+
+ if type(valeur) == types.TupleType and not valeur[0] in ('RI','MP') or type(valeur) == types.ListType:
+ # Cas d'une liste de valeurs
+ # on s'arrete a la premiere erreur
+ for val in valeur:
+ self.convert_into(val)
+ return valeur
+
+ # Cas d'un scalaire
+ if self.definition.into == None :
+ #on est dans le cas d'un ensemble continu de valeurs possibles (intervalle)
+ if type(valeur) in (types.IntType,types.FloatType,types.LongType) :
+ min = self.definition.val_min
+ max = self.definition.val_max
+ if min == '**': min = valeur -1
+ if max == '**': max = valeur +1
+ if valeur < min or valeur > max :
+ raise ValidException("La valeur : %s du mot-clé %s est en dehors du domaine de validité [ %s , %s ]" % (repr(valeur),self.nom,min,max) )
+ return valeur
+ else :
+ # on est dans le cas d'un ensemble discret de valeurs possibles (into)
+ if valeur not in self.definition.into:
+ raise ValidException("La valeur : %s n'est pas permise pour le mot-clé : %s" % (repr(valeur),self.nom) )
+ return valeur
+
+ def verif_into(self,cr='non'):
+ """
+ Vérifie si la valeur de self est bien dans l'ensemble discret de valeurs
+ donné dans le catalogue derrière l'attribut into ou vérifie que valeur est bien compris
+ entre val_min et val_max
+ """
+ into = 1
+ try:
+ self.convert_into(self.valeur)
+ except ValidException,e:
+ if cr == 'oui': self.cr.fatal(str(e))
+ into = 0
+ return into
+
+ def convert_type(self,valeur):
+ """
+ Cette methode verifie que valeur est du bon type
+ Si c'est le cas elle retourne valeur eventuellement convertie
+ Si ce n'est pas le cas, elle leve une exception
+ """
+ if self.definition.type is None: return valeur
+
+ if valeur == None :
+ raise ValidException("None n'est pas une valeur autorisée")
+
+ adapt = getattr(valeur, '__adapt__', None)
+ if adapt is not None:
+ # l'objet valeur peut se verifier lui meme
+ return adapt(self.convert_type)
+
+ if type(valeur) == types.TupleType and not valeur[0] in ('RI','MP') or type(valeur) == types.ListType:
+ # Cas d'une liste de valeurs
+ # on s'arrete a la premiere erreur
+ for val in valeur:
+ self.convert_type(val)
+ return valeur
+
+ # Ici, valeur est un scalaire ...il faut tester sur tous les types ou les valeurs possibles
+ for type_permis in self.definition.type:
+ if self.check_type(valeur,type_permis) : return valeur
+ # si on sort de la boucle précédente par ici c'est que l'on n'a trouvé aucun type valable --> valeur refusée
+ raise ValidException("%s n'est pas d'un type autorisé" % repr(valeur))
+
+ def check_type(self,valeur,type_permis):
+ """
+ Fonction booléenne qui retourne 1 si valeur est du type type_permis, 0 sinon
+ """
+ if type_permis == 'R':
+ return self.is_reel(valeur)
+ elif type_permis == 'I':
+ return self.is_entier(valeur)
+ elif type_permis == 'C':
+ return self.is_complexe(valeur)
+ elif type_permis == 'TXM':
+ return type(valeur)==types.StringType
+ elif type(type_permis) == types.ClassType:
+ return self.is_object_from(valeur,type_permis)
+ elif type(type_permis) == types.InstanceType:
+ try:
+ return type_permis.__convert__(valeur) is not None
+ except:
+ return 0
+ elif type_permis == 'shell':
+ return self.is_shell(valeur)
+ else:
+ print "Type non encore géré %s" %`type_permis`
+ print self.nom,self.parent.nom,self.jdc.fichier
+ return 0
+
+ def is_complexe(self,valeur):
+ """ Retourne 1 si valeur est un complexe, 0 sinon """
+ if type(valeur) in (types.ComplexType,types.IntType,types.FloatType,types.LongType):
+ # Pour permettre l'utilisation de complexes Python
+ return 1
+ elif type(valeur) != types.TupleType :
+ # On n'autorise pas les listes pour les complexes
+ return 0
+ elif len(valeur) != 3:return 0
+ else:
+ # Un complexe doit etre un tuple de longueur 3 avec 'RI' ou 'MP' comme premiere
+ # valeur suivie de 2 reels.
+ if string.strip(valeur[0]) in ('RI','MP'):
+ try:
+ v1=self.convert_reel(valeur[1]),self.convert_reel(valeur[2])
+ return 1
+ except:
+ return 0
+ else:
+ return 0
+
+ def convert_reel(self,valeur):
+ try:
+ return float(valeur)
+ except:
+ adapt = getattr(valeur, '__adapt__', None)
+ if adapt is not None:
+ # l'objet valeur peut se verifier lui meme
+ return adapt(self.convert_reel)
+ raise ValidException("%s n'est pas un reel" % repr(valeur))
+
+ def is_reel(self,valeur):
+ """
+ Retourne 1 si valeur est un reel, 0 sinon
+ """
+ if type(valeur) not in (types.IntType,types.FloatType,types.LongType):
+ # ce n'est pas un réel
+ return 0
+ else:
+ return 1
+
+ def is_entier(self,valeur):
+ """ Retourne 1 si valeur est un entier, 0 sinon """
+ if type(valeur) not in (types.IntType,types.LongType):
+ # ce n'est pas un entier
+ return 0
+ else:
+ return 1
+
+ def is_shell(self,valeur):
+ """
+ Retourne 1 si valeur est un shell, 0 sinon
+ Pour l'instant aucune vérification n'est faite
+ On impose juste que valeur soit une string
+ """
+ if type(valeur) != types.StringType:
+ return 0
+ else:
+ return 1
+
+ def is_object_from(self,objet,classe):
+ """
+ Retourne 1 si objet est une instance de la classe classe, 0 sinon
+ """
+ convert = getattr(classe, '__convert__', None)
+ if convert is not None:
+ # classe verifie les valeurs
+ try:
+ v= convert(objet)
+ if v is None:return 0
+ else:return 1
+ except:
+ return 0
+ if type(objet) != types.InstanceType :
+ return 0
+ if isinstance(objet,classe) :
+ # On accepte les instances de la classe et des classes derivees
+ return 1
+
+ return 0
+
+ def verif_type(self,val=None,cr='non'):
+ """
+ FONCTION :
+ Cette methode verifie que le type de l'argument val est en conformite avec celui
+ qui est declare dans la definition du mot cle simple.
+ Elle a plusieurs modes de fonctionnement liés à la valeur de cr.
+ Si cr vaut 'oui' : elle remplit le compte-rendu self.cr sinon elle ne le remplit pas.
+ PARAMETRE DE RETOUR :
+ Cette méthode retourne une valeur booléenne qui vaut 1 si le type de val est correct ou 0 sinon
+
+ """
+ try:
+ self.convert_type(val)
+ return 1
+ except ValidException,e:
+ if cr == 'oui': self.cr.fatal(str(e))
+ return 0
+
def isvalid(self,cr='non'):
"""
Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP
self.cr.fatal("None n'est pas une valeur autorisée")
else:
# type,into ...
- #PN ??? je n ose pas y toucher ???
- #if v.__class__.__name__ in ('PARAMETRE','EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'):
- if ((issubclass(v.__class__,param2.Formula)) or
- (v.__class__.__name__ in ('EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'))):
- verif_type=self.verif_typeihm(v)
- else:
- verif_type=self.verif_type(val=v,cr=None)
- # cas des tuples avec un ITEM_PARAMETRE
- if verif_type == 0:
- if type(v) == types.TupleType :
- new_val=[]
- for i in v:
- if ((issubclass(i.__class__,param2.Formula)) or
- (i.__class__.__name__ in ('EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'))):
- if self.verif_typeihm(val=i,cr=cr) == 0:
- verif_type = 0
- break
- else:
- new_val.append(i)
- if new_val != [] :
- verif_type=self.verif_type(val=new_val,cr=cr)
- else :
- # Cas d une liste de paramétre
- verif_type=self.verif_typeliste(val=v,cr=cr)
- else:
- verif_type=self.verif_type(val=v,cr=cr)
- valid = verif_type*self.verif_into(cr=cr)*self.verif_card(cr=cr)
+ valid = self.verif_type(val=v,cr=cr)*self.verif_into(cr=cr)*self.verif_card(cr=cr)
#
# On verifie les validateurs s'il y en a et si necessaire (valid == 1)
#
- if valid and self.definition.validators and not self.definition.validators.verif(self.valeur):
- if cr == 'oui' :
- self.cr.fatal(string.join(("Mot-clé : ",self.nom,"devrait avoir ",self.definition.validators.info())))
- valid=0
+ if valid and self.definition.validators:
+ try:
+ self.definition.validators.convert(self.valeur)
+ except ValidException,e:
+ if cr == 'oui' :
+ self.cr.fatal(string.join(("Mot-clé : ",self.nom,"devrait avoir ",self.definition.validators.info())))
+ valid=0
# fin des validateurs
#
- # cas d un item Parametre
- if self.valeur.__class__.__name__ == 'ITEM_PARAMETRE':
- valid=self.valeur.isvalid()
- if valid == 0:
- if cr == 'oui' :
- self.cr.fatal(string.join( repr (self.valeur), " a un indice incorrect"))
-
self.set_valid(valid)
return self.valid
val.eval()
return 1
except :
- pass
+ traceback.print_exc()
+ pass
return self.verif_type(val,cr)
def verif_typeliste(self,val,cr='non') :
for v in val :
verif=verif+self.verif_typeihm(v,cr)
return verif
-
+
Ces comportements pourront etre rapatries dans le Noyau quand leur
interface sera stabilisée.
"""
+class ValidException(Exception):pass
import types
+from I_MCSIMP import ValidException
class Valid:
"""
que l'on trouve dans Ihm.
"""
-class ListVal(Valid):pass
+class ListVal(Valid):
+ """
+ Cette classe sert de classe mère pour tous les validateurs qui acceptent
+ des listes.
+ """
+ def is_list(self):
+ return 1
+
+ def get_into(self,liste_courante=None,into_courant=None):
+ """
+ Cette méthode get_into effectue un traitement général qui consiste
+ a filtrer la liste de choix into_courant, si elle existe, en ne
+ conservant que les valeurs valides (appel de la méthode valid).
+ """
+ if into_courant is None:
+ return None
+ else:
+ liste_choix=[]
+ for e in into_courant:
+ if self.verif(e):
+ liste_choix.append(e)
+ return liste_choix
+
+ def convert(self,valeur):
+ """
+ Méthode verif pour les validateurs de listes. Cette méthode
+ fait appel à la méthode verif_item sur chaque élément de la
+ liste. Si valeur est un paramètre, on utilise sa valeur effective
+ valeur.valeur.
+ """
+ if type(valeur) in (types.ListType,types.TupleType):
+ for val in valeur:
+ self.convert_item(val)
+ return valeur
+ else:
+ return self.convert_item(valeur)
+
+
+class RangeVal(ListVal):
+ def convert_item(self,valeur):
+ if valeur > self.low and valeur < self.high:return valeur
+ raise ValidException("%s devrait etre comprise entre %s et %s" %(valeur,self.low,self.high))
+
+
+class CardVal(Valid):
+ def convert(self,valeur):
+ if type(valeur) in (types.ListType,types.TupleType):
+ l=len(valeur)
+ elif valeur is None:
+ l=0
+ else:
+ l=1
+ if self.max != '**' and l > self.max:raise ValidException("%s devrait etre de longueur inferieure a %s" %(valeur,self.max))
+ if self.min != '**' and l < self.min:raise ValidException("%s devrait etre de longueur superieure a %s" %(valeur,self.min))
+ return valeur
-class RangeVal(ListVal):pass
-class CardVal(Valid):pass
+class PairVal(ListVal):
+ def convert(self,valeur):
+ if type(valeur) in (types.ListType,types.TupleType):
+ for val in valeur:
+ if val % 2 != 0:raise ValidException("%s contient des valeurs non paires" % repr(valeur))
+ else:
+ if valeur % 2 != 0:raise ValidException("%s n'est pas pair" % repr(valeur))
+ return valeur
-class PairVal(ListVal):pass
-class EnumVal(ListVal):pass
+
+class EnumVal(ListVal):
+ def convert_item(self,valeur):
+ if valeur in self.into:return valeur
+ raise ValidException("%s contient des valeurs hors des choix possibles: %s " %(valeur,self.into))
+
-class NoRepeat(ListVal):pass
+class NoRepeat(ListVal):
+ """
+ Verification d'absence de doublons dans la liste.
+ """
+ def __init__(self):
+ self.cata_info=""
+
+ def info(self):
+ return ": pas de présence de doublon dans la liste"
+
+ def info_erreur_liste(self):
+ return "Les doublons ne sont pas permis"
-class LongStr(ListVal):pass
+ def verif_item(self,valeur):
+ return 1
+
+ def verif(self,valeur):
+ if type(valeur) in (types.ListType,types.TupleType):
+ liste=list(valeur)
+ for val in liste:
+ if liste.count(val)!=1 : return 0
+ return 1
+ else:
+ return 1
+
+ def convert_item(self,valeur):
+ if valeur in self.liste : raise ValidException("%s est un doublon" % valeur)
+ return valeur
+
+ def convert(self,valeur):
+ adapt = getattr(valeur, '__adapt__', None)
+ if adapt is not None:
+ # l'objet valeur peut se verifier lui meme
+ return adapt(self.convert)
+
+ if type(valeur) == types.TupleType and not valeur[0] in ('RI','MP') or type(valeur) == types.ListType:
+ # Cas d'une liste de valeurs
+ # on s'arrete a la premiere erreur
+ self.liste=[]
+ for val in valeur:
+ adapt = getattr(val, '__adapt__', None)
+ if adapt is not None:
+ v=adapt(self.convert_item)
+ else:
+ v=self.convert_item(val)
+ self.liste.append(v)
+ return valeur
+
+ def get_into(self,liste_courante=None,into_courant=None):
+ """
+ Methode get_into spécifique pour validateur NoRepeat, on retourne
+ une liste de choix qui ne contient aucune valeur de into_courant
+ déjà contenue dans liste_courante
+ """
+ if into_courant is None:
+ liste_choix=None
+ else:
+ liste_choix=[]
+ for e in into_courant:
+ if e in liste_choix: continue
+ if liste_courante is not None and e in liste_courante: continue
+ liste_choix.append(e)
+ return liste_choix
+
+
+class LongStr(ListVal):
+ """
+ Verification de la longueur d une chaine
+ """
+ def __init__(self,low,high):
+ self.low=low
+ self.high=high
+ self.cata_info=""
+
+ def info(self):
+ return "longueur de la chaine entre %s et %s" %(self.low,self.high)
+
+ def info_erreur_item(self):
+ return "Longueur de la chaine incorrecte"
+
+ def verif_item(self,valeur):
+ low=self.low
+ high=self.high
+ if valeur[0]=="'" and valeur[-1]=="'" :
+ low=low+2
+ high=high+2
+ if len(valeur) < low :return 0
+ if len(valeur) > high:return 0
+ return 1
+
+ def convert(self,valeur):
+ adapt = getattr(valeur, '__adapt__', None)
+ if adapt is not None:
+ # l'objet valeur peut se verifier lui meme
+ return adapt(self.convert)
+
+ if type(valeur) == types.TupleType and not valeur[0] in ('RI','MP') or type(valeur) == types.ListType:
+ # Cas d'une liste de valeurs
+ # on s'arrete a la premiere erreur
+ for val in valeur:
+ self.convert_item(val)
+ return valeur
+ else:
+ return self.convert_item(valeur)
+
+ def convert_item(self,valeur):
+ low=self.low
+ high=self.high
+ if valeur[0]=="'" and valeur[-1]=="'" :
+ low=low+2
+ high=high+2
+ if len(valeur) < low or len(valeur) > high :
+ raise ValidException("%s n'est pas de la bonne longueur" % repr(valeur))
+ return valeur
+
+
+
+class OrdList(ListVal):
+ def convert(self,valeur):
+ if type(valeur) in (types.ListType,types.TupleType):
+ if self.ord=='croissant':
+ var=valeur[0]
+ for val in valeur[1:]:
+ if val<var:raise ValidException("%s n'est pas par valeurs croissantes" % repr(valeur))
+ var=val
+ return valeur
+ elif self.ord=='decroissant':
+ var=valeur[0]
+ for val in valeur[1:]:
+ if val>var:raise ValidException("%s n'est pas par valeurs decroissantes" % repr(valeur))
+ var=val
+ return valeur
+ else:
+ return valeur
-class OrdList(ListVal):pass
CoercableFuncs = { types.IntType: int,
types.LongType: long,
types.ComplexType: complex,
types.UnicodeType: unicode }
-class TypeVal(ListVal):pass
+class TypeVal(ListVal):
+ def convert_item(self,valeur):
+ return self.coerce(valeur)
class InstanceVal(ListVal):pass
class FunctionVal(Valid):pass
-class OrVal(Valid):pass
-
-class AndVal(Valid):pass
+class OrVal(Valid):
+ def convert(self,valeur):
+ for validator in self.validators:
+ try:
+ return validator.verif(valeur)
+ except:
+ pass
+ raise ValidException("%s n'est pas du bon type" % valeur)
+class AndVal(Valid):
+ def convert(self,valeur):
+ for validator in self.validators:
+ valeur=validator.convert(valeur)
+ return valeur
# courante pendant le processus de construction des étapes.
# Si on insère des commandes (par ex, dans EFICAS), il faut préalablement
# remettre ce pointeur à 0
- if etape:
+ if etape is not None:
index_etape=self.etapes.index(etape)
else:
index_etape=len(self.etapes)
Cette méthode indique si valeur est un objet de type PARAMETRE
dont on cherchera à evaluer la valeur (valeur.valeur)
"""
- return type(valeur) == types.InstanceType and valeur.__class__.__name__ in ('PARAMETRE',)
+ #return type(valeur) == types.InstanceType and valeur.__class__.__name__ in ('PARAMETRE',)
+ return 0
def is_unknown(self,valeur):
"""
--- /dev/null
+"""
+Copyright (c) 2004, Wai Yip Tung
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+* Neither the name of the Wai Yip Tung nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+A TestRunner for use with the Python unit testing framework. It
+generates a HTML report to show the result at a glance.
+
+The simplest way to use this is to invoke its main method. E.g.
+
+ import unittest
+ import HTMLTestRunner
+
+ ... define your tests ...
+
+ if __name__ == '__main__':
+ HTMLTestRunner.main()
+
+It defines the class HTMLTestRunner, which is a counterpart of unittest's
+TextTestRunner. You can also instantiates a HTMLTestRunner object for
+finer control.
+"""
+
+# URL: http://tungwaiyip.info/software
+
+__author__ = "Wai Yip Tung"
+__version__ = "0.7"
+
+
+# TOOD: need to make sure all HTML and JavaScript blocks are properly escaped!
+# TODO: allow link to custom CSS
+# TODO: color stderr
+# TODO: simplify javascript using ,ore than 1 class in the class attribute?
+
+import datetime
+import string
+import StringIO
+import sys
+import time
+import unittest
+from xml.sax import saxutils
+
+
+# ------------------------------------------------------------------------
+# The redirectors below is used to capture output during testing. Output
+# sent to sys.stdout and sys.stderr are automatically captured. However
+# in some cases sys.stdout is already cached before HTMLTestRunner is
+# invoked (e.g. calling logging.basicConfig). In order to capture those
+# output, use the redirectors for the cached stream.
+#
+# e.g.
+# >>> logging.basicConfig(stream=HTMLTestRunner.stdout_redirector)
+# >>>
+
+class OutputRedirector(object):
+ """ Wrapper to redirect stdout or stderr """
+ def __init__(self, fp):
+ self.fp = fp
+
+ def write(self, s):
+ self.fp.write(s)
+
+ def writelines(self, lines):
+ self.fp.writelines(lines)
+
+ def flush(self):
+ self.fp.flush()
+
+stdout_redirector = OutputRedirector(sys.stdout)
+stderr_redirector = OutputRedirector(sys.stderr)
+
+
+
+# ----------------------------------------------------------------------
+# Template
+
+STATUS = {
+0: 'pass',
+1: 'fail',
+2: 'error',
+}
+
+
+CSS = """
+<style>
+body { font-family: verdana, arial, helvetica, sans-serif; font-size: 80%; }
+table { font-size: 100%; }
+pre { }
+h1 { }
+.heading {
+ margin-top: 0ex;
+ margin-bottom: 1ex;
+}
+#show_detail_line {
+ margin-top: 3ex;
+ margin-bottom: 1ex;
+}
+#result_table {
+ width: 80%;
+ border-collapse: collapse;
+ border: medium solid #777;
+}
+#result_table td {
+ border: thin solid #777;
+ padding: 2px;
+}
+#header_row {
+ font-weight: bold;
+ color: white;
+ background-color: #777;
+}
+#total_row { font-weight: bold; }
+.passClass { background-color: #6c6; }
+.failClass { background-color: #c60; }
+.errorClass { background-color: #c00; }
+.passCase { color: #6c6; }
+.failCase { color: #c60; font-weight: bold; }
+.errorCase { color: #c00; font-weight: bold; }
+.hiddenRow { display: none; }
+.testcase { margin-left: 2em; }
+#btm_filler { margin-top: 50%; }
+</style>
+"""
+
+# currently not used
+CSS_LINK = '<link rel="stylesheet" href="$url" type="text/css">\n'
+
+
+HTML_TMPL = string.Template(r"""
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html>
+<head>
+ <title>$title</title>
+ <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+ $css
+</head>
+<body>
+<script>
+output_list = Array();
+
+/* level - 0:Summary; 1:Failed; 2:All */
+function showCase(level) {
+ trs = document.getElementsByTagName("tr");
+ for (var i = 0; i < trs.length; i++) {
+ tr = trs[i];
+ id = tr.id;
+ if (id.substr(0,2) == 'ft') {
+ if (level < 1) {
+ tr.className = 'hiddenRow';
+ }
+ else {
+ tr.className = '';
+ }
+ }
+ if (id.substr(0,2) == 'pt') {
+ if (level > 1) {
+ tr.className = '';
+ }
+ else {
+ tr.className = 'hiddenRow';
+ }
+ }
+ }
+}
+
+function showClassDetail(cid, count) {
+ var id_list = Array(count);
+ var toHide = 1;
+ for (var i = 0; i < count; i++) {
+ tid0 = 't' + cid.substr(1) + '.' + (i+1);
+ tid = 'f' + tid0;
+ tr = document.getElementById(tid);
+ if (!tr) {
+ tid = 'p' + tid0;
+ tr = document.getElementById(tid);
+ }
+ id_list[i] = tid;
+ if (tr.className) {
+ toHide = 0;
+ }
+ }
+ for (var i = 0; i < count; i++) {
+ tid = id_list[i];
+ if (toHide) {
+ document.getElementById(tid).className = 'hiddenRow';
+ }
+ else {
+ document.getElementById(tid).className = '';
+ }
+ }
+}
+
+function showOutput(id, name) {
+ w = window.open("", //url
+ name,
+ "resizable,status,width=800,height=450");
+ d = w.document;
+ d.write("<pre>");
+ d.write(output_list[id]);
+ d.write("\n");
+ d.write("<a href='javascript:window.close()'>close</a>\n");
+ d.write("</pre>\n");
+ d.close();
+}
+
+</script>
+
+<h1>$description</h1>
+<p class='heading'><strong>Time:</strong> $time</p>
+<p class='heading'><strong>Status:</strong> $status</p>
+<p id='show_detail_line'>Show
+<a href='javascript:showCase(0)'>Summary</a>
+<a href='javascript:showCase(1)'>Failed</a>
+<a href='javascript:showCase(2)'>All</a>
+</p>
+<table id='result_table'>
+<colgroup>
+<col align='left' />
+<col align='right' />
+<col align='right' />
+<col align='right' />
+<col align='right' />
+<col align='right' />
+</colgroup>
+<tr id='header_row'>
+ <td>Class/Test case</td>
+ <td>Count</td>
+ <td>Pass</td>
+ <td>Fail</td>
+ <td>Error</td>
+ <td>View</td>
+</tr>
+$tests
+<tr id='total_row'>
+ <td>Total</td>
+ <td>$count</td>
+ <td>$Pass</td>
+ <td>$fail</td>
+ <td>$error</td>
+ <td> </td>
+</tr>
+</table>
+<div id='btm_filler' />
+</body>
+</html>
+""")
+
+CLASS_TMPL = string.Template(r"""
+<tr class='$style'>
+ <td>$name</td>
+ <td>$count</td>
+ <td>$Pass</td>
+ <td>$fail</td>
+ <td>$error</td>
+ <td><a href="javascript:showClassDetail('$cid',$count)">Detail</a></td>
+</tr>
+""")
+
+TEST_TMPL = string.Template(r"""
+<tr id='$tid' class='$Class'>
+ <td class='$style'><div class='testcase'>$name<div></td>
+ <td colspan='5' align='center'><a href="javascript:showOutput('$tid', '$name')">$status</a></td>
+</tr>
+""")
+
+TEST_TMPL_NO_OUTPUT = string.Template(r"""
+<tr id='$tid' class='$Class'>
+ <td class='$style'><div class='testcase'>$name<div></td>
+ <td colspan='5' align='center'>$status</td>
+</tr>
+""")
+
+TEST_OUTPUT_TMPL = string.Template(r"""
+<script>output_list['$id'] = '$output';</script>
+""")
+
+
+# ----------------------------------------------------------------------
+
+TestResult = unittest.TestResult
+
+class _TestResult(TestResult):
+ # note: _TestResult is a pure representation of results.
+ # It lacks the output and reporting ability compares to unittest._TextTestResult.
+
+ def __init__(self, verbosity=1):
+ TestResult.__init__(self)
+ self.stdout0 = None
+ self.stderr0 = None
+ self.verbosity = verbosity
+
+ # result is a list of result in 4 tuple
+ # (
+ # result code (0: success; 1: fail; 2: error),
+ # TestCase object,
+ # Test output (byte string),
+ # stack trace,
+ # )
+ self.result = []
+
+
+ def startTest(self, test):
+ TestResult.startTest(self, test)
+ # just one buffer for both stdout and stderr
+ self.outputBuffer = StringIO.StringIO()
+ stdout_redirector.fp = self.outputBuffer
+ stderr_redirector.fp = self.outputBuffer
+ self.stdout0 = sys.stdout
+ self.stderr0 = sys.stderr
+ sys.stdout = stdout_redirector
+ sys.stderr = stderr_redirector
+
+
+ def complete_output(self):
+ """
+ Disconnect output redirection and return buffer.
+ Safe to call multiple times.
+ """
+ if self.stdout0:
+ sys.stdout = self.stdout0
+ sys.stderr = self.stderr0
+ self.stdout0 = None
+ self.stderr0 = None
+ return self.outputBuffer.getvalue()
+
+
+ def stopTest(self, test):
+ # Usually one of addSuccess, addError or addFailure would have been called.
+ # But there are some path in unittest that would bypass this.
+ # We must disconnect stdout in stopTest(), which is guaranteed to be called.
+ self.complete_output()
+
+
+ def addSuccess(self, test):
+ TestResult.addSuccess(self, test)
+ output = self.complete_output()
+ self.result.append((0, test, output, ''))
+ if self.verbosity > 1:
+ sys.stderr.write('ok ')
+ sys.stderr.write(str(test))
+ sys.stderr.write('\n')
+ else:
+ sys.stderr.write('.')
+
+ def addError(self, test, err):
+ TestResult.addError(self, test, err)
+ output = self.complete_output()
+ self.result.append((2, test, output, self._exc_info_to_string(err, test)))
+ if self.verbosity > 1:
+ sys.stderr.write('E ')
+ sys.stderr.write(str(test))
+ sys.stderr.write('\n')
+ else:
+ sys.stderr.write('E')
+
+ def addFailure(self, test, err):
+ TestResult.addFailure(self, test, err)
+ output = self.complete_output()
+ self.result.append((1, test, output, self._exc_info_to_string(err, test)))
+ if self.verbosity > 1:
+ sys.stderr.write('F ')
+ sys.stderr.write(str(test))
+ sys.stderr.write('\n')
+ else:
+ sys.stderr.write('F')
+
+
+class HTMLTestRunner:
+ """
+ """
+ def __init__(self, stream=sys.stdout, descriptions=1, verbosity=1, description='Test'):
+ # unittest itself has no good mechanism for user to define a
+ # description neither in TestCase nor TestSuite. Allow user to
+ # pass in the description as a parameter.
+
+ # note: this is different from unittest.TextTestRunner's
+ # 'descrpitions' parameter, which is an integer flag.
+
+ self.stream = stream
+ self.startTime = datetime.datetime.now()
+ self.description = description
+ self.verbosity = verbosity
+
+ def run(self, test):
+ "Run the given test case or test suite."
+ result = _TestResult(self.verbosity)
+ test(result)
+ self.stopTime = datetime.datetime.now()
+ self.generateReport(test, result)
+ print >>sys.stderr, '\nTime Elapsed: %s' % (self.stopTime-self.startTime)
+ return result
+
+ def sortResult(self, result_list):
+ # unittest does not seems to run in any particular order.
+ # Here at least we want to group them together by class.
+ rmap = {}
+ classes = []
+ for n,t,o,e in result_list:
+ cls = t.__class__
+ if not rmap.has_key(cls):
+ rmap[cls] = []
+ classes.append(cls)
+ rmap[cls].append((n,t,o,e))
+ r = [(cls, rmap[cls]) for cls in classes]
+ return r
+
+ def generateReport(self, test, result):
+ rows = []
+ npAll = nfAll = neAll = 0
+ sortedResult = self.sortResult(result.result)
+ for cid, (cls, cls_results) in enumerate(sortedResult):
+ # update counts
+ np = nf = ne = 0
+ for n,t,o,e in cls_results:
+ if n == 0: np += 1
+ elif n == 1: nf += 1
+ else: ne += 1
+ npAll += np
+ nfAll += nf
+ neAll += ne
+
+ row = CLASS_TMPL.safe_substitute(
+ style = ne > 0 and 'errorClass' or nf > 0 and 'failClass' or 'passClass',
+ name = "%s.%s" % (cls.__module__, cls.__name__),
+ count = np+nf+ne,
+ Pass = np,
+ fail = nf,
+ error = ne,
+ cid = 'c%s' % (cid+1),
+ )
+ rows.append(row)
+
+ for tid, (n,t,o,e) in enumerate(cls_results):
+ # e.g. 'pt1.1', 'ft1.1', etc
+ has_output = bool(o or e)
+ tid = (n == 0 and 'p' or 'f') + 't%s.%s' % (cid+1,tid+1)
+ name = t.id().split('.')[-1]
+ tmpl = has_output and TEST_TMPL or TEST_TMPL_NO_OUTPUT
+ row = tmpl.safe_substitute(
+ tid = tid,
+ Class = (n == 0 and 'hiddenRow' or ''),
+ style = n == 2 and 'errorCase' or (n == 1 and 'failCase' or ''),
+ name = name,
+ status = STATUS[n],
+ )
+ rows.append(row)
+ if has_output:
+ # o and e should be byte string because they are collected from stdout and stderr?
+ if isinstance(o,str):
+# TODO: some problem with 'string_escape': it escape \n and mess up formating
+# uo = unicode(o.encode('string_escape'))
+ uo = o.decode('latin-1')
+ else:
+ uo = o
+ if isinstance(e,str):
+# TODO: some problem with 'string_escape': it escape \n and mess up formating
+# ue = unicode(e.encode('string_escape'))
+ ue = e.decode('latin-1')
+ else:
+ ue = e
+ row = TEST_OUTPUT_TMPL.safe_substitute(
+ id = tid,
+ output = saxutils.escape(uo+ue) \
+ .replace("'", ''') \
+ .replace('"', '"') \
+ .replace('\\','\\\\') \
+ .replace('\r','\\r') \
+ .replace('\n','\\n'),
+ )
+ rows.append(row)
+
+ report = HTML_TMPL.safe_substitute(
+ title = self.description,
+ css = CSS,
+ description = self.description,
+ time = str(self.startTime)[:19],
+ status = result.wasSuccessful() and 'Passed' or 'Failed',
+ tests = ''.join(rows),
+ count = str(npAll+nfAll+neAll),
+ Pass = str(npAll),
+ fail = str(nfAll),
+ error = str(neAll),
+ )
+ self.stream.write(report.encode('utf8'))
+
+
+##############################################################################
+# Facilities for running tests from the command line
+##############################################################################
+
+# Note: Reuse unittest.TestProgram to launch test. In the future we may
+# build our own launcher to support more specific command line
+# parameters like test title, CSS, etc.
+class TestProgram(unittest.TestProgram):
+ """
+ A variation of the unittest.TestProgram. Please refer to the base
+ class for command line parameters.
+ """
+ def runTests(self):
+ # Pick HTMLTestRunner as the default test runner.
+ # base class's testRunner parameter is not useful because it means
+ # we have to instantiate HTMLTestRunner before we know self.verbosity.
+ if self.testRunner is None:
+ self.testRunner = HTMLTestRunner(verbosity=self.verbosity)
+ unittest.TestProgram.runTests(self)
+
+main = TestProgram
+
+##############################################################################
+# Executing this module from the command line
+##############################################################################
+
+if __name__ == "__main__":
+ main(module=None)
--- /dev/null
+
+import sys
+sys.path.insert(0,"../Aster")
+import prefs
+ASTERDIR="/local/chris/ASTER/instals/STA8.2/astest"
+
+"""
+This program executes all unitest tests that are found in
+ - directories with name test* or Test*
+ - files with name test* or Test*
+
+unitest tests are :
+ - functions and class with names test* or Test*
+ - methods with name test* or Test* from classes with name test* or Test*
+
+Typical uses are :
+
+ - execute all tests with text output : python2.4 run.py
+ - execute all tests with html output : python2.4 run.py --html
+ - execute some tests with text output : python2.4 run.py testelem
+ - execute one test with text output : python2.4 run.py testelem/testsimp1.py
+ - execute all tests with verbosity and html output : python2.4 run.py -v --html
+"""
+
import sys,types,os
import sre
import unittest
from optparse import OptionParser
-sys.path[:0]=[".."]
+import config
testMatch = sre.compile(r'^[Tt]est')
class TestSuite(unittest.TestSuite):
+ ignore=[]
loader = unittest.defaultTestLoader
def __init__(self, names=[]):
mod = getattr(mod,comp)
return mod
+ def importdir(self,rep,path):
+ init = os.path.abspath(os.path.join(path,'__init__.py'))
+ if os.path.isfile(init):
+ package=self._import(rep)
+ if package:
+ return TestPackageSuite(package)
+ else:
+ return TestDirectorySuite(path)
+
+ def importfile(self,item,path):
+ root, ext = os.path.splitext(item)
+ if ext != '.py':
+ return
+ if root.find('/') >= 0:
+ dirname, file = os.path.split(path)
+ root, ext = os.path.splitext(file)
+ sys.path.insert(0,dirname)
+ mod=self._import(root)
+ sys.path.remove(dirname)
+ else:
+ mod=self._import(root)
+ return ModuleTestSuite(mod)
+
def collectTests(self):
if self.names:
entries=self.names
else:
entries = [ item for item in os.listdir(os.getcwd())
if item.lower().find('test') >= 0 ]
+ self.path=os.getcwd()
+ return self._collectTests(entries)
+ def _collectTests(self,entries):
tests=[]
for item in entries:
- path=os.path.abspath(os.path.join(os.getcwd(),item))
- if os.path.isfile(item):
- root, ext = os.path.splitext(item)
- if ext == '.py':
- if root.find('/') >= 0:
- dirname, file = os.path.split(path)
- root, ext = os.path.splitext(file)
- sys.path.insert(0,dirname)
- mod=self._import(root)
- sys.path.remove(dirname)
- else:
- mod=self._import(root)
- tests.append(ModuleTestSuite(mod))
- elif os.path.isdir(item):
- init = os.path.abspath(os.path.join(item,'__init__.py'))
- if os.path.isfile(init):
- package=self._import(item)
- if package:
- tests.append(TestPackageSuite(package))
- else:
- tests.append(TestDirectorySuite(path))
+ if (item[0] == '.'
+ or item in self.ignore
+ or not testMatch.search(item)):
+ continue
+ path=os.path.abspath(os.path.join(self.path,item))
+ if os.path.isfile(path):
+ t=self.importfile(item,path)
+ if t:tests.append(t)
+ elif os.path.isdir(path):
+ tests.append(self.importdir(item,path))
return tests
class TestDirectorySuite(TestSuite):
- ignore=[]
def __init__(self,path):
self.path=path
super(TestDirectorySuite,self).__init__()
sys.path.insert(0,self.path)
entries = os.listdir(self.path)
entries.sort()
- for item in entries:
- if (item[0] == '.'
- or item in self.ignore
- or not testMatch.search(item)):
- continue
- item_path = os.path.abspath(os.path.join(self.path,item))
- if os.path.isfile(item_path):
- root, ext = os.path.splitext(item)
- if ext != '.py':
- continue
- if root.find('/') >= 0:
- dirname, file = os.path.split(item_path)
- root, ext = os.path.splitext(file)
- sys.path.insert(0,dirname)
- mod=self._import(root)
- sys.path.remove(dirname)
- else:
- mod=self._import(root)
- tests.append(ModuleTestSuite(mod))
- elif os.path.isdir(item_path):
- init = os.path.abspath(os.path.join(item_path,'__init__.py'))
- if os.path.isfile(init):
- package=self._import(item)
- if package:
- tests.append(TestPackageSuite(package))
- else:
- tests.append(TestDirectorySuite(item_path))
+ tests=self._collectTests(entries)
sys.path.remove(self.path)
return tests
path=os.path.abspath(os.path.dirname(self.package.__file__))
super(TestPackageSuite,self).__init__(path)
- def collectTests(self):
- tests=[]
- if self.path:
- sys.path.insert(0,self.path)
- entries = os.listdir(self.path)
- entries.sort()
- for item in entries:
- if (item[0] == '.'
- or item in self.ignore
- or not testMatch.search(item)):
- continue
- item_path = os.path.abspath(os.path.join(self.path,item))
- if os.path.isfile(item_path):
- root, ext = os.path.splitext(item)
- if ext != '.py':
- continue
- name="%s.%s" % (self.package.__name__,root)
- mod=self._import(name)
- tests.append(ModuleTestSuite(mod))
- elif os.path.isdir(item_path):
- init = os.path.abspath(os.path.join(item_path,'__init__.py'))
- if os.path.isfile(init):
- name="%s.%s" % (self.package.__name__,item)
- package=self._import(name)
- if package:
- tests.append(TestPackageSuite(package))
- else:
- tests.append(TestDirectorySuite(item_path))
- sys.path.remove(self.path)
- return tests
+ def importdir(self,item,path):
+ init = os.path.abspath(os.path.join(path,'__init__.py'))
+ if os.path.isfile(init):
+ name="%s.%s" % (self.package.__name__,item)
+ package=self._import(name)
+ if package:
+ return TestPackageSuite(package)
+ else:
+ return TestDirectorySuite(path)
+ def importfile(self,item,path):
+ root, ext = os.path.splitext(item)
+ if ext != '.py':
+ return
+ name="%s.%s" % (self.package.__name__,root)
+ mod=self._import(name)
+ return ModuleTestSuite(mod)
class ModuleTestSuite(TestSuite):
for test in func_tests ]
return tests
+
class TestProgram(unittest.TestProgram):
USAGE="""
"""
- def __init__(self,testRunner=None):
- self.testRunner = testRunner
+ def __init__(self):
+ self.testRunner = None
self.verbosity = 1
+ self.html=0
self.parseArgs(sys.argv)
+ if self.html:
+ import HTMLTestRunner
+ self.testRunner = HTMLTestRunner.HTMLTestRunner(verbosity=self.verbosity)
self.createTests()
self.runTests()
parser.add_option("-v","--verbose",action="count",
dest="verbosity",default=1,
help="Be more verbose. ")
+ parser.add_option("--html",action="store_true",
+ dest="html",default=0,
+ help="Produce HTML output ")
options, args = parser.parse_args(argv)
self.verbosity = options.verbosity
+ self.html=options.html
if args:
self.names = list(args)
def createTests(self):
self.test = TestSuite(self.names)
-
-main = TestProgram
-
if __name__ == "__main__":
- main()
+ TestProgram()
--- /dev/null
+MM=LIRE_MAILLAGE()
--- /dev/null
+POURSUITE()
+MA=LIRE_MAILLAGE(INFO=inf)
+FIN()
--- /dev/null
+DEBUT()
+inf=1
+p2=inf+1
+p3=sin(p2)
+FIN()
--- /dev/null
+DEBUT()
+inf1=1
+MA=LIRE_MAILLAGE(INFO=inf1)
+INCLUDE_MATERIAU( NOM_AFNOR='18MND5', TYPE_MODELE='REF',
+ VARIANTE='A', TYPE_VALE='NOMI',
+ NOM_MATER='MAT3', INFO=1 )
+
+FIN()
--- /dev/null
+DEBUT()
+a=1
+fmt_raison='-'*80+"""
+
+ Exception erreur_Fatale interceptee
+ Raison : %s
+
+"""+'-'*80+'\n'
+FIN()
--- /dev/null
+from Numeric import cos
+DEBUT()
+RAYCRA=1.
+EPCRA=0.1
+S_CR=3.1415*(RAYCRA**2-(RAYCRA-EPCRA)**2)
+T_CR=3.1415
+NOMF="nomfichier"
+n=2
+
+MA=LIRE_MAILLAGE( )
+
+MO=AFFE_MODELE( MAILLAGE=MA,
+ #test de validateur GEOM (typ=grma) avec grma derive de GEOM
+ AFFE=(_F(GROUP_MA = ('LI1'),
+ PHENOMENE = 'MECANIQUE',
+ MODELISATION = 'DIS_TR'),
+ ),
+ INFO=2,);
+
+carel=[0.]*78
+
+CAREG=AFFE_CARA_ELEM(MODELE=MO,
+ DISCRET=_F(GROUP_MA=('LI1'),
+ CARA = 'K_TR_L',
+ VALE = carel,
+ REPERE='LOCAL' , ),
+ ORIENTATION=(_F(GROUP_MA=('LI1',),
+ CARA='VECT_Y',
+ VALE=(0.,0.,1.),),),
+ AFFE_FIBRE =( _F(GROUP_MA='CRAYON', COOR_AXE_POUTRE = (0.,0.,), CARA='SURFACE', VALE=( 0.,S_CR/4,)),
+ _F(GROUP_MA='CRAYON', COOR_AXE_POUTRE = (0.,0.,), CARA='SURFACE', VALE=( 0.,T_CR,)),
+ _F(GROUP_MA='CRAYON', COOR_AXE_POUTRE = (0.,sin(n*22.5*pi/180),), CARA='SURFACE', VALE=( 0.,T_CR/4,)),
+ _F(GROUP_MA='CRAYON', COOR_AXE_POUTRE = (0.,(cos(n*22.5*pi/180)),), CARA='SURFACE', VALE=( 0.,T_CR/4,)),
+ ),
+ );
+
+DEFI_FICHIER(UNITE=50, FICHIER='./REPE_OUT/zzzz206a_resu.mail')
+#test de validateur LongStr avec parametre instance de PARAMETRE
+DEFI_FICHIER(UNITE=50, FICHIER=NOMF)
+#test de validateur LongStr avec parametre instance de Formula
+u=DEFI_FICHIER( FICHIER=NOMF*2)
+DEFI_FICHIER (ACTION='LIBERER',UNITE=50)
+#test de validateur d'objet entier (typ='I'), instance de la classe entier
+DEFI_FICHIER (ACTION='LIBERER',UNITE=u)
+
+# test de validateur qui accepte tout (typ=assd)
+IMPR_CO(CO=MA)
+
+FIN()
--- /dev/null
+DEBUT()
+a=1
+MA=LIRE_MAILLAGE()
+FIN()
--- /dev/null
+DEBUT()
+MAYA=LIRE_MAILLAGE()
+
+MAYA=DEFI_GROUP( reuse=MAYA, MAILLAGE=MAYA,
+ CREA_GROUP_MA=_F( NOM = 'TOUT', TOUT = 'OUI'))
+
+BARRE1=AFFE_MODELE( MAILLAGE=MAYA,
+ AFFE=_F( GROUP_MA='SS1',
+ MODELISATION = 'POU_D_E',
+ PHENOMENE = 'MECANIQUE'))
+#
+MATERIO1=DEFI_MATERIAU( ELAS=_F( RHO = 1.E08, NU = 0.3, E = 1.E10))
+
+MATERIO2=DEFI_MATERIAU( ELAS=_F( RHO = 0., NU = 0., E = 1.E15))
+#
+CHMAT=AFFE_MATERIAU( MAILLAGE=MAYA,AFFE=(
+ #_F( TOUT = 'OUI', MATER = MATERIO1),
+ _F( GROUP_MA = 'SS1', MATER = MATERIO1),
+ _F( GROUP_MA = 'SS2', MATER = MATERIO1),
+ _F( GROUP_MA = 'SS3', MATER = MATERIO1),
+ _F( GROUP_MA = 'RIGIDE', MATER = MATERIO2),
+)) # commentaire test
+
+CARA1=AFFE_CARA_ELEM( MODELE=BARRE1,
+ POUTRE=_F(
+ GROUP_MA = 'TOUT',
+ SECTION = 'CERCLE',
+ CARA = ('R', 'EP',),
+ VALE = (0.1, 0.01,)))
+
+GUIDAGE1=AFFE_CHAR_MECA( MODELE=BARRE1,DDL_IMPO=(
+ _F( GROUP_MA='SS1',
+ DX = 0., DZ = 0., DRX = 0., DRY = 0.),
+ _F( GROUP_NO = 'L1', DY = 0., DRZ = 0.),
+ ))
+
+K_ELEM1=CALC_MATR_ELEM( MODELE=BARRE1,
+ CARA_ELEM=CARA1,
+ CHAM_MATER=CHMAT,
+ OPTION='RIGI_MECA',
+ CHARGE=GUIDAGE1)
+
+NUM1=NUME_DDL( MATR_RIGI=K_ELEM1)
+
+#
+K_ASSE1=ASSE_MATRICE( MATR_ELEM=K_ELEM1,
+ NUME_DDL=NUM1)
+
+MODESTA1=MODE_STATIQUE( MATR_RIGI=K_ASSE1,
+ MODE_STAT=_F(
+ GROUP_NO=('L12'),
+ AVEC_CMP = ('DY','DRZ'),
+ ))
+
+# parse: -affectation
+
+DS1=[None]*5
+DS2=[None]*5
+DS3=[None]*5
+DS4=[None]*5
+CHS1=[None]*5
+CHS2=[None]*5
+
+# parse: +affectation
+
+for k in range(1,5):
+ DS1[k] = CREA_CHAMP( OPERATION='EXTR', TYPE_CHAM='NOEU_DEPL_R',
+ RESULTAT= MODESTA1, NUME_ORDRE=k, NOM_CHAM = 'DEPL');
+
+FIN()
--- /dev/null
+DEPL2 = FORMULE(NOM_PARA='INST',VALE='sin(OMEGAA*INST)/(OMEGAA**xx)')
+DEPLACE2=CALC_FONC_INTERP( FONCTION=DEPL2,
+ LIST_PARA=L_INST,
+ NOM_PARA='INST',
+ PROL_DROITE='LINEAIRE',
+ PROL_GAUCHE='LINEAIRE',
+ NOM_RESU='DEPL' )
+
+MONO_X=CALC_CHAR_SEISME( MATR_MASS=MASSE,
+ DIRECTION=( 1., 0., 0.,),
+ MONO_APPUI='OUI' )
+
+
+MACRO_PROJ_BASE(BASE=MODE_MEC,MATR_ASSE_GENE=(
+ _F( MATRICE = CO("MASS_GEN"), MATR_ASSE = MASSE),
+ _F( MATRICE = CO("RIGI_GEN"), MATR_ASSE = RIGIDITE)),
+ VECT_ASSE_GENE=_F( VECTEUR = CO("VECT_X"), VECT_ASSE = MONO_X)
+ )
+
--- /dev/null
+POURSUITE(CODE=_F( NOM = 'EFICA01A'))
+
+INCLUDE_MATERIAU( NOM_AFNOR='18MND5', TYPE_MODELE='REF',
+ VARIANTE='A', TYPE_VALE='NOMI',
+ NOM_MATER='MAT3', INFO=1 )
+
+CHMAT3=AFFE_MATERIAU( MAILLAGE=MAILLA3,
+ AFFE=_F( TOUT='OUI', MATER = MAT3, TEMP_REF = 20.))
+
+riginor = 2.88E7
+
+TRAN_GE2=DYNA_TRAN_MODAL( MASS_GENE=MGEN_BIC, RIGI_GENE=RGEN_BIC,
+ METHODE='EULER',
+ AMOR_REDUIT=( 0.07, 0.07, ),
+ MODE_STAT=MSTA_BIC,EXCIT=(
+ _F( VECT_GENE = VECT_X1, ACCE = ACCELER1,
+ MULT_APPUI = 'OUI',
+ DIRECTION = ( 1., 0., 0.,), NOEUD = 'NO1',
+ VITE = VITESSE1, DEPL = DEPLACE1),
+ _F( VECT_GENE = VECT_X2, ACCE = ACCELER2,
+ MULT_APPUI = 'OUI',
+ DIRECTION = ( 1., 0., 0.,), NOEUD = 'NO11',
+ VITE = VITESSE2, DEPL = DEPLACE2)),
+ CHOC=_F( GROUP_NO_1 = 'MASSES1',
+ GROUP_NO_2 = 'MASSES2',
+ OBSTACLE = GRILLE,
+ INTITULE = 'NO2/NO12',
+ NORM_OBST = (0., 0., 1.,),
+ DIST_1 = 0.4495,
+ DIST_2 = 0.4495,
+ RIGI_NOR = riginor,
+ AMOR_NOR = 0.,
+ RIGI_TAN = 0.,
+ COULOMB = 0.),
+ INCREMENT=_F( INST_INIT = 0., INST_FIN = 1., PAS = 0.00025),
+ ARCHIVAGE=_F( PAS_ARCH = 8)
+ )
+
+LISTIMP=DEFI_LIST_REEL( DEBUT=0.,
+ INTERVALLE=_F( JUSQU_A = 1., NOMBRE = 500))
+
+RESUA1=REST_BASE_PHYS( RESU_GENE=TRAN_GE1,
+ LIST_INST=LISTIMP,
+ INTERPOL='LIN',
+ NOM_CHAM='DEPL',
+ MULT_APPUI='OUI'
+ )
+
+FIN()
--- /dev/null
+# MODIF DATE 20/09/2004 AUTEUR DURAND C.DURAND
+# TITRE TEST DE NON REGRESSION DE L IHM EFICAS - DERIVE DE SDND102A
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# Ce cas test est gere en configuration dans la base ASTER, il sert de
+# modele pour prononcer la recette de l IHM d EFICAS : l objectif est de
+# pouvoir recreer ce test a l identique dans EFICAS a partir d une page
+# blanche.
+# On a donc essaye d y placer toutes les commandes un peu particulieres
+# du langage de commandes d ASTER
+#
+# Il s agit en fait du test SDND102A auquel on a ajoute :
+# la definition d un parametre (VAL)
+# l inclusion d un fichier (INCLUDE)
+# une poursuite (POURSUITE)
+# Il contient ainsi :
+# des parametres, des formules, des macros, des mots cles facteurs repetes
+# (y compris conditionnes par des regles : calc_fonction / COMB),
+# des blocs (mode_iter_simult,calc_char_seisme), un defi_valeur, un parametre.
+#
+#
+# Il faudra y associer quelques recommandations pour la recette :
+# - verifier qu en ouvrant le .com0, il demande bien a browser le .comm puis, en cascade, le .11
+# - verifier qu on peut bien supprimer une commande, un mot cle simple et facteur
+# - verifier les acces a la doc
+#
+#
+
+
+DEBUT(CODE=_F(NOM='EFICA01A',NIV_PUB_WEB='INTERNET',VISU_EFICAS='NON'),)
+
+MAILLAGE=LIRE_MAILLAGE()
+
+MAILLAGE=DEFI_GROUP(reuse=MAILLAGE,
+ MAILLAGE=MAILLAGE,
+ CREA_GROUP_NO=(_F(NOEUD='NO2',
+ NOM='MASSES',),
+ _F(NOEUD='NO1',
+ NOM='ENCASTRE',),),)
+
+MAILLA2=LIRE_MAILLAGE(UNITE=21,)
+
+MODELE=AFFE_MODELE(MAILLAGE=MAILLAGE,
+ AFFE=(_F(GROUP_MA='RESSORT',
+ PHENOMENE='MECANIQUE',
+ MODELISATION='DIS_T',),
+ _F(GROUP_NO='MASSES',
+ PHENOMENE='MECANIQUE',
+ MODELISATION='DIS_T',),),)
+
+BICHOC=AFFE_MODELE(MAILLAGE=MAILLA2,
+ AFFE=(_F(GROUP_MA='RESSORTS',
+ PHENOMENE='MECANIQUE',
+ MODELISATION='DIS_T',),
+ _F(GROUP_NO=('MASSES1','MASSES2',),
+ PHENOMENE='MECANIQUE',
+ MODELISATION='DIS_T',),),)
+VAL = 98696.0
+
+
+CARA_ELE=AFFE_CARA_ELEM(MODELE=MODELE,
+ DISCRET=(_F(GROUP_MA='RESSORT',
+ REPERE='GLOBAL',
+ CARA='K_T_D_L',
+ VALE=(VAL,0.0,0.0,),),
+ _F(GROUP_NO='MASSES',
+ CARA='M_T_D_N',
+ VALE=25.0,),),)
+
+CARA_BIC=AFFE_CARA_ELEM(MODELE=BICHOC,
+ DISCRET=(_F(GROUP_MA='RESSORTS',
+ REPERE='GLOBAL',
+ CARA='K_T_D_L',
+ VALE=(VAL,0.0,0.0,),),
+ _F(GROUP_NO='MASSES1',
+ CARA='M_T_D_N',
+ VALE=25.0,),
+ _F(GROUP_NO='MASSES2',
+ CARA='M_T_D_N',
+ VALE=25.0,),),)
+
+CON_LIM=AFFE_CHAR_MECA(MODELE=MODELE,
+ DDL_IMPO=(_F(GROUP_NO='ENCASTRE',
+ DX=0.0,
+ DY=0.0,
+ DZ=0.0,),
+ _F(GROUP_NO='MASSES',
+ DY=0.0,
+ DZ=0.0,),),)
+
+CL_BICHO=AFFE_CHAR_MECA(MODELE=BICHOC,
+ DDL_IMPO=(_F(GROUP_NO='ENCBICHO',
+ DX=0.0,
+ DY=0.0,
+ DZ=0.0,),
+ _F(GROUP_NO=('MASSES1','MASSES2',),
+ DY=0.0,
+ DZ=0.0,),),)
+
+MACRO_MATR_ASSE(MODELE=MODELE,
+ CARA_ELEM=CARA_ELE,
+ CHARGE=CON_LIM,
+ NUME_DDL=CO('NUMEDDL'),
+ MATR_ASSE=(_F(MATRICE=CO('RIGIDITE'),
+ OPTION='RIGI_MECA',),
+ _F(MATRICE=CO('MASSE'),
+ OPTION='MASS_MECA',),),)
+
+MACRO_MATR_ASSE(MODELE=BICHOC,
+ CARA_ELEM=CARA_BIC,
+ CHARGE=CL_BICHO,
+ NUME_DDL=CO('NUMDDLC'),
+ MATR_ASSE=(_F(MATRICE=CO('RIGI_BIC'),
+ OPTION='RIGI_MECA',),
+ _F(MATRICE=CO('MASS_BIC'),
+ OPTION='MASS_MECA',),),)
+
+MODE_MEC=MODE_ITER_SIMULT(MATR_A=RIGIDITE,
+ MATR_B=MASSE,)
+
+MODE_MEC=NORM_MODE(reuse =MODE_MEC,
+ MODE=MODE_MEC,
+ NORME='MASS_GENE',)
+
+MODE_BIC=MODE_ITER_SIMULT(MATR_A=RIGI_BIC,
+ MATR_B=MASS_BIC,
+ METHODE='JACOBI',
+ OPTION='SANS',
+ CALC_FREQ=_F(OPTION='BANDE',
+ FREQ=(1.0,10.0,),),)
+
+MODE_BIC=NORM_MODE(reuse =MODE_BIC,
+ MODE=MODE_BIC,
+ NORME='MASS_GENE',)
+
+MODE_STA=MODE_STATIQUE(MATR_RIGI=RIGIDITE,
+ MATR_MASS=MASSE,
+ MODE_STAT=_F(TOUT='OUI',
+ AVEC_CMP='DX',),)
+
+MSTA_BIC=MODE_STATIQUE(MATR_RIGI=RIGI_BIC,
+ MATR_MASS=MASS_BIC,
+ MODE_STAT=_F(TOUT='OUI',
+ AVEC_CMP='DX',),)
+
+L_INST=DEFI_LIST_REEL(DEBUT=0.0,
+ INTERVALLE=_F(JUSQU_A=1.0,
+ PAS=1.E-4,),)
+
+OMEGAA=2.*pi*10.
+
+ACCE1 = FORMULE(VALE = 'sin(OMEGAA*INST)',
+ NOM_PARA='INST')
+
+ACCELER1=CALC_FONC_INTERP(FONCTION=ACCE1,
+ NOM_RESU='ACCE',
+ LIST_PARA=L_INST,
+ NOM_PARA = 'INST',
+ PROL_DROITE='LINEAIRE',
+ PROL_GAUCHE='LINEAIRE',)
+
+ACCE2 = FORMULE(VALE = '-sin(OMEGAA*INST)',
+ NOM_PARA='INST')
+
+ACCELER2=CALC_FONC_INTERP(FONCTION=ACCE2,
+ NOM_RESU='ACCE',
+ LIST_PARA=L_INST,
+ NOM_PARA = 'INST',
+ PROL_DROITE='LINEAIRE',
+ PROL_GAUCHE='LINEAIRE',)
+
+VITE1 = FORMULE(VALE = '-cos(OMEGAA*INST)/OMEGAA',
+ NOM_PARA='INST')
+
+VITESSE1=CALC_FONC_INTERP(FONCTION=VITE1,
+ NOM_RESU='VITE',
+ LIST_PARA=L_INST,
+ NOM_PARA = 'INST',
+ PROL_DROITE='LINEAIRE',
+ PROL_GAUCHE='LINEAIRE',)
+
+DEPL1 = FORMULE(VALE = '-sin(OMEGAA*INST)/(OMEGAA**2)',
+ NOM_PARA='INST')
+
+DEPLACE1=CALC_FONC_INTERP(FONCTION=DEPL1,
+ NOM_RESU='DEPL',
+ LIST_PARA=L_INST,
+ NOM_PARA = 'INST',
+ PROL_DROITE='LINEAIRE',
+ PROL_GAUCHE='LINEAIRE',)
+
+VITE2 = FORMULE(VALE = 'cos(OMEGAA*INST)/OMEGAA',
+ NOM_PARA='INST')
+
+VITESSE2=CALC_FONC_INTERP(FONCTION=VITE2,
+ NOM_RESU='VITE',
+ LIST_PARA=L_INST,
+ NOM_PARA = 'INST',
+ PROL_DROITE='LINEAIRE',
+ PROL_GAUCHE='LINEAIRE',)
+
+xx=2
+
+INCLUDE(UNITE=11,
+ INFO=1,)
+
+MUR=DEFI_OBSTACLE(TYPE='PLAN_Z',)
+
+TRAN_GE1=DYNA_TRAN_MODAL(METHODE='EULER',
+ MASS_GENE=MASS_GEN,
+ RIGI_GENE=RIGI_GEN,
+ AMOR_REDUIT=0.07,
+ MODE_STAT=MODE_STA,
+ INCREMENT=_F(INST_INIT=0.0,
+ INST_FIN=1.0,
+ PAS=2.0E-4,),
+ ARCHIVAGE=_F(PAS_ARCH=8,),
+ EXCIT=_F(VECT_GENE=VECT_X,
+ ACCE=ACCELER1,
+ VITE=VITESSE1,
+ DEPL=DEPLACE1,
+ MULT_APPUI='OUI',
+ DIRECTION=(1.0,0.0,0.0,),
+ NOEUD='NO1',),
+ CHOC=_F(INTITULE='NO2/MUR',
+ GROUP_NO_1='MASSES',
+ OBSTACLE=MUR,
+ ORIG_OBST=(-1.0,0.0,0.0,),
+ NORM_OBST=(0.0,0.0,1.0,),
+ JEU=1.1005,
+ RIGI_NOR=5.76E7,
+ AMOR_NOR=0.0,
+ RIGI_TAN=0.0,
+ COULOMB=0.0,),)
+
+MULT_X1=CALC_CHAR_SEISME(MATR_MASS=MASS_BIC,
+ DIRECTION=(1.0,0.0,0.0,),
+ MODE_STAT=MSTA_BIC,
+ NOEUD='NO1',)
+
+MULT_X2=CALC_CHAR_SEISME(MATR_MASS=MASS_BIC,
+ DIRECTION=(1.0,0.0,0.0,),
+ MODE_STAT=MSTA_BIC,
+ NOEUD='NO11',)
+
+MACRO_PROJ_BASE(BASE=MODE_BIC,
+ MATR_ASSE_GENE=(_F(MATRICE=CO('MGEN_BIC'),
+ MATR_ASSE=MASS_BIC,),
+ _F(MATRICE=CO('RGEN_BIC'),
+ MATR_ASSE=RIGI_BIC,),),
+ VECT_ASSE_GENE=(_F(VECTEUR=CO('VECT_X1'),
+ VECT_ASSE=MULT_X1,),
+ _F(VECTEUR=CO('VECT_X2'),
+ VECT_ASSE=MULT_X2,),),)
+
+GRILLE=DEFI_OBSTACLE(TYPE='BI_PLAN_Z',)
+
+MAILLA3=LIRE_MAILLAGE(UNITE=22,)
+
+FIN()
--- /dev/null
+DEPL2 = FORMULE(NOM_PARA='INST',VALE='sin(OMEGAA*INST)/(OMEGAA**xx)')
+DEPLACE2=CALC_FONC_INTERP( FONCTION=DEPL2,
+ LIST_PARA=L_INST,
+ NOM_PARA='INST',
+ PROL_DROITE='LINEAIRE',
+ PROL_GAUCHE='LINEAIRE',
+ NOM_RESU='DEPL' )
+
+MONO_X=CALC_CHAR_SEISME( MATR_MASS=MASSE,
+ DIRECTION=( 1., 0., 0.,),
+ MONO_APPUI='OUI' )
+
+
+MACRO_PROJ_BASE(BASE=MODE_MEC,MATR_ASSE_GENE=(
+ _F( MATRICE = CO("MASS_GEN"), MATR_ASSE = MASSE),
+ _F( MATRICE = CO("RIGI_GEN"), MATR_ASSE = RIGIDITE)),
+ VECT_ASSE_GENE=_F( VECTEUR = CO("VECT_X"), VECT_ASSE = MONO_X)
+ )
+
--- /dev/null
+# MODIF DATE 20/09/2004 AUTEUR DURAND C.DURAND
+# TITRE TEST DE NON REGRESSION DE L IHM EFICAS - DERIVE DE SDND102A
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# Ce cas test est gere en configuration dans la base ASTER, il sert de
+# modele pour prononcer la recette de l IHM d EFICAS : l objectif est de
+# pouvoir recreer ce test a l identique dans EFICAS a partir d une page
+# blanche.
+# On a donc essaye d y placer toutes les commandes un peu particulieres
+# du langage de commandes d ASTER
+#
+# Il s agit en fait du test SDND102A auquel on a ajoute :
+# la definition d un parametre (VAL)
+# l inclusion d un fichier (INCLUDE)
+# une poursuite (POURSUITE)
+# Il contient ainsi :
+# des parametres, des formules, des macros, des mots cles facteurs repetes
+# (y compris conditionnes par des regles : calc_fonction / COMB),
+# des blocs (mode_iter_simult,calc_char_seisme), un defi_valeur, un parametre.
+#
+#
+# Il faudra y associer quelques recommandations pour la recette :
+# - verifier qu en ouvrant le .com0, il demande bien a browser le .comm puis, en cascade, le .11
+# - verifier qu on peut bien supprimer une commande, un mot cle simple et facteur
+# - verifier les acces a la doc
+#
+#
+
+
+DEBUT(CODE=_F(NOM='EFICA01A',NIV_PUB_WEB='INTERNET',VISU_EFICAS='NON'),)
+
+MAILLAGE=LIRE_MAILLAGE()
+
+MAILLAGE=DEFI_GROUP(reuse=MAILLAGE,
+ MAILLAGE=MAILLAGE,
+ CREA_GROUP_NO=(_F(NOEUD='NO2',
+ NOM='MASSES',),
+ _F(NOEUD='NO1',
+ NOM='ENCASTRE',),),)
+
+MAILLA2=LIRE_MAILLAGE(UNITE=21,)
+
+MODELE=AFFE_MODELE(MAILLAGE=MAILLAGE,
+ AFFE=(_F(GROUP_MA='RESSORT',
+ PHENOMENE='MECANIQUE',
+ MODELISATION='DIS_T',),
+ _F(GROUP_NO='MASSES',
+ PHENOMENE='MECANIQUE',
+ MODELISATION='DIS_T',),),)
+
+BICHOC=AFFE_MODELE(MAILLAGE=MAILLA2,
+ AFFE=(_F(GROUP_MA='RESSORTS',
+ PHENOMENE='MECANIQUE',
+ MODELISATION='DIS_T',),
+ _F(GROUP_NO=('MASSES1','MASSES2',),
+ PHENOMENE='MECANIQUE',
+ MODELISATION='DIS_T',),),)
+VAL = 98696.0
+
+
+CARA_ELE=AFFE_CARA_ELEM(MODELE=MODELE,
+ DISCRET=(_F(GROUP_MA='RESSORT',
+ REPERE='GLOBAL',
+ CARA='K_T_D_L',
+ VALE=(VAL,0.0,0.0,),),
+ _F(GROUP_NO='MASSES',
+ CARA='M_T_D_N',
+ VALE=25.0,),),)
+
+CARA_BIC=AFFE_CARA_ELEM(MODELE=BICHOC,
+ DISCRET=(_F(GROUP_MA='RESSORTS',
+ REPERE='GLOBAL',
+ CARA='K_T_D_L',
+ VALE=(VAL,0.0,0.0,),),
+ _F(GROUP_NO='MASSES1',
+ CARA='M_T_D_N',
+ VALE=25.0,),
+ _F(GROUP_NO='MASSES2',
+ CARA='M_T_D_N',
+ VALE=25.0,),),)
+
+CON_LIM=AFFE_CHAR_MECA(MODELE=MODELE,
+ DDL_IMPO=(_F(GROUP_NO='ENCASTRE',
+ DX=0.0,
+ DY=0.0,
+ DZ=0.0,),
+ _F(GROUP_NO='MASSES',
+ DY=0.0,
+ DZ=0.0,),),)
+
+CL_BICHO=AFFE_CHAR_MECA(MODELE=BICHOC,
+ DDL_IMPO=(_F(GROUP_NO='ENCBICHO',
+ DX=0.0,
+ DY=0.0,
+ DZ=0.0,),
+ _F(GROUP_NO=('MASSES1','MASSES2',),
+ DY=0.0,
+ DZ=0.0,),),)
+
+MACRO_MATR_ASSE(MODELE=MODELE,
+ CARA_ELEM=CARA_ELE,
+ CHARGE=CON_LIM,
+ NUME_DDL=CO('NUMEDDL'),
+ MATR_ASSE=(_F(MATRICE=CO('RIGIDITE'),
+ OPTION='RIGI_MECA',),
+ _F(MATRICE=CO('MASSE'),
+ OPTION='MASS_MECA',),),)
+
+MACRO_MATR_ASSE(MODELE=BICHOC,
+ CARA_ELEM=CARA_BIC,
+ CHARGE=CL_BICHO,
+ NUME_DDL=CO('NUMDDLC'),
+ MATR_ASSE=(_F(MATRICE=CO('RIGI_BIC'),
+ OPTION='RIGI_MECA',),
+ _F(MATRICE=CO('MASS_BIC'),
+ OPTION='MASS_MECA',),),)
+
+MODE_MEC=MODE_ITER_SIMULT(MATR_A=RIGIDITE,
+ MATR_B=MASSE,)
+
+MODE_MEC=NORM_MODE(reuse =MODE_MEC,
+ MODE=MODE_MEC,
+ NORME='MASS_GENE',)
+
+MODE_BIC=MODE_ITER_SIMULT(MATR_A=RIGI_BIC,
+ MATR_B=MASS_BIC,
+ METHODE='JACOBI',
+ OPTION='SANS',
+ CALC_FREQ=_F(OPTION='BANDE',
+ FREQ=(1.0,10.0,),),)
+
+MODE_BIC=NORM_MODE(reuse =MODE_BIC,
+ MODE=MODE_BIC,
+ NORME='MASS_GENE',)
+
+MODE_STA=MODE_STATIQUE(MATR_RIGI=RIGIDITE,
+ MATR_MASS=MASSE,
+ MODE_STAT=_F(TOUT='OUI',
+ AVEC_CMP='DX',),)
+
+MSTA_BIC=MODE_STATIQUE(MATR_RIGI=RIGI_BIC,
+ MATR_MASS=MASS_BIC,
+ MODE_STAT=_F(TOUT='OUI',
+ AVEC_CMP='DX',),)
+
+L_INST=DEFI_LIST_REEL(DEBUT=0.0,
+ INTERVALLE=_F(JUSQU_A=1.0,
+ PAS=1.E-4,),)
+
+OMEGAA=2.*pi*10.
+
+ACCE1 = FORMULE(VALE = 'sin(OMEGAA*INST)',
+ NOM_PARA='INST')
+
+ACCELER1=CALC_FONC_INTERP(FONCTION=ACCE1,
+ NOM_RESU='ACCE',
+ LIST_PARA=L_INST,
+ NOM_PARA = 'INST',
+ PROL_DROITE='LINEAIRE',
+ PROL_GAUCHE='LINEAIRE',)
+
+ACCE2 = FORMULE(VALE = '-sin(OMEGAA*INST)',
+ NOM_PARA='INST')
+
+ACCELER2=CALC_FONC_INTERP(FONCTION=ACCE2,
+ NOM_RESU='ACCE',
+ LIST_PARA=L_INST,
+ NOM_PARA = 'INST',
+ PROL_DROITE='LINEAIRE',
+ PROL_GAUCHE='LINEAIRE',)
+
+VITE1 = FORMULE(VALE = '-cos(OMEGAA*INST)/OMEGAA',
+ NOM_PARA='INST')
+
+VITESSE1=CALC_FONC_INTERP(FONCTION=VITE1,
+ NOM_RESU='VITE',
+ LIST_PARA=L_INST,
+ NOM_PARA = 'INST',
+ PROL_DROITE='LINEAIRE',
+ PROL_GAUCHE='LINEAIRE',)
+
+DEPL1 = FORMULE(VALE = '-sin(OMEGAA*INST)/(OMEGAA**2)',
+ NOM_PARA='INST')
+
+DEPLACE1=CALC_FONC_INTERP(FONCTION=DEPL1,
+ NOM_RESU='DEPL',
+ LIST_PARA=L_INST,
+ NOM_PARA = 'INST',
+ PROL_DROITE='LINEAIRE',
+ PROL_GAUCHE='LINEAIRE',)
+
+VITE2 = FORMULE(VALE = 'cos(OMEGAA*INST)/OMEGAA',
+ NOM_PARA='INST')
+
+VITESSE2=CALC_FONC_INTERP(FONCTION=VITE2,
+ NOM_RESU='VITE',
+ LIST_PARA=L_INST,
+ NOM_PARA = 'INST',
+ PROL_DROITE='LINEAIRE',
+ PROL_GAUCHE='LINEAIRE',)
+
+xx=2
+
+INCLUDE(UNITE=11,
+ INFO=1,)
+
+MUR=DEFI_OBSTACLE(TYPE='PLAN_Z',)
+
+TRAN_GE1=DYNA_TRAN_MODAL(METHODE='EULER',
+ MASS_GENE=MASS_GEN,
+ RIGI_GENE=RIGI_GEN,
+ AMOR_REDUIT=0.07,
+ MODE_STAT=MODE_STA,
+ INCREMENT=_F(INST_INIT=0.0,
+ INST_FIN=1.0,
+ PAS=2.0E-4,),
+ ARCHIVAGE=_F(PAS_ARCH=8,),
+ EXCIT=_F(VECT_GENE=VECT_X,
+ ACCE=ACCELER1,
+ VITE=VITESSE1,
+ DEPL=DEPLACE1,
+ MULT_APPUI='OUI',
+ DIRECTION=(1.0,0.0,0.0,),
+ NOEUD='NO1',),
+ CHOC=_F(INTITULE='NO2/MUR',
+ GROUP_NO_1='MASSES',
+ OBSTACLE=MUR,
+ ORIG_OBST=(-1.0,0.0,0.0,),
+ NORM_OBST=(0.0,0.0,1.0,),
+ JEU=1.1005,
+ RIGI_NOR=5.76E7,
+ AMOR_NOR=0.0,
+ RIGI_TAN=0.0,
+ COULOMB=0.0,),)
+
+MULT_X1=CALC_CHAR_SEISME(MATR_MASS=MASS_BIC,
+ DIRECTION=(1.0,0.0,0.0,),
+ MODE_STAT=MSTA_BIC,
+ NOEUD='NO1',)
+
+MULT_X2=CALC_CHAR_SEISME(MATR_MASS=MASS_BIC,
+ DIRECTION=(1.0,0.0,0.0,),
+ MODE_STAT=MSTA_BIC,
+ NOEUD='NO11',)
+
+MACRO_PROJ_BASE(BASE=MODE_BIC,
+ MATR_ASSE_GENE=(_F(MATRICE=CO('MGEN_BIC'),
+ MATR_ASSE=MASS_BIC,),
+ _F(MATRICE=CO('RGEN_BIC'),
+ MATR_ASSE=RIGI_BIC,),),
+ VECT_ASSE_GENE=(_F(VECTEUR=CO('VECT_X1'),
+ VECT_ASSE=MULT_X1,),
+ _F(VECTEUR=CO('VECT_X2'),
+ VECT_ASSE=MULT_X2,),),)
+
+GRILLE=DEFI_OBSTACLE(TYPE='BI_PLAN_Z',)
+
+MAILLA3=LIRE_MAILLAGE(UNITE=22,)
+
+FIN()
--- /dev/null
+from Numeric import size
+
+DEBUT()
+
+# Definition des parametres de l'excitation sinusoidale
+freq=1500.0
+periode=1.0/freq
+pas=periode/100.0
+
+LISTTM=DEFI_LIST_REEL(DEBUT=0.0*periode,
+ INTERVALLE=_F(JUSQU_A=100.0*periode,
+ PAS=pas,),);
+
+LISTRD=DEFI_LIST_REEL(DEBUT=(98.0)*periode+pas,
+ INTERVALLE=_F(JUSQU_A=(100.0)*periode,
+ PAS=pas,),);
+
+FIN()
--- /dev/null
+DEBUT()
+sensible=[2.1E11, 0.3, 1.E-6, 1.E-6, ]
+
+# parse: -affectation
+n=len(sensible)
+PS=[None]*n
+
+for i in range(n):
+ PS[i]=DEFI_PARA_SENSI(VALE=sensible[i])
+
+FIN()
--- /dev/null
+DEBUT()
+MA=LIRE_MAILLAGE()
+INCLUDE_MATERIAU( NOM_AFNOR='18MND5', TYPE_MODELE='REF',
+ VARIANTE='A', TYPE_VALE='NOMI',
+ NOM_MATER='MAT3', INFO=1 )
+
+FIN()
--- /dev/null
+DEBUT()
+P1 = 9.8;
+
+P2 = 8.8;
+
+P3 = 7;
+
+P5 = P3*P1;
+
+P6 = P1-3;
+
+P4 = [2,3,4];
+
+a = 1.
+b=3
+c= 3 * 5
+cc="b+3"
+d= 4 + \
+ 5 \
+ -4
+e=LIRE_MAILLAGE()
+##MA=LIRE_MAILLAGE()
+x=(1,2)
+y=[3,
+#comme
+4]
+z="a"
+zz='v'
+u='''aaaa
+bbbb'''
+if 1:
+ a=45
+else:
+ a=5.6
+d={"a":0}
+e={"a":0,
+#comme
+"d":4}
+a==1
+s="-"*80
+fmt_raison='-'*80+'''
+
+ Exception erreur_Fatale interceptee
+ Raison : %s
+
+'''+'-'*80+'xxxxxxxxxxxxxxxx\n'
+
+# commen """
+# commen '''
+# commen '
+# commen "
+BETA=3.41557E-08
+
+C_0=105.7
+
+C_EQ_I05=69.1
+
+C_EQ_E05=69.1
+
+C_EQ_I10=51.6
+
+C_EQ_E10=69.1
+
+FL_INT05 = FORMULE(NOM_PARA='TEMP',VALE='''
+(0.5*BETA / ((C_0 - C_EQ_I05 )**2)
+ * (TEMP - (2.*C_0 - C_EQ_I05 ))*(TEMP - C_EQ_I05 ))''')
+
+zz=8.9;
+zz=8.9;aa=10
+
+FIN()
--- /dev/null
+import os,glob,sys
+import unittest
+
+from Editeur import appli
+
+from config import ASTERDIR
+
+class TestCase(unittest.TestCase):
+ app=None
+ def setUp(self):
+ if self.app == None:
+ self.app=appli.STANDALONE(version='v8.2')
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in glob.glob(os.path.join(ASTERDIR,"[a-l]*.comm")):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") != -1:continue
+ for o in ('3','2','1','0','m'):
+ f=f[:-1]+o
+ if os.path.isfile(f):break
+ i=i+1
+ exec """def test%s(self,file="%s"):
+ self.commtest(file)
+""" % (i,f)
+ del i,f,ff,text,o
+
+ def commtest(self,file):
+ """ Test generique"""
+ print file
+ j=self.app.openJDC(file=file)
+ assert j.isvalid(),j.report()
+ j.supprime()
+ assert sys.getrefcount(j) == 2,sys.getrefcount(j)
--- /dev/null
+import os,glob,sys
+import unittest
+
+from Editeur import appli
+
+from config import ASTERDIR
+
+class TestCase(unittest.TestCase):
+ app=None
+ def setUp(self):
+ if self.app == None:
+ self.app=appli.STANDALONE(version='v8.2')
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in glob.glob(os.path.join(ASTERDIR,"z*.comm")):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") != -1:continue
+ for o in ('3','2','1','0','m'):
+ f=f[:-1]+o
+ if os.path.isfile(f):break
+ i=i+1
+ exec """def test%s(self,file="%s"):
+ self.commtest(file)
+""" % (i,f)
+ del i,f,o,ff,text
+
+ def commtest(self,file):
+ """ Test generique"""
+ print file
+ j=self.app.openJDC(file=file)
+ assert j.isvalid(),j.report()
+ j.supprime()
+ assert sys.getrefcount(j) == 2,sys.getrefcount(j)
+
--- /dev/null
+import os,glob,sys
+import unittest
+
+from Editeur import appli
+
+from config import ASTERDIR
+
+class TestCase(unittest.TestCase):
+ app=None
+ def setUp(self):
+ if self.app == None:
+ self.app=appli.STANDALONE(version='v8.2')
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in glob.glob(os.path.join(ASTERDIR,"[m-r]*.comm")):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") != -1:continue
+ for o in ('3','2','1','0','m'):
+ f=f[:-1]+o
+ if os.path.isfile(f):break
+ i=i+1
+ exec """def test%s(self,file="%s"):
+ self.commtest(file)
+""" % (i,f)
+ del i,f,o,ff,text
+
+ def commtest(self,file):
+ """ Test generique"""
+ print file
+ j=self.app.openJDC(file=file)
+ assert j.isvalid(),j.report()
+ j.supprime()
+ assert sys.getrefcount(j) == 2,sys.getrefcount(j)
+
--- /dev/null
+import os,glob,sys
+import unittest
+
+from Editeur import appli
+
+from config import ASTERDIR
+
+class TestCase(unittest.TestCase):
+ app=None
+ def setUp(self):
+ if self.app == None:
+ self.app=appli.STANDALONE(version='v8.2')
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in glob.glob(os.path.join(ASTERDIR,"s[a-d]*.comm")):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") != -1:continue
+ for o in ('3','2','1','0','m'):
+ f=f[:-1]+o
+ if os.path.isfile(f):break
+ i=i+1
+ exec """def test%s(self,file="%s"):
+ self.commtest(file)
+""" % (i,f)
+ del i,f,o,ff,text
+
+ def commtest(self,file):
+ """ Test generique"""
+ print file
+ j=self.app.openJDC(file=file)
+ assert j.isvalid(),j.report()
+ j.supprime()
+ assert sys.getrefcount(j) == 2,sys.getrefcount(j)
+
--- /dev/null
+import os,glob,sys
+import unittest
+
+from Editeur import appli
+
+from config import ASTERDIR
+
+class TestCase(unittest.TestCase):
+ app=None
+ def setUp(self):
+ if self.app == None:
+ self.app=appli.STANDALONE(version='v8.2')
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in glob.glob(os.path.join(ASTERDIR,"s[e-r]*.comm")):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") != -1:continue
+ for o in ('3','2','1','0','m'):
+ f=f[:-1]+o
+ if os.path.isfile(f):break
+ i=i+1
+ exec """def test%s(self,file="%s"):
+ self.commtest(file)
+""" % (i,f)
+ del i,f,o,ff,text
+
+ def commtest(self,file):
+ """ Test generique"""
+ print file
+ j=self.app.openJDC(file=file)
+ assert j.isvalid(),j.report()
+ j.supprime()
+ assert sys.getrefcount(j) == 2,sys.getrefcount(j)
+
--- /dev/null
+import os,glob,sys
+import unittest
+
+from Editeur import appli
+
+from config import ASTERDIR
+
+class TestCase(unittest.TestCase):
+ app=None
+ def setUp(self):
+ if self.app == None:
+ self.app=appli.STANDALONE(version='v8.2')
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in glob.glob(os.path.join(ASTERDIR,"ssl[a-l]*.comm")):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") != -1:continue
+ for o in ('3','2','1','0','m'):
+ f=f[:-1]+o
+ if os.path.isfile(f):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") == -1: break
+ i=i+1
+ exec """def test%s(self,file="%s"):
+ self.commtest(file)
+""" % (i,f)
+ del i,f,o,ff,text
+
+ def commtest(self,file):
+ """ Test generique"""
+ print file
+ j=self.app.openJDC(file=file)
+ assert j.isvalid(),j.report()
+ j.supprime()
+ assert sys.getrefcount(j) == 2,sys.getrefcount(j)
+
--- /dev/null
+import os,glob,sys
+import unittest
+
+from Editeur import appli
+
+from config import ASTERDIR
+
+class TestCase(unittest.TestCase):
+ app=None
+ def setUp(self):
+ if self.app == None:
+ self.app=appli.STANDALONE(version='v8.2')
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in glob.glob(os.path.join(ASTERDIR,"ssl[m-z]*.comm")):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") != -1:continue
+ for o in ('3','2','1','0','m'):
+ f=f[:-1]+o
+ if os.path.isfile(f):break
+ i=i+1
+ exec """def test%s(self,file="%s"):
+ self.commtest(file)
+""" % (i,f)
+ del i,f,o,ff,text
+
+ def commtest(self,file):
+ """ Test generique"""
+ print file
+ j=self.app.openJDC(file=file)
+ assert j.isvalid(),j.report()
+ j.supprime()
+ assert sys.getrefcount(j) == 2,sys.getrefcount(j)
+
--- /dev/null
+import os,glob,sys
+import unittest
+
+from Editeur import appli
+
+from config import ASTERDIR
+
+class TestCase(unittest.TestCase):
+ app=None
+ def setUp(self):
+ if self.app == None:
+ self.app=appli.STANDALONE(version='v8.2')
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in glob.glob(os.path.join(ASTERDIR,"ss[m-z]*.comm")):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") != -1:continue
+ for o in ('3','2','1','0','m'):
+ f=f[:-1]+o
+ if os.path.isfile(f):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") == -1: break
+ i=i+1
+ exec """def test%s(self,file="%s"):
+ self.commtest(file)
+""" % (i,f)
+ del i,f,o,ff,text
+
+ def commtest(self,file):
+ """ Test generique"""
+ print file
+ j=self.app.openJDC(file=file)
+ assert j.isvalid(),j.report()
+ j.supprime()
+ assert sys.getrefcount(j) == 2,sys.getrefcount(j)
+
--- /dev/null
+import os,glob,sys
+import unittest
+
+from Editeur import appli
+
+from config import ASTERDIR
+
+class TestCase(unittest.TestCase):
+ app=None
+ def setUp(self):
+ if self.app == None:
+ self.app=appli.STANDALONE(version='v8.2')
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in glob.glob(os.path.join(ASTERDIR,"s[t-z]*.comm")):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") != -1:continue
+ for o in ('3','2','1','0','m'):
+ f=f[:-1]+o
+ if os.path.isfile(f):break
+ i=i+1
+ exec """def test%s(self,file="%s"):
+ self.commtest(file)
+""" % (i,f)
+ del i,f,o,ff,text
+
+ def commtest(self,file):
+ """ Test generique"""
+ print file
+ j=self.app.openJDC(file=file)
+ assert j.isvalid(),j.report()
+ j.supprime()
+ assert sys.getrefcount(j) == 2,sys.getrefcount(j)
+
--- /dev/null
+import os,glob,sys
+import unittest
+
+from Editeur import appli
+
+from config import ASTERDIR
+
+class TestCase(unittest.TestCase):
+ app=None
+ def setUp(self):
+ if self.app == None:
+ self.app=appli.STANDALONE(version='v8.2')
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in glob.glob(os.path.join(ASTERDIR,"[t-y]*.comm")):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") != -1:continue
+ for o in ('3','2','1','0','m'):
+ f=f[:-1]+o
+ if os.path.isfile(f):break
+ i=i+1
+ exec """def test%s(self,file="%s"):
+ self.commtest(file)
+""" % (i,f)
+ del i,f,o,ff,text
+
+ def commtest(self,file):
+ """ Test generique"""
+ print file
+ j=self.app.openJDC(file=file)
+ assert j.isvalid(),j.report()
+ j.supprime()
+ assert sys.getrefcount(j) == 2,sys.getrefcount(j)
+
--- /dev/null
+import os,glob,sys
+import unittest
+import difflib
+
+import prefs
+from Editeur import appli
+
+def add_param(j,pos,nom,valeur):
+ co=j.addentite("PARAMETRE",pos)
+ co.set_nom(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)
+ mcs.set_valeur(mcs.eval_val(valeur))
+ return mcs
+
+def cdiff(text1,text2):
+ return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1)))
+
+class TestCase(unittest.TestCase):
+ app=None
+ def setUp(self):
+ if self.app == None:
+ self.app=appli.STANDALONE(version='v8.2')
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in glob.glob(os.path.join(prefs.INSTALLDIR,"Tests/testcomm/*.comm")):
+ for o in ('3','2','1','0','m'):
+ f=f[:-1]+o
+ if os.path.isfile(f):break
+
+ i=i+1
+ exec """def test%s(self,file="%s"):
+ self.commtest(file)
+""" % (i,f)
+ del i
+
+ def commtest(self,file):
+ """ Test generique"""
+ print file
+ j=self.app.openJDC(file=file)
+ assert j.isvalid(),j.report()
+ CONTEXT.unset_current_step()
+ j.supprime()
+ assert sys.getrefcount(j) == 2,sys.getrefcount(j)
--- /dev/null
+DEBUT()
+YOUNG = DEFI_PARA_SENSI(VALE=1.)
+FORC = DEFI_PARA_SENSI(VALE=1.)
+MA=LIRE_MAILLAGE()
+MA=DEFI_GROUP( reuse=MA, MAILLAGE=MA,
+ CREA_GROUP_NO=_F(
+ GROUP_MA = ( 'LP9P10', 'LP9P10B',
+ 'LP8P9', 'LP8P9B',
+ ))
+ )
+
+MO=AFFE_MODELE( MAILLAGE=MA,
+ AFFE=_F( TOUT = 'OUI',
+ PHENOMENE = 'MECANIQUE',
+ MODELISATION = 'C_PLAN')
+ )
+ZERO = DEFI_CONSTANTE(VALE=0.)
+NU = DEFI_CONSTANTE(VALE=0.3)
+ALPHA = DEFI_CONSTANTE(VALE=0.)
+
+MAT=DEFI_MATERIAU(ELAS_FO=_F( E = YOUNG, NU = NU,
+ TEMP_DEF_ALPHA =20.,
+ ALPHA = ALPHA, RHO=7800.,))
+
+CHMAT=AFFE_MATERIAU( MAILLAGE=MA,
+ AFFE=_F( TOUT = 'OUI',
+ MATER = MAT)
+ )
+
+CH=AFFE_CHAR_MECA_F( MODELE=MO,
+ FORCE_INTERNE=_F(TOUT='OUI',FY=FORC,),
+ DDL_IMPO=(
+ _F( GROUP_NO = 'LP8P9',
+ DX = ZERO),
+ _F( GROUP_NO = 'LP8P9B',
+ DX = ZERO),
+ _F( GROUP_NO = 'P11',
+ DY = ZERO))
+ )
+
+DEP=MECA_STATIQUE( MODELE=MO, CHAM_MATER=CHMAT,
+ SENSIBILITE = (FORC),
+ EXCIT=_F( CHARGE = CH),
+ )
+
+DEP=CALC_ELEM(reuse=DEP,RESULTAT=DEP,
+ SENSIBILITE = (FORC),
+ OPTION=('EPSI_ELGA_DEPL','SIEF_ELGA_DEPL',),)
+
+FOND=DEFI_FOND_FISS( MAILLAGE=MA,
+ FOND_FISS=_F( GROUP_NO = ('P0',)),
+ NORMALE=(0., 1., 0.,)
+ )
+
+THETA0=CALC_THETA( MODELE=MO,
+ THETA_2D=_F( GROUP_NO = ('P0',),
+ MODULE = 1.,
+ R_INF = 3.75E-5,
+ R_SUP = 7.50E-5),
+ DIRECTION=(1., 0., 0.,)
+ )
+
+G0=CALC_G_THETA_T( RESULTAT=DEP,
+ THETA=THETA0,
+ SYME_CHAR='SANS',
+ COMP_ELAS=_F( RELATION = 'ELAS',
+ DEFORMATION = 'PETIT')
+ )
+
+DG0=CALC_G_THETA_T( RESULTAT=DEP,
+ SENSIBILITE = (FORC),
+ THETA=THETA0,
+ SYME_CHAR='SANS',
+ COMP_ELAS=_F( RELATION = 'ELAS',
+ DEFORMATION = 'PETIT')
+ )
+
+TEST_TABLE( TABLE=DG0,
+ NOM_PARA='G',
+ SENSIBILITE = (FORC),
+ VALE=1.06E-2,
+ REFERENCE='ANALYTIQUE',
+ PRECISION=0.0005 )
+
+
+FIN()
+MA1=LIRE_MAILLAGE()
+MO1=AFFE_MODELE( MAILLAGE=MA1, AFFE=_F( TOUT = 'OUI',
+ PHENOMENE = 'MECANIQUE', MODELISATION = 'C_PLAN'))
+
+FIN()
--- /dev/null
+
+
+DEBUT();
+P1 = 9.8;
+
+P2 = 8.8;
+
+P3 = 7;
+
+P5 = (P3 * P1);
+
+P6 = (P1 - 3);
+
+P4 = [2, 3, 4];
+
+#Pas trouve shellpanel
+
+MAILLA2=LIRE_MAILLAGE(UNITE=P4[1],);
+
+aaa = FORMULE(VALE='a+z',
+ NOM_PARA=('a','z',),);
+
+MAIL=LIRE_MAILLAGE(UNITE=P3,);
+# 'LIRE_MAILLAGE', 'UNITE' --> uniquebasepanel
+
+az = FORMULE(VALE='aaaaa',
+ NOM_PARA=('ae','inst',),);
+
+AFFE1=AFFE_MODELE(MAILLAGE=MAIL,
+ AFFE=(_F(GROUP_MA=('RESSORT','eee',),
+ PHENOMENE='MECANIQUE',
+ MODELISATION='DIS_T',),
+ _F(GROUP_MA='MASSES',
+ PHENOMENE='MECANIQUE',
+ MODELISATION='DIS_T',),
+ _F(GROUP_NO=('GNP3','GNP5','GNP6','GNP7','GNP8','GNP9','GNP10','GNP11','GNP12',),
+ PHENOMENE='ACOUSTIQUE',
+ MODELISATION='PLAN',),),);
+
+MOD=AFFE_MODELE(MAILLAGE=MAIL,
+ AFFE=(_F(GROUP_MA='RESSORT',
+ PHENOMENE='MECANIQUE',
+ MODELISATION='DIS_T',),
+ _F(GROUP_MA='MASSES',
+ PHENOMENE='MECANIQUE',
+ MODELISATION='DIS_T',),
+ _F(TOUT='OUI',
+ PHENOMENE='THERMIQUE',
+ MODELISATION='COQUE',),),);
+
+CARA=AFFE_CARA_ELEM(MODELE=MOD,
+ POUTRE=_F(GROUP_MA='MA',
+ SECTION='CERCLE',
+ CARA='R',
+ VALE=(3.0,P6,),),);
+# 'AFFE_MODELE', 'MAILLAGE' --> uniqueassdpanel
+# AFFE_MODELE', 'AFFE', 'GROUP_MA' --> plusieursbasepanel
+# 'AFFE_MODELE', 'AFFE', 'PHENOMENE' --> uniqueintopanel
+# 'AFFE_MODELE', 'AFFE', 'b_mecanique'--> plusieursintopanel
+
+F1=DEFI_FONCTION(NOM_PARA='DX',
+ VALE=(5.0,3.0,P4[1],P3,),);
+
+F3=DEFI_FONCTION(NOM_PARA='DRX',
+ VALE_C=(5.0,7.0,9.0,9.0,8.0,7.0,),);
+# 'DEFI_FONCTION', 'VALE' --> fonctionpanel
+
+MATER2=DEFI_MATERIAU(ELAS=_F(E=100000000000.0,
+ NU=0.0,),
+ ECRO_ASYM_LINE=_F(DC_SIGM_EPSI=0.0,
+ SY_C=200000000.0,
+ DT_SIGM_EPSI=0.0,
+ SY_T=50000000.0,),);
+
+PS1=DEFI_PARA_SENSI(VALE=1.0,);
+
+PS2=DEFI_PARA_SENSI(VALE=1.0,);
+
+PS3=DEFI_PARA_SENSI(VALE=1.0,);
+
+CHMAT2=AFFE_MATERIAU(MAILLAGE=MAIL,
+ AFFE=_F(TOUT='OUI',
+ MATER=MATER2,),);
+
+AAAZ=AFFE_CHAR_THER(MODELE=AFFE1,
+ TEMP_IMPO=_F(TOUT='OUI',
+ TEMP=0.0,),);
+
+TH1=THER_LINEAIRE(MODELE=AFFE1,
+ CHAM_MATER=CHMAT2,
+ EXCIT=_F(CHARGE=AAAZ,),
+ SENSIBILITE=(PS1,PS2,),);
+# 'THER_LINEAIRE', 'SENSIBILITE' --> plusieursassdpanel
+
+ACA1=AFFE_CHAR_ACOU(MODELE=AFFE1,
+ PRES_IMPO=_F(TOUT='OUI',
+ PRES=('RI',3.0,3.0,),),);
+# 'AFFE_CHAR_ACOU', 'PRES_IMPO', 'PRES' --> uniquecomppanel
+
+MACRO_MATR_ASSE(MODELE=AFFE1,
+ NUME_DDL=CO('DDL1'),
+ MATR_ASSE=_F(MATRICE=CO('MAT1'),
+ OPTION='RIGI_THER',),);
+# 'MACRO_MATR_ASSE', 'MATR_ASSE', 'MATRICE' --> uniquesdcopanel
+
+FIN();
--- /dev/null
+
+
+DEBUT();
+a = 1.0;
+
+b = 3;
+
+c = 15;
+
+d = 5;
+
+x = (1, 2);
+
+y = [3, 4];
+
+y2 = (y * 2);
+
+z = 'a';
+
+zz = 'v';
+
+t = a;
+
+v = """aaaa
+bbbb""";
+
+xx = ceil(sqrt(d));
+
+yy = cos(3.1);
+
+ax = sin(2);
+
+bx = cos(xx);
+
+cx = sin(xx);
+
+zy = y[1];
+
+
+FIN();
--- /dev/null
+import os
+import unittest
+import difflib
+
+import prefs
+from Editeur import appli
+from Editeur import comploader
+from Editeur import Objecttreeitem
+
+def add_param(j,pos,nom,valeur):
+ co=j.addentite("PARAMETRE",pos)
+ co.set_nom(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)
+ mcs.set_valeur(mcs.eval_val(valeur))
+ return mcs
+
+def cdiff(text1,text2):
+ return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1)))
+
+class TestCase(unittest.TestCase):
+ """ Tests sur des items """
+ def setUp(self):
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ def test001(self):
+ """Test comploader"""
+ composants=comploader.charger_composants()
+ itemtype=comploader.gettreeitem({'a':1})
+ assert itemtype is Objecttreeitem.ObjectTreeItem
+
+ def test002(self):
+ """ Test de commentarisation/decommentarisation a partir d'un item jdc """
+ app=appli.STANDALONE(version='v8.2')
+ 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()
+ # on commente la commande LIRE_MAILLAGE
+ 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()
+ # on reaffecte l'objet MAIL
+ for it in commands:
+ if it.nom in ("AFFE_MODELE","AFFE_MATERIAU") :
+ for mc in it.GetSubList():
+ if mc.nom == "MAILLAGE":
+ valeur,validite=mc.eval_valeur("MAIL")
+ test = mc.set_valeur(valeur)
+ text1=app.get_text_JDC(j,'python')
+ f=open(file)
+ text2=f.read()
+ f.close()
+ assert text1 == text2 , cdiff(text1,text2)
+
--- /dev/null
+# coding=utf-8
+
+import os
+import unittest
+import difflib
+import compare
+
+import prefs
+from Editeur import appli
+
+def add_param(j,pos,nom,valeur):
+ co=j.addentite("PARAMETRE",pos)
+ co.set_nom(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)
+ mcs.set_valeur(mcs.eval_val(valeur))
+ return mcs
+
+def cdiff(text1,text2):
+ return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1)))
+
+class TestCase(unittest.TestCase):
+ def setUp(self):
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ def test000(self):
+ app=appli.STANDALONE(version='v8.2')
+ j=app.newJDC()
+
+# commande DEBUT
+ co=j.addentite("DEBUT",0)
+ co=add_param(j,1,"P1",None)
+ x=co.valeur or "coucou"
+ assert x == "coucou"
+ assert len(co) == 0
+ co.set_valeur(1)
+ assert len(co) == 1
+ co.set_valeur([1,2])
+ assert len(co) == 2
+
+ def test001(self):
+ """ Test d'insertion de commandes dans fichier toto.comm"""
+ app=appli.STANDALONE(version='v8.2')
+ file=os.path.join(prefs.INSTALLDIR,"Tests/testelem/toto.comm")
+ j=app.openJDC(file=file)
+ expected="""DEBUT CR validation : toto.comm
+FIN CR validation :toto.comm
+"""
+ cr=str(j.report())
+ assert cr == expected, cr + "!=" + expected
+ co=j.etapes[1]
+ mcs=co.addentite("INFO")
+
+ cr=app.get_text_JDC(j,'python')
+ expected="""
+
+DEBUT();
+
+MA=LIRE_MAILLAGE(INFO=1,);
+
+FIN();
+"""
+ assert cr == expected, cr + "!=" + expected
+ co=j.addentite("LIRE_MAILLAGE",2)
+ test,mess=co.nomme_sd("MA2")
+ assert test == 1
+
+ cr=app.get_text_JDC(j,'python')
+ expected="""
+
+DEBUT();
+
+MA=LIRE_MAILLAGE(INFO=1,);
+
+MA2=LIRE_MAILLAGE();
+
+FIN();
+"""
+ assert cr == expected, cr + "!=" + expected
+
+ def test002(self):
+ """ Test de construction du fichier de commandes az.comm de zero"""
+
+ app=appli.STANDALONE(version='v8.2')
+ j=app.newJDC()
+# commande DEBUT
+ co=j.addentite("DEBUT",0)
+# commande FIN
+ co=j.addentite("FIN",1)
+# parametres
+ pos=0
+ pos=pos+1
+ co=add_param(j,pos,"P1","9.8")
+ pos=pos+1
+ co=add_param(j,pos,"P2","8.8")
+ pos=pos+1
+ co=add_param(j,pos,"P3","7")
+ pos=pos+1
+ co=add_param(j,pos,"P5","P3*P1")
+ pos=pos+1
+ co=add_param(j,pos,"P6","P1-3")
+ pos=pos+1
+ co=add_param(j,pos,"P4","[2,3,4]")
+# commentaire
+ pos=pos+1
+ 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")
+ valeur=mcs.eval_val("P4[1]")
+ test=mcs.set_valeur(valeur)
+# formule
+ pos=pos+1
+ 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")
+ valeur,validite=mcs.eval_valeur("P3")
+ test=mcs.set_valeur(valeur)
+#
+ pos=pos+1
+ co=j.addentite("COMMENTAIRE",pos)
+ co.set_valeur(" 'LIRE_MAILLAGE', 'UNITE' --> uniquebasepanel")
+# formule
+ pos=pos+1
+ 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)
+ 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")
+ mcs=mcf[0].get_child("PHENOMENE")
+ valeur=mcs.eval_val_item('MECANIQUE')
+ assert valeur=='MECANIQUE',str(valeur)
+ test=mcs.set_valeur(valeur)
+ assert mcf["PHENOMENE"] == 'MECANIQUE'
+ mcs=mcf[0].get_child("b_mecanique").get_child("MODELISATION")
+ mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ assert mcf["MODELISATION"] == 'DIS_T'
+ mcs=add_mcsimp(mcf[0],"GROUP_MA",('RESSORT','eee',))
+
+ 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")
+ 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.set_valeur(mcs.eval_val_item('PLAN'))
+ #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")
+# commande AFFE_MODELE
+ pos=pos+1
+ co=j.addentite("AFFE_MODELE",pos)
+ mcs=co.get_child("MAILLAGE")
+ mcs.set_valeur(mcs.eval_val("MAIL"))
+
+ mcf=co.addentite("AFFE")
+ mcs=mcf[0].get_child("PHENOMENE")
+ valeur=mcs.eval_val_item('MECANIQUE')
+ test=mcs.set_valeur(valeur)
+ mcs=mcf[0].get_child("b_mecanique").get_child("MODELISATION")
+ mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=add_mcsimp(mcf[0],"GROUP_MA",'RESSORT')
+
+ 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")
+ 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")
+#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)
+ mcs=co.get_child("MODELE")
+ mcs.set_valeur(mcs.eval_val("MOD"))
+ mcf=co.addentite("POUTRE")
+ mcs=mcf[0].get_child("SECTION")
+ mcs.set_valeur(mcs.eval_val('CERCLE'))
+ assert mcf[0]["SECTION"] == 'CERCLE'
+ mcs=add_mcsimp(mcf[0],"GROUP_MA",'MA')
+ mcs=mcf[0].get_child("b_cercle").get_child("b_constant").get_child("CARA")
+ 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")
+# commentaire
+ pos=pos+1
+ co=j.addentite("COMMENTAIRE",pos)
+ text=""" 'AFFE_MODELE', 'MAILLAGE' --> uniqueassdpanel
+ AFFE_MODELE', 'AFFE', 'GROUP_MA' --> plusieursbasepanel
+ 'AFFE_MODELE', 'AFFE', 'PHENOMENE' --> uniqueintopanel
+ 'AFFE_MODELE', 'AFFE', 'b_mecanique'--> plusieursintopanel"""
+ co.set_valeur(text)
+#F1=DEFI_FONCTION(NOM_PARA='DX',
+# VALE=(5.0,3.0,P4[1],P3,),);
+ pos=pos+1
+ co=j.addentite("DEFI_FONCTION",pos)
+ mcs=co.get_child("NOM_PARA")
+ mcs.set_valeur(mcs.eval_val("DX"))
+ mcs=co.addentite("VALE")
+ mcs.set_valeur(mcs.eval_val("5.0,3.0,P4[1],P3"))
+ co.nomme_sd("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)
+ mcs=co.get_child("NOM_PARA")
+ mcs.set_valeur(mcs.eval_val("DRX"))
+ 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")
+# commentaire
+ pos=pos+1
+ co=j.addentite("COMMENTAIRE",pos)
+ co.set_valeur(" 'DEFI_FONCTION', 'VALE' --> fonctionpanel ")
+#MATER2=DEFI_MATERIAU(ELAS=_F(E=100000000000.0,
+# NU=0.0,),
+# ECRO_ASYM_LINE=_F(DC_SIGM_EPSI=0.0,
+# SY_C=200000000.0,
+# DT_SIGM_EPSI=0.0,
+# SY_T=50000000.0,),);
+ pos=pos+1
+ 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")
+ 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("0.0"))
+ mcs=mcf[0].get_child("SY_C")
+ 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")
+#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)
+ mcs=co.get_child("VALE")
+ mcs.set_valeur(mcs.eval_val("1.0"))
+ co.nomme_sd("PS1")
+ pos=pos+1
+ co=j.addentite("DEFI_PARA_SENSI",pos)
+ mcs=co.get_child("VALE")
+ mcs.set_valeur(mcs.eval_val("1.0"))
+ co.nomme_sd("PS2")
+ pos=pos+1
+ co=j.addentite("DEFI_PARA_SENSI",pos)
+ mcs=co.get_child("VALE")
+ mcs.set_valeur(mcs.eval_val("1.0"))
+ co.nomme_sd("PS3")
+#CHMAT2=AFFE_MATERIAU(MAILLAGE=MAIL,
+# AFFE=_F(TOUT='OUI',
+# MATER=MATER2,),);
+ pos=pos+1
+ 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")
+#AAAZ=AFFE_CHAR_THER(MODELE=AFFE1,
+# TEMP_IMPO=_F(TOUT='OUI',
+# TEMP=0.0,),);
+ pos=pos+1
+ co=j.addentite("AFFE_CHAR_THER",pos)
+ add_mcsimp(co,"MODELE","AFFE1")
+ mcf=co.addentite("TEMP_IMPO")
+ add_mcsimp(mcf[0],"TOUT","OUI")
+ add_mcsimp(mcf[0],"TEMP","0.0")
+ co.nomme_sd("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)
+ 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")
+# commentaire
+ pos=pos+1
+ 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)
+ add_mcsimp(co,"MODELE","AFFE1")
+ 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")
+# commentaire
+ pos=pos+1
+ co=j.addentite("COMMENTAIRE",pos)
+ co.set_valeur(" 'AFFE_CHAR_ACOU', 'PRES_IMPO', 'PRES' --> uniquecomppanel")
+
+# 'AFFE_CHAR_ACOU', 'PRES_IMPO', 'PRES' --> uniquecomppanel
+
+#MACRO_MATR_ASSE(MODELE=AFFE1,
+# NUME_DDL=CO('DDL1'),
+# MATR_ASSE=_F(MATRICE=CO('MAT1'),
+# OPTION='RIGI_THER',),);
+ pos=pos+1
+ co=j.addentite("MACRO_MATR_ASSE",pos)
+ add_mcsimp(co,"MODELE","AFFE1")
+ mcs=co.get_child("NUME_DDL")
+ mcs.set_valeur_co('DDL1')
+ mcf=co.get_child("MATR_ASSE")
+ add_mcsimp(mcf[0],"OPTION","RIGI_THER")
+ mcs=mcf[0].get_child("MATRICE")
+ mcs.set_valeur_co('MAT1')
+# commentaire
+ pos=pos+1
+ co=j.addentite("COMMENTAIRE",pos)
+ co.set_valeur(" 'MACRO_MATR_ASSE', 'MATR_ASSE', 'MATRICE' --> uniquesdcopanel")
+
+ assert j.isvalid(),j.report()
+
+ text1=app.get_text_JDC(j,'python')
+ file=os.path.join(prefs.INSTALLDIR,"Tests/testelem/az.comm")
+ f=open(file)
+ text2=f.read()
+ f.close()
+ assert text1 == text2 , cdiff(text1,text2)
+
+ def test003(self):
+ """ Test de construction du fichier de commandes az.comm de zero"""
+
+ app=appli.STANDALONE(version='v8.2')
+ j=app.newJDC()
+# commande DEBUT
+ co=j.addentite("DEBUT",0)
+# commande FIN
+ co=j.addentite("FIN",1)
+#parametre
+ pos=0
+ pos=pos+1
+ co=add_param(j,pos,"P1","9.8")
+ pos=pos+1
+ co=add_param(j,pos,"P2","sin(P1)")
+# formule
+ pos=pos+1
+ 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)
+ add_mcsimp(co,"VALE","1.,2.,3.")
+ co.nomme_sd("LI1")
+#commande defi_list_reel
+ pos=pos+1
+ co=j.addentite("DEFI_LIST_REEL",pos)
+ add_mcsimp(co,"VALE","sin(1.)")
+ co.nomme_sd("LI2")
+#commande defi_list_reel
+ pos=pos+1
+ co=j.addentite("DEFI_LIST_REEL",pos)
+ add_mcsimp(co,"VALE","aaa(1.,2.)")
+ co.nomme_sd("LI3")
+#commande defi_list_reel
+ pos=pos+1
+ co=j.addentite("DEFI_LIST_REEL",pos)
+ add_mcsimp(co,"VALE","sin(1.,2)")
+ co.nomme_sd("LI4")
+#commande defi_list_reel
+ pos=pos+1
+ co=j.addentite("DEFI_LIST_REEL",pos)
+ add_mcsimp(co,"VALE","aaa(1.)")
+ co.nomme_sd("LI5")
+#commande defi_list_reel
+ pos=pos+1
+ co=j.addentite("DEFI_LIST_REEL",pos)
+ add_mcsimp(co,"VALE","1,sin(1.),2")
+ co.nomme_sd("LI6")
+
+ expected="""DEBUT CR validation : SansNom
+ Etape : DEFI_LIST_REEL ligne : ...
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ ! Concept retourné non défini !
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ Mot-clé simple : VALE
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ ! 'sin(1.,2)' n'est pas d'un type autorisé !
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ Fin Mot-clé simple : VALE
+ Fin Etape : DEFI_LIST_REEL
+ Etape : DEFI_LIST_REEL ligne : ...
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ ! Concept retourné non défini !
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ Mot-clé simple : VALE
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ ! 'aaa(1.)' n'est pas d'un type autorisé !
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ Fin Mot-clé simple : VALE
+ Fin Etape : DEFI_LIST_REEL
+FIN CR validation :SansNom
+"""
+ msg=str( j.report())
+ assert compare.check(expected,msg),cdiff(expected,msg)
--- /dev/null
+# coding=utf-8
+import os
+import unittest
+import difflib
+import compare
+
+import prefs
+from Editeur import appli
+from Accas import AsException
+
+def add_param(j,pos,nom,valeur):
+ co=j.addentite("PARAMETRE",pos)
+ co.set_nom(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)
+ mcs.set_valeur(mcs.eval_val(valeur))
+ return mcs
+
+def cdiff(text1,text2):
+ return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1)))
+
+class TestCase(unittest.TestCase):
+ def setUp(self):
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ def test001(self):
+ """ Test de commentarisation/decommentarisation de commandes dans fichier az.comm"""
+ app=appli.STANDALONE(version='v8.2')
+ file=os.path.join(prefs.INSTALLDIR,"Tests/testelem/az.comm")
+ j=app.openJDC(file=file)
+ 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())
+ # on decommente la commande LIRE_MAILLAGE
+ commande,nom = cco.uncomment()
+ # on reaffecte l'objet MAIL
+ for co in j.etapes:
+ if co.nom in ("AFFE_MODELE","AFFE_MATERIAU") :
+ add_mcsimp(co,"MAILLAGE",'MAIL')
+
+ text1=app.get_text_JDC(j,'python')
+ f=open(file)
+ text2=f.read()
+ f.close()
+ assert text1 == text2 , cdiff(text1,text2)
+
+ def test002(self):
+ """ Test de commentarisation/decommentarisation de macro commande dans fichier az.comm"""
+ app=appli.STANDALONE(version='v8.2')
+ file=os.path.join(prefs.INSTALLDIR,"Tests/testelem/az.comm")
+ j=app.openJDC(file=file)
+ 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())
+ # on decommente la commande MACRO_MATR_ASSE
+ commande,nom = cco.uncomment()
+ assert j.isvalid(),j.report()
+
+ def test003(self):
+ """ Test de commentarisation/decommentarisation de commandes dans fichier az.comm"""
+ app=appli.STANDALONE(version='v8.2')
+ text="""
+DEBUT()
+MA=LIRE_MAILLAGE()
+FIN()
+"""
+ j=app.openTXT(text)
+ 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")
+ # on decommente la commande LIRE_MAILLAGE
+ commande,nom = cco.uncomment()
+ expected="""DEBUT CR validation : TEXT
+ Etape : LIRE_MAILLAGE ligne : ...
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ ! Concept retourné non défini !
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ Fin Etape : LIRE_MAILLAGE
+FIN CR validation :TEXT
+"""
+ msg=str( j.report())
+ assert compare.check(expected,msg),cdiff(expected,msg)
+
+ def test004(self):
+ """ Test de commentarisation/decommentarisation de commandes dans fichier az.comm"""
+ app=appli.STANDALONE(version='v8.2')
+ text="""
+DEBUT()
+MA=LIRE_MAILLAGE()
+AFFE_MODELE(MAILLAGE=MA)
+FIN()
+"""
+ j=app.openTXT(text)
+ # on commente la commande LIRE_MAILLAGE
+ co=j.etapes[1]
+ cco=co.get_objet_commentarise(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())
+ # on decommente la commande AFFE_MODELE
+ commande,nom = cco2.uncomment()
+ assert commande["MAILLAGE"] == None
+
+ def test005(self):
+ """ Test de commentarisation/decommentarisation de commandes dans fichier az.comm"""
+ app=appli.STANDALONE(version='v8.2')
+ text="""
+DEBUT()
+MA=LIRE_MAILLAGE()
+AFFE_MODELE(MAILLAGE=MA)
+FIN()
+"""
+ j=app.openTXT(text)
+ # on commente la commande AFFE_MODELE
+ co=j.etapes[2]
+ cco2=co.get_objet_commentarise(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())
+ # on decommente la commande AFFE_MODELE
+ self.assertRaises(AsException, cco2.uncomment, )
+
--- /dev/null
+# coding=utf-8
+import os
+import unittest
+import difflib
+import compare
+
+import prefs
+from Editeur import appli
+from Accas import AsException
+
+def add_param(j,pos,nom,valeur):
+ co=j.addentite("PARAMETRE",pos)
+ co.set_nom(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)
+ mcs.set_valeur(mcs.eval_val(valeur))
+ return mcs
+
+def cdiff(text1,text2):
+ return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1)))
+
+class TestCase(unittest.TestCase):
+ def setUp(self):
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in ("params.comm",):
+ file=os.path.join(prefs.INSTALLDIR,"Tests/testelem",f)
+ i=i+1
+ exec """def test%s(self,file="%s"):
+ self.commtest(file)
+""" % (i,file)
+ del i
+
+ def commtest(self,file):
+ """ Test de lecture/ecriture de fichier .comm"""
+ print file
+ app=appli.STANDALONE(version='v8.2')
+ j=app.openJDC(file=file)
+ assert j.isvalid(),j.report()
+
+ text1=app.get_text_JDC(j,'python')
+ f=open(file)
+ text2=f.read()
+ f.close()
+ assert text1 == text2 , cdiff(text1,text2)
+
# coding=utf-8
+import types
from Accas import SIMP,ASSD
class maillage(ASSD):pass
class maillage_sdaster(ASSD):pass
+from Accas import ValidException
import unittest
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)
+
+ def test014(self):
+ class LongStr:
+ def __init__(self,min,max):
+ self.min=min
+ self.max=max
+ def __convert__(self,valeur):
+ if type(valeur) == types.StringType:
+ if self.min < len(valeur) < self.max:return valeur
+ return None
+
+ cata=SIMP(typ=LongStr(5,8),statut='o')
+ liste=(("aaaaaa",1),
+ ("aaaaaaa",1),
+ ("aaaaaaaaaaaaaaa",0),
+ ("aa",0),
+ )
+ 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(b.eval(),2.56)
c=Variable('q',[1,a,3])
d=c[1]/3
- self.assertEqual(str(d),'((q[1]) / 3)')
+ self.assertEqual(str(d),'(q[1] / 3)')
self.assertEqual(d.eval(),25.6/3)
f=cos(d)
- self.assertEqual(str(f),'cos(((q[1]) / 3))')
+ self.assertEqual(str(f),'cos((q[1] / 3))')
self.assertEqual(f.eval(),-0.628288791022798)
g=a**2
self.assertEqual(str(g),'(n ** 2)')
self.assertEqual(g.eval(),429496.72960000008)
def test003(self):
+ """ Validation d'un parametre (instance de la classe Variable)
+ """
cata=SIMP(statut='o',typ='R',max=3)
liste=((1,1),(Variable('x',(0.,1.)),1), (1.,1),(Variable('x',(0.,1.)),1), (('RI',1,0),0),
(1+0j,0), ("('RI',1,0)",0), ("toto",0), (None,0),
)
for valeur,valid in liste:
o=cata(valeur,'mcs',None)
- print o.val,o.valeur
+ #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)
+
+ def test004(self):
+ cata=SIMP(typ='C',statut='o',max=10)
+ liste=((1,1),("a",0), (1.,1),(('RI',1.,0.),1), (('RI',1,0),1), (1+0j,1),
+ (('RI',Variable('x',1.),0.),1),
+ (Variable('x',1.),1),
+ (Variable('x',1.)+0j,1),
+ ((Variable('x',1.)+0j,1.,0.,Variable('x',1.+2j),Variable('x',Variable('y',1.)+2j)),1),
+ ("('RI',1,0)",0), ("toto",0), (None,0),
+ (Variable('x',(1,2,2+5j)),1),
+ (Variable('x',(1,2,2+5j,5,6,7,8,9,10,11,12)),0),
+ (Variable('x',(1,2,2+5j,5,6,Variable('y',1+4j),8,9,10,11,12)),0),
+ (Variable('x',(1,"aaaa",2+5j,5,6,Variable('y',1+4j),8,9,10,11,12)),0),
+ (1+Variable('x',1.)*1j,1),
+ )
+ 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)
+
+ def test005(self):
+ t=Variable('t',None)
+ assert len(t) == 0
# coding=utf-8
from Accas import *
+from Extensions.param2 import Variable
import unittest
import compare
valid=compare.check(rep,report)
if not valid:
msg="le rapport d'erreur est incorrect.\n valeur = %s\n expected =\n%s\n got =\n%s " % (valeur,report,rep)
- print msg
+ #print msg
self.assert_(valid,msg=msg)
def test001(self):
! Mot-clé : mcs devrait avoir longueur de la chaine entre 3 et 5 !
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Fin Mot-clé simple : mcs
+"""),
+ (Variable('x',"aaa"),OK),
+ (Variable('x',"aaaaaaaaaaaa"),
+"""Mot-clé simple : mcs
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ ! Mot-clé : mcs devrait avoir longueur de la chaine entre 3 et 5 !
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+Fin Mot-clé simple : mcs
"""),
)
self._test(cata,liste)
(("aaaa","axyz","bbbb","zzz"),OK),
("aaaa",OK),("aaaaa",OK),
("axyzaa",OK),("bbbbaaa",OK),
+ (("aaa",Variable('x',"bbb")),OK),
+ (("aaa",Variable('x',"aaa")),
+"""Mot-clé simple : mcs
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ ! Mot-clé : mcs devrait avoir : pas de présence de doublon dans la liste !
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+Fin Mot-clé simple : mcs
+"""),
+ (Variable('x',("aaa","bbb")),OK),
+ (Variable('x',("aaa","bbb","bbb")),
+"""Mot-clé simple : mcs
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ ! Mot-clé : mcs devrait avoir : pas de présence de doublon dans la liste !
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+Fin Mot-clé simple : mcs
+"""),
)
self._test(cata,liste)
--- /dev/null
+DEBUT()
+MA=LIRE_MAILLAGE()
+FIN()
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+import sys,string,re,tokenize
+import cStringIO
+
+class ENTITE_JDC :
+ def __init__(self):
+ self.texte = ''
+
+ def set_text(self,texte):
+ self.texte = texte
+
+ def append_text(self,texte):
+ """
+ """
+ self.texte = self.texte +texte
+
+class COMMENTAIRE(ENTITE_JDC):
+
+ def __str__(self):
+ """
+ Retourne une chaîne de caractères représentant self
+ sous une forme interprétable par EFICAS
+ """
+ t=repr(self.texte)
+ return "COMMENTAIRE("+t+")\n"
+
+ def append_text(self,texte):
+ """
+ Ajoute texte à self.texte en enlevant le # initial
+ """
+ if texte[0] == '#':
+ self.texte = self.texte+texte[1:]
+ else:
+ # le dièse n'est pas sur le premier caractère
+ amont,aval = string.split(texte,'#',1) # on découpe suivant la première occurrence de #
+ self.texte = self.texte +amont + aval
+
+class AFFECTATION(ENTITE_JDC):
+
+ def append_text(self,texte):
+ """
+ Ajoute texte à self.texte en enlevant tout retour chariot et tout point virgule
+ """
+ self.texte = self.texte+texte
+
+ def __str__(self):
+ """
+ Retourne une expression de l'affectation compréhensible par ACCAS
+ et exploitable par EFICAS
+ """
+ #t=repr(self.texte)
+ t=self.texte
+ return "PARAMETRE(nom='"+self.name+"',valeur="+t+")"
+
+class COMMANDE_COMMENTARISEE(ENTITE_JDC):
+
+ def append_text(self,texte):
+ """
+ Ajoute texte à self.texte en enlevant les doubles commentaires
+ """
+ texte = string.strip(texte)
+ texte = string.strip(texte[2:])
+ self.texte = self.texte+(len(self.texte)>0)*'\n'+texte
+
+ def __str__(self):
+ """
+ Retourne une expression de la commande commentarisée compréhensible par ACCAS
+ et exploitable par EFICAS
+ """
+ return "COMMANDE_COMM(texte="+repr(self.texte)+")\n"
+
+
+next = {}
+next['if'] = next['elif'] = 'elif', 'else', 'end'
+next['while'] = next['for'] = 'else', 'end'
+next['try'] = 'except', 'finally'
+next['except'] = 'except', 'else', 'end'
+next['else'] = next['finally'] = next['def'] = next['class'] = 'end'
+next['end'] = ()
+start = 'if', 'while', 'for', 'try', 'def', 'class'
+
+class PARSEUR_PYTHON:
+ """
+ Cette classe sert à créer un objet PARSEUR_PYTHON qui réalise l'analyse d'un texte
+ représentant un JDC Python en distinguant :
+ - les commentaires inter commandes
+ - les affectations
+ - les commandes
+ """
+ # au moins 1 caractère non blanc ou non tabulation
+ #pattern_ligne_non_blanche = re.compile(r'^[\w\t]+')
+ pattern_ligne_non_blanche = re.compile(r'[^ \t]+')
+ kwprog = re.compile(
+ r'^\s*(?P<kw>[a-z]+)'
+ r'(\s+(?P<id>[a-zA-Z_]\w*))?'
+ r'[^\w]')
+ endprog = re.compile(
+ r'^\s*#?\s*end\s+(?P<kw>[a-z]+)'
+ r'(\s+(?P<id>[a-zA-Z_]\w*))?'
+ r'[^\w]')
+ wsprog = re.compile(r'^[ \t]*')
+ optionprog=re.compile(r'#\s*parse:\s*([^\n\'"]*)$')
+
+ def __init__(self,texte):
+ # on verifie que le texte fourni se compile correctement
+ compile(texte,"<string>",'exec')
+ self.texte = cStringIO.StringIO(texte)
+ self.line=''
+ self.out=""
+ self.lastcol = 0
+ self.lastrow = 1
+ self.please_indent = 1
+ self.indent_list = []
+ self.indentation=0
+ self.paren_level=0
+ self.affectation=0
+ self.indent_list=[""]
+ self.objet_courant=None
+ self.affectation_flag=1
+ self.comment_flag=1
+ self.buffer=[]
+ self.buffer_indent=""
+
+ def getoptions(self):
+ m= self.optionprog.match(self.line)
+ if m:
+ option=m.group(1)
+ name=option[1:]
+ flag=(option[0] == '+')
+ if name == "affectation": self.affectation_flag=flag
+ if name == "comment": self.comment_flag=flag
+ if name == "all":
+ self.comment_flag=flag
+ self.affectation_flag=flag
+
+ def readline(self):
+ self.line= self.texte.readline()
+ #print "line:",self.line
+ # option ?
+ self.getoptions()
+ return self.line
+
+ def get_texte(self,appli=None):
+ """
+ Retourne le texte issu de l'analyse
+ """
+ for tk in tokenize.generate_tokens(self.readline):
+ self.process_token(tk)
+ return self.out
+
+ def process_token(self, tk):
+ """
+ """
+ ttype, tstring, spos, epos, line = tk
+ thisrow, thiscol = spos
+ #print spos, epos,tokenize.tok_name[ttype],self.lastrow, self.lastcol
+
+ if thisrow > self.lastrow:
+ # si plusieurs lignes (>1)
+ self.out=self.out+"\n" * (thisrow - self.lastrow - 1)
+ self.lastcol = 0
+
+# if thiscol > self.lastcol :
+# self.out=self.out+ " " * (thiscol - self.lastcol)
+# self.please_indent = None
+
+ self.thiscol=thiscol
+ #self.nextrow, self.nextcol = epos
+
+ try:
+ fn = getattr(self, tokenize.tok_name[ttype])
+ except AttributeError:
+ print >>sys.stderr, "No match!", tokenize.tok_name[ttype], tstring
+ return
+
+ if ttype != tokenize.DEDENT and ttype != tokenize.INDENT and self.please_indent:
+ self.do_indent()
+
+ fn(tstring)
+ self.lastrow, self.lastcol = epos
+
+ def output(self,tstring):
+ #print "output",tstring
+
+ if self.thiscol > self.lastcol :
+ #print self.thiscol,self.lastcol
+ self.out=self.out+ " " * (self.thiscol - self.lastcol)
+ self.lastcol=self.thiscol
+
+ self.out=self.out+tstring
+
+ def output_com(self,tstring):
+ self.out=self.out+tstring
+
+ def update_indent(self):
+ #print "update_indent",len(self.indent_list[-1]),len(self.buffer_indent)
+ if len(self.indent_list[-1]) > len(self.buffer_indent):
+ self.out=self.out+(len(self.indent_list[-1]) - len(self.buffer_indent))*" "
+ self.buffer_indent=self.indent_list[-1]
+
+ def do_indent(self):
+ #print "indentation dans do_indent",len(self.indent_list)
+
+ self.out=self.out+self.indent_list[-1]
+ self.buffer_indent=self.indent_list[-1]
+ if self.lastcol+len(self.indent_list[-1]) > self.thiscol:
+ self.lastcol=self.thiscol
+ else:
+ self.lastcol=self.lastcol+len(self.indent_list[-1])
+ self.please_indent = None
+
+ def flush_buffer(self):
+ #if self.buffer:
+ # print len(self.indent_list),self.please_indent
+ for ob in self.buffer:
+ self.out= self.out+ str(ob)
+ self.do_indent()
+ self.buffer=[]
+ self.objet_courant=None
+
+ def NL(self, tstring):
+ if self.affectation:
+ if self.paren_level == 0:
+ # affectation en cours mais complète
+ self.out= self.out+ str(self.affectation_courante)
+ self.affectation_courante=None
+ self.please_indent=1
+ self.affectation=0
+ else:
+ # affectation en cours, on ajoute
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.append_text(tstring)
+ return
+
+ if self.objet_courant:
+ self.objet_courant=None
+ self.buffer.append(tstring)
+ # self.please_indent = None
+ return
+ self.output(tstring)
+ self.please_indent = 1
+
+ def COMMENT(self, tstring):
+ liste= string.split(self.line,"##",1)
+ if len(liste) > 1:
+ # On a trouve un double commentaire
+ before,after=liste
+ if self.affectation:
+ # affectation en cours, on ignore
+ pass
+ elif self.paren_level > 0:
+ self.output(tstring)
+ elif self.comment_flag and not self.pattern_ligne_non_blanche.search(before):
+ # il s'agit d'une commande commentarisée
+ if self.objet_courant == None:
+ if not self.buffer:self.buffer_indent=self.indent_list[-1]
+ self.objet_courant=COMMANDE_COMMENTARISEE()
+ self.buffer.append(self.objet_courant)
+ self.objet_courant.append_text(tstring)
+ self.please_indent = None
+ elif isinstance(self.objet_courant,COMMENTAIRE):
+ self.objet_courant=COMMANDE_COMMENTARISEE()
+ self.buffer.append(self.objet_courant)
+ self.objet_courant.append_text(tstring)
+ self.please_indent = None
+ else:
+ self.objet_courant.append_text(tstring)
+ self.please_indent = None
+ else:
+ # commentaire inline
+ self.output(tstring)
+ self.please_indent = 1
+ return
+
+ else:
+ # On a un commentaire simple
+ new_line = string.split(self.line,'#')[0]
+ if self.affectation:
+ # affectation en cours, on ignore
+ pass
+ elif self.paren_level > 0:
+ self.output(tstring)
+ elif self.comment_flag and not self.pattern_ligne_non_blanche.search(new_line):
+ # commentaire précédé de blancs
+ if self.objet_courant == None:
+ if not self.buffer:self.buffer_indent=self.indent_list[-1]
+ self.objet_courant=COMMENTAIRE()
+ self.buffer.append(self.objet_courant)
+ self.objet_courant.append_text(tstring)
+ self.please_indent = None
+ elif isinstance(self.objet_courant,COMMANDE_COMMENTARISEE):
+ self.objet_courant=COMMENTAIRE()
+ self.buffer.append(self.objet_courant)
+ self.objet_courant.append_text(tstring)
+ self.please_indent = None
+ else:
+ self.objet_courant.append_text(tstring)
+ self.please_indent = None
+ else:
+ # commentaire inline
+ self.output(tstring)
+ self.please_indent = 1
+ return
+
+ def ERRORTOKEN(self, tstring):
+ print "ERRORTOKEN",tstring
+
+ def NAME(self, tstring):
+ if self.buffer:
+ self.update_indent()
+ self.flush_buffer()
+
+ if self.affectation ==1:
+ # on a une expression du type NAME=NAME
+ # on ne veut pas des expressions qui commencent par NAME=NAME(NAME=
+ # on en prend le chemin : on met affectation a 3 pour le signaler
+ # on attend d'en savoir plus
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.append_text(tstring)
+ self.affectation=3
+ return
+ elif self.affectation ==4:
+ # on a une expression qui commence par NAME=NAME(NAME
+ # il s'agit tres probablement d'une commande
+ # on annule l'affectation en cours
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.append_text(tstring)
+ self.affectation=5
+ return
+ elif self.affectation == 2:
+ # affectation en cours, on ajoute
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.append_text(tstring)
+ self.affectation=2
+ return
+ self.affectation=0
+ self.name=None
+ if self.paren_level == 0 and self.affectation_flag:
+ # si on est en dehors de parentheses et en mode transformation d'affectation
+ # on initialise l'attribut name qui indique une affectation en cours
+ self.name=tstring
+ self.output(tstring)
+
+ def ident(self, tstring):
+ self.flush_buffer()
+ self.affectation=0
+ self.output(tstring)
+
+ def NUMBER(self, tstring):
+ self.flush_buffer()
+ if self.affectation>=1:
+ # affectation en cours, on ajoute
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.append_text(tstring)
+ self.affectation=2
+ return
+ self.output(tstring)
+
+ def OP(self,tstring):
+ self.flush_buffer()
+ if tstring in ('(','[','{'): self.paren_level=self.paren_level+1
+ if tstring in (')',']','}'): self.paren_level=self.paren_level-1
+
+ if tstring == '=' and self.affectation ==5:
+ # on a une expression qui commence par NAME=NAME(NAME=)
+ # il peut s'agir d'une commande
+ # on annule l'affectation en cours
+ self.out= self.out+ self.affectation_courante.texte
+ self.affectation_courante=None
+ self.name=None
+ self.affectation=0
+ elif tstring == ')' and self.affectation ==4:
+ # on a une expression qui commence par NAME=NAME()
+ # il peut s'agir d'une commande
+ # on annule l'affectation en cours
+ self.out= self.out+ self.affectation_courante.texte
+ self.affectation_courante=None
+ self.affectation=0
+ elif tstring == '(' and self.affectation == 3:
+ # on a deja trouve NAME=NAME
+ # on passe affectation a 4
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.append_text(tstring)
+ self.affectation=4
+ return
+ elif tstring == ';' and self.affectation>=1:
+ # l'affectation est terminee
+ self.out= self.out+ str(self.affectation_courante)
+ self.affectation_courante=None
+ self.please_indent=1
+ self.affectation=0
+ elif self.affectation>=1:
+ # on complete l'affectation
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.append_text(tstring)
+ self.affectation=2
+ return
+
+ self.affectation=0
+ if self.name and tstring=='=':
+ self.affectation=1
+ self.affectation_courante=AFFECTATION()
+ self.affectation_courante.name=self.name
+ self.output(tstring)
+
+ ENDMARKER = ident
+ NEWLINE=NL
+
+ def INDENT(self, tstring):
+ #tstring=str(len(self.indent_list))*len(tstring)
+ self.indent_list.append(tstring)
+ #print "indentation dans INDENT",len(self.indent_list),len(tstring)
+ self.affectation=0
+ if self.buffer:
+ self.update_indent()
+ self.flush_buffer()
+
+ def DEDENT(self, tstring):
+ #print "DEDENT",tstring,len(tstring)
+ if self.buffer:
+ self.out= self.out+ str(self.buffer[0])
+ if len(self.buffer) > 1:
+ for ob in self.buffer[1:]:
+ self.do_indent()
+ self.out= self.out+ str(ob)
+ self.buffer=[]
+ self.objet_courant=None
+ self.please_indent=1
+
+ self.affectation=0
+ self.indent_list = self.indent_list[:-1]
+ #print "indentation dans DEDENT",len(self.indent_list)
+
+ def STRING(self, tstring):
+ self.flush_buffer()
+ if self.affectation>=1:
+ # affectation en cours, on ajoute
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.append_text(tstring)
+ self.affectation=2
+ return
+ self.output(tstring)
+
+if __name__ == "__main__" :
+ import sys
+ import cStringIO
+ text="""
+#
+# comment
+# comment
+# comment
+#
+
+import sys,os
+
+# commentaire
+# commentaire
+# commentaire
+
+DEBUT();
+##toto = FORMULE(REEL='(REEL:A) = A',);
+
+x=2*cos(90.)/34.
+
+a=1.
+if a != 0:
+ a=+1
+
+b=2.
+c=a+b
+#if 1:
+# d=3
+# e=5
+#try:
+# a=1/2
+#except KeyError:
+# pass
+
+if 1:
+ a=2
+ b=3
+ # commenta
+else:
+ # commen
+ # commen
+ a=3
+ # qqqqqqqqqqqqqqqq
+ c=5
+
+b=5
+ # commentaire
+toto = FORMULE(REEL='(REEL:A) = A',);
+titi = FORMULE(REEL='(REEL:A) = A',) # commentaire inline
+tutu = FORMULE(REEL='(REEL:A) = A',) ## commentaire inline
+
+TEST_TABLE( TABLE=RELV[k],
+ FILTRE=(
+ _F( NOM_PARA = 'QUANTITE',
+ VALE_K = 'MAXIMUM'),),
+ # commentaire
+ NOM_PARA='VMIS', # comm
+ VALE=1.9669824189084E9,
+ REFERENCE='NON_REGRESSION',
+ VERSION='8.1.0' )
+
+if 1:
+ a=fff(a=1,
+ b=2)
+if 1:
+ a=2
+ b=3
+ # commenta
+else:
+ # commen
+ # commen
+ a=3
+
+for k in range(1,10):
+
+ # Appel a GMSH pour le maillage
+
+ f=open("coque.geo","w")
+
+
+a = 1.
+b=3
+c= 3 * 5
+d= 4 + \
+ 5 \
+ -4
+e=toto(a=1)
+x=(1,2)
+y=[3,
+#comme
+4]
+z="a"
+zz='v'
+u='''aaaa
+bbbb'''
+if 1:
+ a=45
+else:
+ a=5.6
+d={"a":0}
+e={"a":0,
+#comme
+"d":4}
+a==1
+x=a==1
+s="-"*80
+fmt_raison='-'*80+'''
+
+ Exception erreur_Fatale interceptee
+ Raison : %s
+
+'''+'-'*80+'xxxxxxxxxxxxxxxx'
+q=30*cos(12)
+f=cos(12)
+#commen'''
+#commen'''
+y=a[1]
+y=["x"]*10
+
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+#
+# comment
+# comment
+# comment
+#
+zz=8.9;
+zz=8.9;aa=10
+P1 = 9.8;
+
+P2 = 8.8;
+
+P3 = 7;
+
+P5 = P3*P1;
+
+P6 = P1-3;
+
+P4 = [2,3,4];
+
+P7=P4[1]
+MA=LIRE_MAILLAGE()
+MA=LIRE_MAILLAGE(#comment
+)
+xyz=cos(10)
+MA=LIRE_MAILLAGE(INFO=1)
+MA=LIRE_MAILLAGE(
+INFO=1)
+MA=LIRE_MAILLAGE(#comme
+INFO=1)
+MA=\
+LIRE_MAILLAGE(INFO=1)
+MA= LIRE_MAILLAGE()
+TFIN = 1.790 # Temps fin pour le calcul
+
+PAS = 0.001 # pas de temps du calcul
+# parse: -affectation
+DS1=[None]*5
+DS2=[None]*5
+DS3=[None]*5
+DS4=[None]*5
+CHS1=[None]*5
+CHS2=[None]*5
+MO=AFFE_MODELE( MAILLAGE=MA,
+ #test de validateur GEOM (typ=grma) avec grma derive de GEOM
+ AFFE=(_F(GROUP_MA = ('LI1'),
+ PHENOMENE = 'MECANIQUE',
+ MODELISATION = 'DIS_TR'),
+ ),
+ INFO=2,);
+
+for k in range(1,5):
+ DS1[k] = CREA_CHAMP( OPERATION='EXTR', TYPE_CHAM='NOEU_DEPL_R',
+ RESULTAT= MODESTA1, NUME_ORDRE=k, NOM_CHAM = 'DEPL');
+
+if x==1:
+ print "coucou"
+elif x==2:
+ print "coucou"
+elif x==2:
+ print "coucou"
+elif x==2:
+ print "coucou"
+else:
+ print "coucou"
+# parse: +affectation
+ff=23 # parametre bidon
+
+# parse: -all
+a=45
+#commment1
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+# parse: +all
+b=45
+#commment2
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+# parse: -comment
+c=45
+#commment3
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+# parse: +comment
+d=45
+#commment5
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+p=sin(ff)
+
+e=toto(a=1)
+e=toto(a=1,b=3)
+e=toto(1,b=3)
+e=toto(a,b=3)
+e=toto()
+sensible=[2.1E11, 0.3, 1.E-6, 1.E-6, ]
+
+n=len(sensible)
+# parse: -affectation
+
+PS=[None]*n
+
+for i in range(n):
+ PS[i]=DEFI_PARA_SENSI(VALE=sensible[i])
+# parse: +affectation
+
+TEST_RESU(RESU=(_F(RESULTAT = U3L,
+ INST = 1.0,
+ NOM_CHAM = 'DEPL',
+ GROUP_NO = 'PPA',
+ NOM_CMP = 'DX',
+ VALE = 2.86E-5,
+ PRECISION = 5.E-2,
+ REFERENCE = 'AUTRE_ASTER',
+ VERSION = '7.1.11',
+ ),
+ )
+ )#
+#
+FIN()
+#
+
+TEST_RESU(RESU=(_F(RESULTAT = U3L,
+ INST = 1.0,
+ NOM_CHAM = 'DEPL',
+ GROUP_NO = 'PPA',
+ NOM_CMP = 'DX',
+ VALE = 2.86E-5,
+ PRECISION = 5.E-2,
+ REFERENCE = 'AUTRE_ASTER',
+ VERSION = '7.1.11',
+ ),
+ )
+ ) #a
+
+titi = FORMULE(REEL='(REEL:A) = A',
+) # commentaire inline
+titi = FORMULE(REEL='(REEL:A) = A',
+ ) # commentaire inline
+
+def f(x):return x
+#comment
+def f(x):
+#comment
+ if a==1:print "coucou"
+ for i in range(10): s=0
+
+#com1
+#com2
+
+#com3
+a=1
+##commendcomm
+for k in range(1,10):
+
+ # Appel a GMSH pour le maillage
+
+ f=open("coque.geo","w")
+#comm
+ if a==1:
+
+ #comm
+
+ for i in x:
+#comm
+##commendcomm
+#comm
+##commendcomm
+#comm
+ if x==3:
+#comm
+ r=1
+ if w==4:
+#comm
+
+ if k:
+
+#comm
+ if g:
+
+#comm
+
+ if t:
+ a=5
+#comm
+if 1:
+ a=2
+ b=3
+ # commenta
+else:
+ # commen
+ # commen
+ a=3
+ # qqqqqqqqqqqqqqqq
+ c=5
+
+b=5
+
+if 1:
+ a=2
+ # commenta
+else:
+ a=3
+if 1:
+ if 2:
+ if 3:
+ a=1
+ elif 4:
+ b=1
+ else:
+ c=5
+ elif 3:
+ x=1
+ else:
+ y=4
+elif 4:
+ s=1
+else:
+ t=9
+#com1
+#com2
+
+#com3
+a=1
+##commendcomm
+for k in range(1,10):
+
+ # Appel a GMSH pour le maillage
+
+ f=open("coque.geo","w")
+#comm
+ if 1:
+ if 2:
+ if 3:
+ a=1
+ else:
+ a=6
+a=1
+##commendcomm
+for k in range(1,10):
+
+ # Appel a GMSH pour le maillage
+
+ f=open("coque.geo","w")
+#comm
+
+ if a==1:
+
+ #comm
+
+ for i in x:
+#comm
+##commendcomm
+#comm
+##commendcomm
+#comm
+ if x==3:
+#comm
+ r=1
+
+ if 1:
+ if 2:
+ if 3:
+ a=1
+ else:
+ a=6
+
+if 1:
+ if 2:
+ if 3:
+ r=1
+ # comm
+ else:
+ x=7
+ toto(a=1,
+b=3)
+SUP_=dict([(grand,0.) for grand in grand_obs])
+
+for k in range(1,ns+1):
+ x=toto(a=1,b=2)
+# comm
+ if 1:
+ #com
+
+ #com
+ x=1
+ #com
+
+ #com
+ ##com
+ elif 3:
+ ##com
+ x=1
+ else:
+ y=3
+
+def f():
+ return
+########################################################################
+
+########################################################################
+# macro commande de post-traitement (ex POST_GOUJ2E)
+# calcul des reactions cumulees suivant les filets
+
+def POST_GOUJ_ops(self,TABLE):
+ ier=0
+
+"""
+ if len(sys.argv)== 2:
+ progname, input = sys.argv
+ f=open(input)
+ t=f.read()
+ f.close()
+ else:
+ t=text
+ txt = PARSEUR_PYTHON(t).get_texte()
+ print txt
+ compile(txt,"<string>",'exec')
"""
import sys,string,traceback
-import parseur_python
+from autre_parseur import PARSEUR_PYTHON
from Noyau import N_CR
def entryPoint():
def convert(self,outformat,appli=None):
if outformat == 'exec':
try:
- return parseur_python.PARSEUR_PYTHON(self.text).get_texte(appli)
+ return PARSEUR_PYTHON(self.text).get_texte(appli)
except:
# Erreur lors de la conversion
l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],
sys.exc_info()[2])
- self.cr.exception("Impossible de convertir le fichier python \
- qui doit contenir des erreurs.\n \
- On retourne le fichier non converti \n \
- Prévenir la maintenance. \n" + string.join(l))
+ self.cr.exception("Impossible de convertir le fichier python "
+ "qui doit contenir des erreurs.\n"
+ "On retourne le fichier non converti.\n"
+ "Prévenir la maintenance. \n" + string.join(l))
# On retourne néanmoins le source initial non converti (au cas où)
return self.text
elif outformat == 'execnoparseur':
#
# ======================================================================
import sys,string,re
+import traceback
class ENTITE_JDC :
def __init__(self,pere):
"""
texte = texte+'\n'
self.texte = self.texte +texte
+ def __str__(self):
+ return self.texte
class COMMENTAIRE(ENTITE_JDC):
"""
Ajoute texte à self.texte en enlevant tout retour chariot et tout point virgule
"""
- if texte[-1] == '\n' : texte = string.strip(texte[0:-1])\r
- if texte[-1] == ';' : texte = string.strip(texte[0:-1])
+ if texte[-1] == '\n' : texte = string.rstrip(texte[0:-1])
+ if texte[-1] == ';' : texte = string.rstrip(texte[0:-1])
self.texte = self.texte+texte
def __str__(self):
et exploitable par EFICAS
"""
nom,valeur = string.split(self.texte,'=',1)
- nom = string.strip(nom)
+ # print nom,valeur
+ n = string.rstrip(nom)
+ nom = string.lstrip(n)
if valeur[-1] == '\n': valeur = valeur[:-1]
- valeur = string.strip(valeur)
+# valeur = string.strip(valeur)
## traitement des "
- if valeur[0]=='"':
- valeur=valeur[1:-1]
- if valeur[-1]=='"':
- valeur=valeur[0:-2]
+# if valeur[0]=='"':
+# valeur=valeur[1:-1]
+# if valeur[-1]=='"':
+# valeur=valeur[0:-2]
- return nom+' = PARAMETRE(nom=\''+nom+'\',valeur="'+valeur+'")\n\n'
+ return n + ' = PARAMETRE(nom=\''+nom+'\',valeur='+valeur+')\n'
class COMMANDE_COMMENTARISEE(ENTITE_JDC):
pattern_commande = re.compile(r'^([A-Z][A-Z0-9_]+)([ \t\r\f\v]*)\(([\w\W]*)')
pattern_eval = re.compile(r'^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)')
pattern_ligne_vide = re.compile(r'^[\t\r\f\v\n]+')
+ pattern_name = re.compile(r'[a-zA-Z_]\w*')
def __init__(self,texte):
self.texte = texte
if self.pattern_commande.match(aval):
return 0
else:
+ s= string.strip(amont)
+ m= self.pattern_name.match(s)
+ if m is None : return 0
+ if m.start() != 0 :return 0
+ if m.end() != len(s):return 0
+ #print texte,amont,aval
return 1
def is_eval(self,texte):
elif commentaire_courant :
# il s'agit de la nième ligne d'un commentaire entre deux commandes
# --> on ajoute cette ligne au commentaire courant
+ #print "ici1",ligne
commentaire_courant.append_text(ligne)
else :
# il s'agit d'un commentaire entre deux commandes
# --> on le crée et il devient le commentaire courant
commentaire_courant = COMMENTAIRE(self)
+ #print "ici2",ligne
commentaire_courant.append_text(ligne)
else:
# la ligne contient des données autre qu'un éventuel commentaire
self.analyse_reel(commande_courante.texte)
commande_courante = None
else:
- #--> poursuite d'une affectation
- # PN -- pour Empecher une erreur pas propre
- if affectation_courante != None :
- affectation_courante.append_text(ligne)
- #affectation_courante.append_text(ligne)
+ if commande_courante:
+ # commande en cours
+ commande_courante.append_text(ligne)
+ affectation_courante = None
+ if commande_courante.get_nb_par() == 0:
+ # la commande courante est terminée (autant de parenthèses fermantes qu'ouvrantes)
+ self.analyse_reel(commande_courante.texte)
+ commande_courante = None
+ else:
+ #print 'ici3',ligne
+ #e=ENTITE_JDC(self)
+ #e.append_text(ligne)
+ #--> poursuite d'une affectation
+ # PN -- pour Empecher une erreur pas propre
+ if affectation_courante != None :
+ affectation_courante.append_text(ligne)
+ #affectation_courante.append_text(ligne)
def enleve (self,texte) :
if __name__ == "__main__" :
#fichier = 'D:/Eficas_dev/Tests/zzzz100a.comm'
fichier = 'U:/Eficas_dev/Tests/test_eval.comm'
+ fichier = '/local/chris/ASTER/Eficas/Eficas1_10/EficasV1/Tests/testcomm/b.comm'
+ fichier = '/local/chris/ASTER/instals/STA8.2/astest/forma11d.comm'
texte = open(fichier,'r').read()
- txt = PARSEUR_PYTHON(texte).get_texte()
+ class appli:
+ dict_reels={}
+ liste_simp_reel=[]
+ txt = PARSEUR_PYTHON(texte).get_texte(appli())
print txt
+ compile(txt, '<string>', 'exec')
import Extensions
from Extensions.parametre import ITEM_PARAMETRE
from Formatage import Formatage
+from Extensions.param2 import Formula
def entryPoint():
"""
return self.generMCNUPLET(obj)
elif isinstance(obj,ITEM_PARAMETRE):
return self.generITEM_PARAMETRE(obj)
+ elif isinstance(obj,Formula):
+ return self.generFormula(obj)
else:
raise "Type d'objet non prévu",obj
def generITEM_PARAMETRE(self,obj):
return repr(obj)
+ def generFormula(self,obj):
+ return repr(obj)
+
def generPARAMETRE(self,obj):
"""
Cette méthode convertit un PARAMETRE
en une liste de chaines de caractères à la syntaxe python
"""
- if type(obj.valeur) == types.StringType:
- # PN pour corriger le bug a='3+4' au lieu de a= 3+4
- #return obj.nom + " = '" + obj.valeur + "';\n"
- return obj.nom + " = " + obj.valeur + ";\n"
- else:
- return obj.nom + ' = ' + str(obj.valeur) + ';\n'
+ return repr(obj) + ";\n"
def generETAPE_NIVEAU(self,obj):
"""
l.append(data)
return l
+ def format_item(self,valeur,etape):
+ if type(valeur) == types.InstanceType :
+ if valeur.__class__.__name__ == 'CO' or hasattr(etape,'sdprods') and valeur in etape.sdprods :
+ s = "CO('"+ self.generator(valeur) +"')"
+ elif isinstance(valeur,Accas.PARAMETRE):
+ # il ne faut pas prendre la string que retourne gener
+ # mais seulement le nom dans le cas d'un paramètre
+ s = valeur.nom
+ else:
+ s = self.generator(valeur)
+ elif type(valeur) == types.FloatType :
+ # Pour un flottant on utilise str
+ # ou la notation scientifique
+ s = str(valeur)
+ try :
+ clefobj=obj.GetNomConcept()
+ if self.appli.dict_reels.has_key(clefobj):
+ if self.appli.dict_reels[clefobj].has_key(valeur):
+ s=self.appli.dict_reels[clefobj][valeur]
+ except:
+ pass
+ elif type(valeur) == types.StringType :
+ if valeur.find('\n') == -1:
+ # pas de retour chariot, on utilise repr
+ s = repr(valeur)
+ elif valeur.find('"""') == -1:
+ # retour chariot mais pas de triple ", on formatte
+ s='"""'+valeur+'"""'
+ else:
+ s = repr(valeur)
+ else :
+ # Pour les autres types on utilise repr
+ s = repr(valeur)
+ return s
+
+
def generMCSIMP(self,obj) :
"""
Convertit un objet MCSIMP en une liste de chaines de caractères à la
if type(obj.valeur) in (types.TupleType,types.ListType) :
s = ''
for val in obj.valeur :
- if type(val) == types.InstanceType :
- if hasattr(obj.etape,'sdprods') and val in obj.etape.sdprods :
- s = s + "CO('"+ self.generator(val) +"')"
- elif val.__class__.__name__ == 'CO':
- s = s + "CO('"+ self.generator(val) +"')"
- elif isinstance(val,Accas.PARAMETRE):
- # il ne faut pas prendre la string que retourne gener
- # mais seulement le nom dans le cas d'un paramètre
- s = s + val.nom
- else:
- s = s + self.generator(val)
- elif type(val) == types.FloatType :
- # Pour un flottant on utilise str qui a une precision de
- # "seulement" 12 chiffres : evite les flottants du genre 0.599999999999998
- s2=str(val)
- try :
- clefobj=obj.GetNomConcept()
- if self.appli.dict_reels.has_key(clefobj):
- if self.appli.dict_reels[clefobj].has_key(val):
- s2=self.appli.dict_reels[clefobj][val]
- except:
- pass
- s = s + s2
- else :
- # Pour les autres types on utilise repr
- s = s + `val`
- s = s + ','
+ s =s +self.format_item(val,obj.etape) + ','
if len(obj.valeur) > 1:
s = '(' + s + '),'
if obj.nbrColonnes() :
s=self.formatColonnes(obj.nbrColonnes(),s)
else :
- val=obj.valeur
- if type(val) == types.InstanceType :
- if hasattr(obj.etape,'sdprods') and val in obj.etape.sdprods :
- s = "CO('"+ self.generator(val) +"')"
- elif val.__class__.__name__ == 'CO':
- s = "CO('"+ self.generator(val) +"')"
- elif isinstance(val,Accas.PARAMETRE):
- # il ne faut pas prendre la string que retourne gener
- # mais seulement le nom dans le cas d'un paramètre
- s = val.nom
- elif isinstance(val,Extensions.parametre.PARAMETRE):
- s = val.nom
- else:
- s = self.generator(val)
- elif type(val) == types.FloatType :
- # Pour un flottant on utilise str
- # ou la notation scientifique
- s = str(val)
- try :
- clefobj=obj.GetNomConcept()
- if self.appli.dict_reels.has_key(clefobj):
- if self.appli.dict_reels[clefobj].has_key(val):
- s=self.appli.dict_reels[clefobj][val]
- except:
- pass
- else :
- # Pour les autres types on utilise repr
- if isinstance(val,Extensions.parametre.PARAMETRE):
- s = val.nom
- else:
- s = `val`
- s= s + ','
+ s=self.format_item(obj.valeur,obj.etape) + ','
return s
