-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
# Copyright (C) 2007-2013 EDF R&D
#
# This library is free software; you can redistribute it and/or
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
"""
Ce package fournit les classes de base d'EFICAS.
- Ces classes permettent d'effectuer quelques opérations basiques :
+ Ces classes permettent d'effectuer quelques opérations basiques :
- - la création
+ - la création
- - la vérification des définitions
+ - la vérification des définitions
- - la création d'objets de type OBJECT à partir d'une définition de type ENTITE
+ - la création d'objets de type OBJECT à partir d'une définition de type ENTITE
"""
# Avant toutes choses, on met le module context dans le global de l'interpreteur (__builtin__)
-# sous le nom CONTEXT afin d'avoir accès aux fonctions
-# get_current_step, set_current_step et unset_current_step de n'importe où
+# sous le nom CONTEXT afin d'avoir accès aux fonctions
+# get_current_step, set_current_step et unset_current_step de n'importe où
import context
import __builtin__
-__builtin__.CONTEXT=context
+__builtin__.CONTEXT = context
+
def _(msg):
"""Differs translation."""
from N_SIMP import SIMP
from N_FACT import FACT
-# structures de données
+# structures de données
import asojb
from asojb import AsBase
+
+# Only the first MAXSIZE objects will be checked
+# This is used for the number of MCFACT, the number of MCSIMP and the number of
+# values in a MCSIMP.
+MAXSIZE = 500
+
+MAXSIZE_MSGCHK = ' <A> Only the first {0} occurrences (total: {1}) have been checked.'
+MAXSIZE_MSGKEEP = ' <A> Only the first {0} occurrences (total: {1}) have been kept.'
-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
# Copyright (C) 2007-2013 EDF R&D
#
# This library is free software; you can redistribute it and/or
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
class Parmi(object):
+
"""Classe qui exprime une contrainte multiple pour un attribut"""
+
def __init__(self, *args):
self.values = list(args)
- def add_value(self, value ):
+ def add_value(self, value):
if value not in self.values:
- self.values.append( value )
+ self.values.append(value)
- def __call__(self, obj, name, value, log ):
+ def __call__(self, obj, name, value, log):
if value not in self.values:
- log.err( obj, "l'attribut %s=%r n'est pas dans %r" % (name, value, self.values) )
+ log.err(obj, "l'attribut %s=%r n'est pas dans %r" %
+ (name, value, self.values))
def __repr__(self):
- l = [ "Parmi(", ]
- g = [ repr(v) for v in self.values ]
- l.append( ", ".join(g) )
- l.append( ")" )
- return "".join( l )
+ l = ["Parmi(", ]
+ g = [repr(v) for v in self.values]
+ l.append(", ".join(g))
+ l.append(")")
+ return "".join(l)
+
class CheckLog(object):
- """Un validateur qui enregistre toutes les erreurs trouvées.
- checkedXXX répond True si la "marq" courante est inférieure ou égale
- à la celle de la dernière vérification.
- Si on incrémentait "marq" à chaque étape, on revérifie à chaque fois.
+
+ """Un validateur qui enregistre toutes les erreurs trouvées.
+ checkedXXX répond True si la "marq" courante est inférieure ou égale
+ à la celle de la dernière vérification.
+ Si on incrémentait "marq" à chaque étape, on revérifie à chaque fois.
"""
def __init__(self):
- self.msg = []
- self.names = {}
- self.cksums = {}
- self.optional = False
- self._marq = 1
+ self.msg = []
+ self.names = {}
+ self.cksums = {}
+ self.optional = False
+ self._marq = 1
self._lastmarq = self._marq
- self._debug = False
- self._profond = False # True pour forcer des vérifications plus profondes
+ self._debug = False
+ self._profond = False # True pour forcer des vérifications plus profondes
- def log(self, level, obj, msg ):
- if obj :
- self.msg.append( (level, obj.nomj(), msg) )
- else :
- self.msg.append( (level, 'None', msg) )
+ def log(self, level, obj, msg):
+ if obj:
+ self.msg.append((level, obj.nomj(), msg))
+ else:
+ self.msg.append((level, 'None', msg))
- def err(self, obj, msg ):
- self.log( 0, obj, msg )
+ def err(self, obj, msg):
+ self.log(0, obj, msg)
- def warn(self, obj, msg ):
- self.log( 1, obj, msg )
+ def warn(self, obj, msg):
+ self.log(1, obj, msg)
def visitOJB(self, obj):
key = obj.nomj()
self.names[key] = self._marq
def checkSumOJB(self, obj, sd, maj='non'):
- # vérifie que le checksum de obj n'a pas changé
+ # vérifie que le checksum de obj n'a pas changé
# sd : concept qui contient obj
- # maj='maj', l'opérateur a le droit de modifier ojb
- if obj.exists :
+ # maj='maj', l'opérateur a le droit de modifier ojb
+ if obj.exists:
import md5
- m=md5.new()
+ m = md5.new()
m.update(str(obj.get()))
- cksum=m.digest()
- nom=obj.nomj()
- if not self.cksums.has_key(nom) :
- self.cksums[nom]=cksum
- else :
- if self.cksums[nom] != cksum :
+ cksum = m.digest()
+ nom = obj.nomj()
+ if not self.cksums.has_key(nom):
+ self.cksums[nom] = cksum
+ else:
+ if self.cksums[nom] != cksum:
self.cksums[nom] = cksum
- #if maj.strip()=='maj' and nom[0:8].strip()==sd.nomj.nomj[0:8].strip() :
- # Remarque : ne pas tester 'maj' premet de résoudre (un peu) le problème
- # posé par la commande DETRUIRE
- if nom[0:8].strip()==sd.nomj.nomj[0:8].strip() :
+ # if maj.strip()=='maj' and nom[0:8].strip()==sd.nomj.nomj[0:8].strip() :
+ # Remarque : ne pas tester 'maj' premet de résoudre (un peu) le problème
+ # posé par la commande DETRUIRE
+ if nom[0:8].strip() == sd.nomj.nomj[0:8].strip():
pass
- else :
- self.err(obj,'Le checksum a changé')
+ else:
+ self.err(obj, 'Le checksum a changé')
def visitAsBase(self, obj):
key = (obj.nomj(), obj.__class__.__name__)
def force(self, force=False):
if not force:
- self._marq = 1
+ self._marq = 1
else:
- self._lastmarq += 1
- self._marq = self._lastmarq
+ self._lastmarq += 1
+ self._marq = self._lastmarq
def checkedOJB(self, obj):
key = obj.nomj()
res = self.names.get(key, 0) >= self._marq
- self.help_dbg([key,], res)
+ self.help_dbg([key, ], res)
return res
def checkedAsBase(self, obj):
def help_dbg(self, key, res):
if self._debug:
if res:
- s = 'ignore'
+ s = 'ignore'
else:
- s = 'check '
+ s = 'check '
print '#DBG %6d %s : %s' % (self._marq, s, ', '.join(key))
def __str__(self):
- d = { 0: "E", 1:"W" }
- return "\n".join( [ "%s:%s: %s" % (d[l],n,m)
- for l,n,m in self.msg ])
+ d = {0: "E", 1: "W"}
+ return "\n".join(["%s:%s: %s" % (d[l], n, m)
+ for l, n, m in self.msg])
+
class CheckFail(CheckLog):
- """Un validateur qui lève une exception
- dès la première erreur"""
- def err(self, obj, msg ):
- raise AssertionError("%s: %s" % (obj.nomj(), msg) )
+
+ """Un validateur qui lève une exception
+ dès la première erreur"""
+
+ def err(self, obj, msg):
+ raise AssertionError("%s: %s" % (obj.nomj(), msg))
-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
# Copyright (C) 2007-2013 EDF R&D
#
# This library is free software; you can redistribute it and/or
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
"""
Description des types de base aster
-version 2 - réécrite pour essayer de simplifier
-le problème des instances/types et instances/instances
+version 2 - réécrite pour essayer de simplifier
+le problème des instances/types et instances/instances
-le type de base ASBase permet de représenter une structure
-de donnée. Une instance de ASBase comme attribut d'une classe
-dérivée de ASBase représente une sous-structure nommée.
+le type de base ASBase permet de représenter une structure
+de donnée. Une instance de ASBase comme attribut d'une classe
+dérivée de ASBase représente une sous-structure nommée.
-une instance de ASBase 'libre' représente une instance de la
-structure de donnée complète.
+une instance de ASBase 'libre' représente une instance de la
+structure de donnée complète.
-c'est ce comportement qui est capturé dans la classe StructType
+c'est ce comportement qui est capturé dans la classe StructType
"""
from basetype import Type
+
class SDNom(Type):
- """Objet représentant une sous-partie de nom
+
+ """Objet représentant une sous-partie de nom
d'objet jeveux"""
nomj = None
debut = None
just = None
justtype = None
- def __init__(self, nomj=None, debut=None, fin=None, just='l', **kwargs ):
+ def __init__(self, nomj=None, debut=None, fin=None, just='l', **kwargs):
"""
Configure un objet nom
- nomj : la partie du nom fixée (par ex .TITR) ou '' si non précisée
- debut, fin : la partie du K24 concernée
+ nomj : la partie du nom fixée (par ex .TITR) ou '' si non précisée
+ debut, fin : la partie du K24 concernée
just : la justification a droite ou a gauche ('l' ou 'r')
- kwargs : inutilisé, juste par simplicité
+ kwargs : inutilisé, juste par simplicité
Note:
On utilise cet objet comme attribut d'instance ou de classe.
En attribut de classe pour les noms de structure, cela permet
- de définir la position du nom d'objet dans le nom jeveux, l'attribut
+ de définir la position du nom d'objet dans le nom jeveux, l'attribut
nom est alors la valeur du suffixe pour une sous-structure ou None pour
une structure principale.
"""
- super( SDNom, self ).__init__( nomj=nomj, debut=debut, fin=fin, just=just, **kwargs )
- self.update( (nomj, debut, fin, just) )
+ super(SDNom, self).__init__(
+ nomj=nomj, debut=debut, fin=fin, just=just, **kwargs)
+ self.update((nomj, debut, fin, just))
def __call__(self):
if self._parent is None or self._parent._parent is None:
debut = self.debut or 0
- prefix = ' '*debut
+ prefix = ' ' * debut
else:
# normalement
# assert self._parent.nomj is self
debut = self.debut or nomparent.fin or len(prefix)
fin = self.fin or 24
nomj = self.nomj or ''
- nomj = self.just( nomj, fin-debut )
+ nomj = self.just(nomj, fin - debut)
prefix = prefix.ljust(24)
- res = prefix[:debut]+nomj+prefix[fin:]
+ res = prefix[:debut] + nomj + prefix[fin:]
return res[:24]
def fcata(self):
- return self.just(self.nomj,self.fin-self.debut).replace(' ','?')
+ return self.just(self.nomj, self.fin - self.debut).replace(' ', '?')
def __repr__(self):
- return "<SDNom(%r,%s,%s)>" % (self.nomj,self.debut,self.fin)
+ return "<SDNom(%r,%s,%s)>" % (self.nomj, self.debut, self.fin)
- # On utilise pickle pour les copies, et pickle ne sait pas gérer la
- # sauvegarde de str.ljust ou str.rjust (c'est une méthode non liée)
+ # On utilise pickle pour les copies, et pickle ne sait pas gérer la
+ # sauvegarde de str.ljust ou str.rjust (c'est une méthode non liée)
def __getstate__(self):
- return (self.nomj, self.debut, self.fin, self.justtype )
+ return (self.nomj, self.debut, self.fin, self.justtype)
- def __setstate__( self, (nomj,debut,fin,just) ):
+ def __setstate__(self, (nomj, debut, fin, just)):
self.nomj = nomj
self.debut = debut
self.fin = fin
- if just=='l' or just is None:
+ if just == 'l' or just is None:
self.just = str.ljust
- elif just=='r':
+ elif just == 'r':
self.just = str.rjust
else:
- raise ValueError("Justification '%s' invalide" % just )
+ raise ValueError("Justification '%s' invalide" % just)
self.justtype = just
-
- def update( self, (nomj,debut,fin,just) ):
+ def update(self, (nomj, debut, fin, just)):
if nomj is not None:
self.nomj = nomj
if self.debut is None:
if self.fin is None:
self.fin = fin
if self.justtype is None and just is not None:
- if just=='l':
+ if just == 'l':
self.just = str.ljust
- elif just=='r':
+ elif just == 'r':
self.just = str.rjust
else:
- raise ValueError("Justification '%s' invalide" % just )
+ raise ValueError("Justification '%s' invalide" % just)
self.justtype = just
- def reparent( self, parent, new_name ):
+ def reparent(self, parent, new_name):
self._parent = parent
self._name = new_name
for nam in self._subtypes:
- obj = getattr( self, nam )
- obj.reparent( self, nam )
+ obj = getattr(self, nam)
+ obj.reparent(self, nam)
if self.nomj is None and self._parent._name is not None:
self.nomj = "." + self._parent._name
-
-
-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
# Copyright (C) 2007-2013 EDF R&D
#
# This library is free software; you can redistribute it and/or
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
"""
Description des OJB jeveux
from basetype import Type
from asnom import SDNom
from ascheckers import CheckLog
-import traceback,sys
+import traceback
+import sys
# pour utilisation dans eficas
try:
- import aster
- from Utilitai.Utmess import UTMESS
+ import aster
+ from Utilitai.Utmess import UTMESS
except:
- pass
+ pass
# -----------------------------------------------------------------------------
+
+
class AsBase(Type):
nomj = SDNom()
optional = False
- def __init__(self, nomj=None, *args, **kwargs ):
- super(AsBase,self).__init__( nomj, *args, **kwargs )
+ def __init__(self, nomj=None, *args, **kwargs):
+ super(AsBase, self).__init__(nomj, *args, **kwargs)
assert self.nomj is not self.__class__.nomj
- if isinstance( nomj, str ):
+ if isinstance(nomj, str):
self.nomj.nomj = nomj
- elif isinstance( nomj, SDNom ):
- self.nomj.update( nomj.__getstate__() )
+ elif isinstance(nomj, SDNom):
+ self.nomj.update(nomj.__getstate__())
def set_name(self, nomj):
"""Positionne le nomj de self
"""
- assert isinstance( self.nomj.nomj, str ), "uniquement pour les concepts"
+ assert isinstance(self.nomj.nomj, str), "uniquement pour les concepts"
self.nomj.nomj = nomj
def check(self, checker=None):
if checker is None:
checker = CheckLog()
- # vérif déjà faite ? (en tenant compte du type)
+ # vérif déjà faite ? (en tenant compte du type)
if checker.checkedAsBase(self):
return checker
- checker.visitAsBase( self )
+ checker.visitAsBase(self)
- # vérifie les enfants :
+ # vérifie les enfants :
optional = checker.optional
checker.optional = checker.optional or self.optional
for name in self._subtypes:
v = getattr(self, name)
- if isinstance( v, (OJB,AsBase) ):
+ if isinstance(v, (OJB, AsBase)):
v.check(checker)
for name in dir(self):
- if name.startswith( 'check_' ):
+ if name.startswith('check_'):
v = getattr(self, name)
if callable(v):
- try :
- v( checker )
- except :
- mess=60*'-'+'\n'
- mess=mess+'Erreur SDVERI (Attention : vérification incomplète)'+'\n'
- mess=mess.join(traceback.format_tb(sys.exc_traceback))
- checker.err(self,mess)
+ try:
+ v(checker)
+ except:
+ mess = 60 * '-' + '\n'
+ mess = mess + \
+ 'Erreur SDVERI (Attention : vérification incomplète)' + \
+ '\n'
+ mess = mess.join(
+ traceback.format_tb(sys.exc_traceback))
+ checker.err(self, mess)
checker.optional = optional
return checker
- def members( self ):
- pass
-
def dump(self, indent=""):
import pydoc
l = []
f = "(f)"
else:
f = "(o)"
- l.append( f+" "+nomj )
- #l.append( '-'*(len(nomj)+3) )
+ l.append(f + " " + nomj)
for name in self._subtypes:
obj = getattr(self, name)
- if isinstance(obj,(AsBase,OJB)):
- l.append( obj.dump(indent) )
+ if isinstance(obj, (AsBase, OJB)):
+ l.append(obj.dump(indent))
for name in dir(self):
- if name.startswith( 'check_' ):
+ if name.startswith('check_'):
obj = getattr(self, name)
if callable(obj) and name.startswith("check_"):
- checkers.append( obj )
+ checkers.append(obj)
- indent = " "*len(nomj)
+ indent = " " * len(nomj)
for checker in checkers:
- doc = pydoc.text.document( checker )
+ doc = pydoc.text.document(checker)
for line in doc.splitlines():
- l.append( indent + line )
- return "\n".join( l )
+ l.append(indent + line)
+ return "\n".join(l)
def short_repr(self):
- return "<%s(%x,%r)>" % (self.__class__.__name__, id(self), self.nomj() )
+ return "<%s(%x,%r)>" % (self.__class__.__name__, id(self), self.nomj())
def long_repr(self):
if not hasattr(self, "accessible") or not self.accessible():
- # hors Aster ou en par_lot='oui'
- return self.short_repr()
+ # hors Aster ou en par_lot='oui'
+ return self.short_repr()
else:
- from Cata.cata import IMPR_CO, _F
- IMPR_CO(CONCEPT=_F(NOM=self.nom), UNITE=6)
- return ''
+ from Cata.cata import IMPR_CO, _F
+ IMPR_CO(CONCEPT=_F(NOM=self.nom), UNITE=6)
+ return ''
def __repr__(self):
- # par défaut, on fait court !
+ # par défaut, on fait court !
return self.short_repr()
# -----------------------------------------------------------------------------
class JeveuxAttr(object):
+
"""Un attribut jeveux"""
+
def __init__(self, name):
self.name = name
def __get__(self, obj, klass):
raise NotImplementedError
- def check(self, attrname, obj, log ):
- checker = getattr(obj, "_"+attrname, None )
+ def check(self, attrname, obj, log):
+ checker = getattr(obj, "_" + attrname, None)
if checker is None:
return True
- val = self.__get__( obj, obj.__class__ )
- if callable( checker ):
- return checker( obj, attrname, val, log )
+ val = self.__get__(obj, obj.__class__)
+ if callable(checker):
+ return checker(obj, attrname, val, log)
+ elif val == checker:
+ return True
else:
- test = val == checker
- if not test:
- log.err( obj, "Attribut incorrect %s %r!=%r" % (self.name, val, checker ) )
- return test
+ log.err(obj, "Attribut incorrect %s %r!=%r" %
+ (self.name, val, checker))
+ return False
# -----------------------------------------------------------------------------
+
+
class JeveuxExists(JeveuxAttr):
+
def __init__(self):
pass
if obj is None:
return self
nomj = obj.nomj()
- if len(nomj)!=24:
+ if len(nomj) != 24:
raise AssertionError(repr(nomj))
- return aster.jeveux_exists( nomj.ljust(24) )
+ return aster.jeveux_exists(nomj.ljust(24))
# -----------------------------------------------------------------------------
+
+
class JeveuxIntAttr(JeveuxAttr):
+
def __get__(self, obj, klass):
if obj is None:
return self
nomj = obj.nomj()
- if aster.jeveux_exists( nomj ):
- return aster.jeveux_getattr( nomj, self.name )[0]
- else :
+ if aster.jeveux_exists(nomj):
+ return aster.jeveux_getattr(nomj, self.name)[0]
+ else:
return None
# -----------------------------------------------------------------------------
+
+
class JeveuxStrAttr(JeveuxAttr):
+
def __get__(self, obj, klass):
if obj is None:
return self
nomj = obj.nomj()
- if aster.jeveux_exists( nomj ):
- return aster.jeveux_getattr( nomj, self.name )[1].strip()
- else :
+ if aster.jeveux_exists(nomj):
+ return aster.jeveux_getattr(nomj, self.name)[1].strip()
+ else:
return None
# -----------------------------------------------------------------------------
+
+
class OJB(AsBase):
_clas = None
_genr = None
xous = JeveuxStrAttr("XOUS")
docu = JeveuxStrAttr("DOCU")
exists = JeveuxExists()
- #optional = False
nomj = SDNom()
def __init__(self, nomj=None, **attrs):
- super(OJB,self).__init__( nomj, **attrs )
- self.foreachattr( self.setattribute, attrs )
+ super(OJB, self).__init__(nomj, **attrs)
+ self.foreachattr(self.setattribute, attrs)
self.optional = attrs.get('optional', False)
- def setattribute( self, name, prop, attrs ):
- _name = "_"+name
+ def setattribute(self, name, prop, attrs):
+ _name = "_" + name
if name in attrs:
- setattr( self, _name, attrs[name] )
+ setattr(self, _name, attrs[name])
def get(self):
nomj = self.nomj()
- if aster.jeveux_exists( nomj ):
- obj_simple = aster.jeveux_getattr( nomj, 'XOUS')[1].strip() == 'S'
- if obj_simple :
- return aster.getvectjev( nomj )
- else :
- return aster.getcolljev( nomj )
+ if aster.jeveux_exists(nomj):
+ obj_simple = aster.jeveux_getattr(nomj, 'XOUS')[1].strip() == 'S'
+ if obj_simple:
+ return aster.getvectjev(nomj)
+ else:
+ return aster.getcolljev(nomj)
else:
return None
def get_stripped(self):
- """Fonction utilitaire, renvoie une liste de chaines 'strippées'"""
+ """Fonction utilitaire, renvoie une liste de chaines 'strippées'"""
data = self.get()
if data is not None:
- return [ x.strip() for x in data ]
+ return [x.strip() for x in data]
else:
return []
def foreachattr(self, callback, *args, **kwargs):
klass = self.__class__
for k in dir(klass):
- v = getattr( klass, k )
+ v = getattr(klass, k)
if isinstance(v, JeveuxAttr):
- callback( k, v, *args, **kwargs )
+ callback(k, v, *args, **kwargs)
def check(self, checker=None):
if checker is None:
checker = CheckLog()
- # l'objet a déjà été vérifié, on ne fait rien
+ # l'objet a déjà été vérifié, on ne fait rien
if checker.checkedOJB(self):
- return checker
- checker.visitOJB( self )
+ return checker
+ checker.visitOJB(self)
if self.exists:
- self.foreachattr( lambda k,v,obj,c: v.check(k, obj, c),
- self, checker )
+ self.foreachattr(lambda k, v, obj, c: v.check(k, obj, c),
+ self, checker)
else:
- if not self.optional and not checker.optional :
- checker.err( self, "n'existe pas (%r)" %self._parent )
+ if not self.optional and not checker.optional:
+ checker.err(self, "n'existe pas (%r)" % self._parent)
return checker
def dump(self, indent=""):
f = "(f)"
else:
f = "(o)"
- return f +" "+ self.nomj() +" "+ str(self.exists)
+ return f + " " + self.nomj() + " " + str(self.exists)
# -----------------------------------------------------------------------------
-def Facultatif( ojb ):
+
+
+def Facultatif(ojb):
ojb.optional = True
return ojb
# -----------------------------------------------------------------------------
+
+
class OJBVect(OJB):
lonmax = JeveuxIntAttr("LONMAX")
lonuti = JeveuxIntAttr("LONUTI")
_genr = "V"
# -----------------------------------------------------------------------------
+
+
class OJBPtnom(OJB):
nommax = JeveuxIntAttr("NOMMAX")
nomuti = JeveuxIntAttr("NOMUTI")
_type = "K"
# -----------------------------------------------------------------------------
+
+
class OJBCollec(OJB):
stockage = JeveuxStrAttr("STOCKAGE")
- nutioc = JeveuxIntAttr( "NUTIOC" )
- acces = JeveuxStrAttr( "ACCES" )
- modelong = JeveuxStrAttr( "MODELONG" )
- nmaxoc = JeveuxIntAttr( "NMAXOC" )
+ nutioc = JeveuxIntAttr("NUTIOC")
+ acces = JeveuxStrAttr("ACCES")
+ modelong = JeveuxStrAttr("MODELONG")
+ nmaxoc = JeveuxIntAttr("NMAXOC")
# -----------------------------------------------------------------------------
+
+
class AsVI(OJBVect):
_type = "I"
# -----------------------------------------------------------------------------
+
+
class AsVS(OJBVect):
_type = "S"
# -----------------------------------------------------------------------------
+
+
class AsVR(OJBVect):
_type = "R"
# -----------------------------------------------------------------------------
+
+
class AsVC(OJBVect):
_type = "C"
# -----------------------------------------------------------------------------
+
+
class AsVL(OJBVect):
_type = "L"
# -----------------------------------------------------------------------------
+
+
class AsVK8(OJBVect):
_type = "K"
_ltyp = 8
# -----------------------------------------------------------------------------
+
+
class AsVK16(OJBVect):
_type = "K"
_ltyp = 16
# -----------------------------------------------------------------------------
+
+
class AsVK24(OJBVect):
_type = "K"
_ltyp = 24
# -----------------------------------------------------------------------------
+
+
class AsVK32(OJBVect):
_type = "K"
_ltyp = 32
# -----------------------------------------------------------------------------
+
+
class AsVK80(OJBVect):
_type = "K"
_ltyp = 80
# Pour compatibilite
AsObject = OJB
-AsColl = OJBCollec
-AsPn = OJBPtnom
-AsVect = OJBVect
+AsColl = OJBCollec
+AsPn = OJBPtnom
+AsVect = OJBVect
-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
# Copyright (C) 2007-2013 EDF R&D
#
# This library is free software; you can redistribute it and/or
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
+
"""
+
Description des types de base aster
-----------------------------------
-version 2 - réécrite pour essayer de simplifier
-le problème des instances/types et instances/instances.
+version 2 - réécrite pour essayer de simplifier
+le problème des instances/types et instances/instances.
-Le type de base `Type` permet de représenter une structure
-de donnée. Une instance de `Type` comme attribut d'une classe
-dérivée de `Type` représente une sous-structure nommée.
+Le type de base `Type` permet de représenter une structure
+de donnée. Une instance de `Type` comme attribut d'une classe
+dérivée de `Type` représente une sous-structure nommée.
-Une instance de `Type` 'libre' représente une instance de la
-structure de donnée complète.
+Une instance de `Type` 'libre' représente une instance de la
+structure de donnée complète.
-C'est ce comportement qui est capturé dans la classe BaseType
+C'est ce comportement qui est capturé dans la classe BaseType
-La classe `Type` hérite de BaseType et y associe la métaclasse MetaType.
+La classe `Type` hérite de BaseType et y associe la métaclasse MetaType.
"""
__docformat__ = "restructuredtext"
-
-
class MetaType(type):
- """Métaclasse d'un type représentant une structure de données.
- Les méthodes spéciales __new__ et __call__ sont réimplémentées
+
+ """Métaclasse d'un type représentant une structure de données.
+ Les méthodes spéciales __new__ et __call__ sont réimplémentées
"""
- def __new__( mcs, name, bases, classdict ):
- """Création d'une nouvelle 'classe' dérivant de Type.
+ def __new__(mcs, name, bases, classdict):
+ """Création d'une nouvelle 'classe' dérivant de Type.
- Cette méthode permet de calculer certains attributs automatiquement:
+ Cette méthode permet de calculer certains attributs automatiquement:
- L'attribut _subtypes qui contient la liste des sous-structures
- de type 'Type' attributs (directs ou hérités) de cette classe.
+ de type 'Type' attributs (directs ou hérités) de cette classe.
- Pour chaque attribut de classe héritant de Type, on recrée une nouvelle
- instance des attributs hérités pour pouvoir maintenir une structure de
- parentée entre l'attribut de classe et sa nouvelle classe.
+ Pour chaque attribut de classe héritant de Type, on recrée une nouvelle
+ instance des attributs hérités pour pouvoir maintenir une structure de
+ parentée entre l'attribut de classe et sa nouvelle classe.
L'effet obtenu est que tous les attributs de classe ou des classes parentes
- de cette classe sont des attributs associés à la classe feuille. Ces attributs
+ de cette classe sont des attributs associés à la classe feuille. Ces attributs
ont eux-meme un attribut parent qui pointe sur la classe qui les contient.
"""
- new_cls = type.__new__( mcs, name, bases, classdict )
+ new_cls = type.__new__(mcs, name, bases, classdict)
new_cls._subtypes = []
for b in bases:
- if hasattr(b,'_subtypes'):
+ if hasattr(b, '_subtypes'):
new_cls._subtypes += b._subtypes
# affecte la classe comme parent des attributs de classe
- # et donne l'occasion aux attributs de se renommer à partir
- # du nom utilisé.
+ # et donne l'occasion aux attributs de se renommer à partir
+ # du nom utilisé.
for k, v in classdict.items():
- if not isinstance( v, BaseType ):
+ if not isinstance(v, BaseType):
continue
- v.reparent( new_cls, k )
- new_cls._subtypes.append( k )
+ v.reparent(new_cls, k)
+ new_cls._subtypes.append(k)
return new_cls
def dup_attr(cls, inst):
"""
# reinstantiate and reparent subtypes
for nam in cls._subtypes:
- obj = getattr( cls, nam )
- # permet de dupliquer completement l'instance
- cpy = cPickle.dumps(obj)
- newobj = cPickle.loads( cpy )
- newobj.reparent( inst, None )
- setattr( inst, nam, newobj )
+ obj = getattr(cls, nam)
+ # permet de dupliquer completement l'instance
+ cpy = cPickle.dumps(obj)
+ newobj = cPickle.loads(cpy)
+ newobj.reparent(inst, None)
+ setattr(inst, nam, newobj)
def __call__(cls, *args, **kwargs):
- """Instanciation d'un Type structuré.
- Lors de l'instanciation on effectue un travail similaire à la
- création de classe: Les attributs sont re-parentés à l'instance
- et réinstanciés pour obtenir une instanciation de toute la structure
+ """Instanciation d'un Type structuré.
+ Lors de l'instanciation on effectue un travail similaire à la
+ création de classe: Les attributs sont re-parentés à l'instance
+ et réinstanciés pour obtenir une instanciation de toute la structure
et de ses sous-structures.
Les attributs de classe deviennent des attributs d'instance.
"""
inst = cls.__new__(cls, *args, **kwargs)
# reinstantiate and reparent subtypes
- cls.dup_attr( inst )
+ cls.dup_attr(inst)
type(inst).__init__(inst, *args, **kwargs)
return inst
def mymethod(cls):
- pass
+ pass
class BaseType(object):
self._name = None
self._parent = None
- def reparent( self, parent, new_name ):
+ def reparent(self, parent, new_name):
self._parent = parent
self._name = new_name
for nam in self._subtypes:
- obj = getattr( self, nam )
- obj.reparent( self, nam )
+ obj = getattr(self, nam)
+ obj.reparent(self, nam)
def supprime(self, delete=False):
- """Permet de casser les boucles de références pour que les ASSD
- puissent être détruites.
- Si `delete` vaut True, on supprime l'objet lui-même et pas
- seulement les références remontantes."""
+ """Permet de casser les boucles de références pour que les ASSD
+ puissent être détruites.
+ Si `delete` vaut True, on supprime l'objet lui-même et pas
+ seulement les références remontantes."""
self._parent = None
self._name = None
for nam in self._subtypes:
obj = getattr(self, nam)
obj.supprime(delete)
- #XXX MC : avec ce code, j'ai l'impression qu'on supprime aussi
- # des attributs de classe, ce qui pose problème pour une
+ # XXX MC : avec ce code, j'ai l'impression qu'on supprime aussi
+ # des attributs de classe, ce qui pose problème pour une
# instanciation future...
- # Dans une version précédente, on utilisait l'attribut
- # sd_deleted pour ne faire qu'une fois, à voir.
- # Supprimer les références remontantes devrait suffir.
- #if delete:
- #while len(self._subtypes):
- #nam = self._subtypes.pop(0)
- #try:
- #delattr(self, nam)
- #except AttributeError:
- #pass
-
- def base( self ):
+ # Supprimer les références remontantes devrait suffir.
+ # if delete:
+ # while len(self._subtypes):
+ # nam = self._subtypes.pop(0)
+ # try:
+ # delattr(self, nam)
+ # except AttributeError:
+ # pass
+
+ def base(self):
if self._parent is None:
return self
return self._parent.base()
class Type(BaseType):
__metaclass__ = MetaType
-
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2012 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 library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
+# 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.
#
-# This library 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
-# Lesser 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.
#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-_root=None
-_cata=None
-debug=0
+# ======================================================================
+
+_root = None
+_cata = None
+debug = 0
from Noyau.N_info import message, SUPERV
-# Le "current step" est l'étape courante.
-# Une macro se déclare étape courante dans sa méthode Build avant de construire
-# ses étapes filles ou dans BuildExec avant de les exécuter.
-# Les étapes simples le font aussi : dans Execute et BuildExec.
-# (Build ne fait rien pour une étape)
+# Le "current step" est l'étape courante.
+# Une macro se déclare étape courante dans sa méthode Build avant de construire
+# ses étapes filles ou dans BuildExec avant de les exécuter.
+# Les étapes simples le font aussi : dans Execute et BuildExec.
+# (Build ne fait rien pour une étape)
+
def set_current_step(step):
- """
- Fonction qui permet de changer la valeur de l'étape courante
- """
- global _root
- if _root : raise Exception("Impossible d'affecter _root. Il devrait valoir None")
- _root=step
- #message.debug(SUPERV, "current_step = %s", step and step.nom, stack_id=-1)
+ """
+ Fonction qui permet de changer la valeur de l'étape courante
+ """
+ global _root
+ if _root:
+ raise Exception("Impossible d'affecter _root. Il devrait valoir None")
+ _root = step
+ # message.debug(SUPERV, "current_step = %s", step and step.nom,
+ # stack_id=-1)
+
def get_current_step():
- """
- Fonction qui permet d'obtenir la valeur de l'étape courante
- """
- return _root
+ """
+ Fonction qui permet d'obtenir la valeur de l'étape courante
+ """
+ return _root
+
def unset_current_step():
- """
- Fonction qui permet de remettre à None l'étape courante
- """
- global _root
- _root=None
+ """
+ Fonction qui permet de remettre à None l'étape courante
+ """
+ global _root
+ _root = None
+
def set_current_cata(cata):
- """
- Fonction qui permet de changer l'objet catalogue courant
- """
- global _cata
- if _cata : raise Exception("Impossible d'affecter _cata. Il devrait valoir None")
- _cata=cata
+ """
+ Fonction qui permet de changer l'objet catalogue courant
+ """
+ global _cata
+ if _cata:
+ raise Exception("Impossible d'affecter _cata. Il devrait valoir None")
+ _cata = cata
+
def get_current_cata():
- """
- Fonction qui retourne l'objet catalogue courant
- """
- return _cata
+ """
+ Fonction qui retourne l'objet catalogue courant
+ """
+ return _cata
-def unset_current_cata():
- """
- Fonction qui permet de remettre à None le catalogue courant
- """
- global _cata
- _cata=None
+def unset_current_cata():
+ """
+ Fonction qui permet de remettre à None le catalogue courant
+ """
+ global _cata
+ _cata = None
-# -*- coding: iso-8859-1 -*-
-
+# coding=utf-8
# Copyright (C) 2007-2013 EDF R&D
#
# This library is free software; you can redistribute it and/or
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
"""
- Ce module sert à nommer les concepts produits par les commandes.
+ Ce module sert à nommer les concepts produits par les commandes.
Le nom du concept est obtenu en appelant la fonction GetNomConceptResultat
du module avec le nom de la commande en argument.
Cette fonction parcourt le source dans lequel la commande se trouve, parse le
- fichier et retrouve le nom du concept qui se trouve à gauche du signe = précédant
+ fichier et retrouve le nom du concept qui se trouve à gauche du signe = précédant
le nom de la commande.
Cette fonction utilise la fonction cur_frame du module N_utils qui retourne la frame
- d'exécution Python située 2 niveaux au-dessus. C'est à partir de cette frame que
- l'on retrouve le fichier source et le numéro de ligne où se trouve l'appel à la commande.
+ d'exécution Python située 2 niveaux au-dessus. C'est à partir de cette frame que
+ l'on retrouve le fichier source et le numéro de ligne où se trouve l'appel à la commande.
"""
# Modules Python
-import re,string
+import re
+import string
import linecache
from functools import partial
# Modules EFICAS
import N_utils
+from strfunc import get_encoding
+
+regex1 = '=?\s*%s\s*\('
+# commentaire standard precede d'un nombre quelconque de blancs (pas
+# multiligne)
+pattern_comment = re.compile(r"^\s*#.*")
-regex1='=?\s*%s\s*\('
-#commentaire standard precede d'un nombre quelconque de blancs (pas multiligne)
-pattern_comment = re.compile(r"^\s*#.*")
def _GetNomConceptResultat(ope, level=2):
- """
- Cette fonction recherche dans la pile des appels, l'appel à la commande
- qui doit etre situé à 2 niveaux au-dessus (cur_frame(2)).
- On retrouve d'abord la frame d'exécution f. Puis le numéro de la ligne
- dans le source f.f_lineno et le nom du fichier source (f.f_code.co_filename).
- A partir de là, on récupère la ligne de source avec linecache.getline
- et on vérifie que cette ligne correspond véritablement à l'appel.
-
- En effet, lorsque les commandes tiennent sur plusieurs lignes, on retrouve
- la dernière ligne. Il faut donc remonter dans le source jusqu'à la première
- ligne.
-
- Enfin la fonction evalnom forme un nom acceptable lorsque le concept est un
- élément d'une liste, par exemple.
-
- """
- f=N_utils.cur_frame(level)
- lineno = f.f_lineno # XXX Too bad if -O is used
- #lineno = f_lineno(f) # Ne marche pas toujours
- co = f.f_code
- filename = co.co_filename
- name = co.co_name
- #pattern pour identifier le debut de la commande
- pattern_oper=re.compile(regex1 % ope)
-
- list=[]
- while lineno > 0:
- line = linecache.getline(filename, lineno)
- lineno=lineno-1
- if pattern_comment.match(line):continue
- list.append(line)
- if pattern_oper.search(line):
- l=pattern_oper.split(line)
- list.reverse()
- # On suppose que le concept resultat a bien ete
- # isole en tete de la ligne de source
- m=evalnom(string.strip(l[0]),f.f_locals)
- #print "NOMS ",m
- if m!=[] : return m[-1]
- else : return ''
- #print "appel inconnu"
- return ""
-
-def evalnom(text,d):
- """
- Retourne un nom pour le concept resultat identifie par text
- Pour obtenir ce nom il y a plusieurs possibilites :
- 1. text est un identificateur python c'est le nom du concept
- 2. text est un element d'une liste on construit le nom en
- evaluant la partie indice dans le contexte de l'appelant d
- """
- l=re.split('([\[\]]+)',text)
- if l[-1] == '' :l=l[:-1]
- lll=[]
- i=0
- while i<len(l):
- s=l[i]
- ll=re.split('[ ,]+',s)
- if ll[0] == '' :ll=ll[1:]
- if len(ll) == 1:
- id0=ll[0]
- else:
- lll=lll+ll[0:-1]
- id0=ll[-1]
- if i+1<len(l) and l[i+1] == '[': # le nom est suivi d un subscript
- sub=l[i+2]
- nom=id0+'_'+str(eval(sub,d))
- i=i+4
- else:
- nom=id0
- i=i+1
- lll.append(nom)
- return lll
+ """
+ Cette fonction recherche dans la pile des appels, l'appel à la commande
+ qui doit etre situé à 2 niveaux au-dessus (cur_frame(2)).
+ On retrouve d'abord la frame d'exécution f. Puis le numéro de la ligne
+ dans le source f.f_lineno et le nom du fichier source (f.f_code.co_filename).
+ A partir de là, on récupère la ligne de source avec linecache.getline
+ et on vérifie que cette ligne correspond véritablement à l'appel.
+
+ En effet, lorsque les commandes tiennent sur plusieurs lignes, on retrouve
+ la dernière ligne. Il faut donc remonter dans le source jusqu'à la première
+ ligne.
+
+ Enfin la fonction evalnom forme un nom acceptable lorsque le concept est un
+ élément d'une liste, par exemple.
+
+ """
+ f = N_utils.cur_frame(level)
+ lineno = f.f_lineno # XXX Too bad if -O is used
+ # lineno = f_lineno(f) # Ne marche pas toujours
+ co = f.f_code
+ filename = unicode(co.co_filename, get_encoding())
+ name = co.co_name
+ # pattern pour identifier le debut de la commande
+ pattern_oper = re.compile(regex1 % ope)
+
+ list = []
+ while lineno > 0:
+ line = linecache.getline(filename, lineno)
+ lineno = lineno - 1
+ if pattern_comment.match(line):
+ continue
+ list.append(line)
+ if pattern_oper.search(line):
+ l = pattern_oper.split(line)
+ list.reverse()
+ # On suppose que le concept resultat a bien ete
+ # isole en tete de la ligne de source
+ m = evalnom(string.strip(l[0]), f.f_locals)
+ # print "NOMS ",m
+ if m != []:
+ return m[-1]
+ else:
+ return ''
+ # print "appel inconnu"
+ return ""
+
+
+def evalnom(text, d):
+ """
+ Retourne un nom pour le concept resultat identifie par text
+ Pour obtenir ce nom il y a plusieurs possibilites :
+ 1. text est un identificateur python c'est le nom du concept
+ 2. text est un element d'une liste on construit le nom en
+ evaluant la partie indice dans le contexte de l'appelant d
+ """
+ l = re.split('([\[\]]+)', text)
+ if l[-1] == '':
+ l = l[:-1]
+ lll = []
+ i = 0
+ while i < len(l):
+ s = l[i]
+ ll = re.split('[ ,]+', s)
+ if ll[0] == '':
+ ll = ll[1:]
+ if len(ll) == 1:
+ id0 = ll[0]
+ else:
+ lll = lll + ll[0:-1]
+ id0 = ll[-1]
+ if i + 1 < len(l) and l[i + 1] == '[': # le nom est suivi d un subscript
+ sub = l[i + 2]
+ nom = id0 + '_' + str(eval(sub, d))
+ i = i + 4
+ else:
+ nom = id0
+ i = i + 1
+ lll.append(nom)
+ return lll
+
def f_lineno(f):
- """
- Calcule le numero de ligne courant
- Devrait marcher meme avec -O
- Semble ne pas marcher en présence de tuples longs
- """
- c=f.f_code
- if not hasattr(c, 'co_lnotab'):return f.f_lineno
- tab=c.co_lnotab
- line = c.co_firstlineno
- stopat = f.f_lasti
- addr = 0
- for i in range(0, len(tab), 2):
- addr = addr + ord(tab[i])
- if addr > stopat:
- break
- line = line + ord(tab[i+1])
- return line
+ """
+ Calcule le numero de ligne courant
+ Devrait marcher meme avec -O
+ Semble ne pas marcher en présence de tuples longs
+ """
+ c = f.f_code
+ if not hasattr(c, 'co_lnotab'):
+ return f.f_lineno
+ tab = c.co_lnotab
+ line = c.co_firstlineno
+ stopat = f.f_lasti
+ addr = 0
+ for i in range(0, len(tab), 2):
+ addr = addr + ord(tab[i])
+ if addr > stopat:
+ break
+ line = line + ord(tab[i + 1])
+ return line
class NamingSystem(N_utils.Singleton):
- """Cette classe définit un système de nommage dynamique des concepts."""
+
+ """Cette classe définit un système de nommage dynamique des concepts."""
_singleton_id = 'nommage.NamingSystem'
-
+
def __init__(self):
"""Initialisation"""
self.native = _GetNomConceptResultat
self.use_global_naming()
def use_naming_function(self, function):
- """Utilise une fonction particulière de nommage."""
+ """Utilise une fonction particulière de nommage."""
self.naming_func = function
def use_global_naming(self):
self.naming_func = partial(self.native, level=3)
def __call__(self, *args):
- """Appel à la fonction de nommage."""
+ """Appel à la fonction de nommage."""
return self.naming_func(*args)
GetNomConceptResultat = NamingSystem()
-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
# Copyright (C) 2007-2013 EDF R&D
#
# This library is free software; you can redistribute it and/or
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
+"""Module rassemblant des fonctions utilitaires de manipulations
+de chaines de caractères
"""
-Module rassemblant des fonctions utilitaires de manipulations
-de chaines de caractères
-"""
-# module identique à Execution/strfunc.py pour usage dans Eficas
+# module identique à Execution/strfunc.py pour usage dans Eficas
import locale
_encoding = None
+
+
def get_encoding():
"""Return local encoding
"""
pass
return unicode(string, 'utf-8', 'replace')
+
def from_unicode(ustring, encoding, errors='replace'):
"""Try to encode a unicode string using encoding."""
try:
pass
return ustring.encode(encoding, errors)
+
def convert(content, encoding=None, errors='replace'):
"""Convert content using encoding or default encoding if None."""
if type(content) not in (str, unicode):
content = to_unicode(content)
return from_unicode(content, encoding or get_encoding(), errors)
+
def ufmt(uformat, *args):
"""Helper function to format a string by converting all its arguments to unicode"""
if type(uformat) is not unicode:
