# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Ihm import I_ASSD
from Ihm import I_LASSD
from Ihm import I_FONCTION
from Noyau import N_ASSD
-#from Noyau import N_LASSD
from Noyau import N_GEOM
from Noyau import N_FONCTION
from Noyau import N_CO
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_REGLE
from Validation import V_AU_MOINS_UN
from Ihm import I_REGLE
class AU_MOINS_UN(V_AU_MOINS_UN.AU_MOINS_UN,I_REGLE.REGLE,N_REGLE.REGLE):
"""
La classe utilise l'initialiseur de REGLE. Il n'est pas
- nécessaire d'expliciter son initialiseur car
+ necessaire d'expliciter son initialiseur car
V_AU_MOINS_UN.AU_MOINS_UN n'en a pas
"""
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_REGLE
from Validation import V_AU_PLUS_UN
from Ihm import I_REGLE
class AU_PLUS_UN(V_AU_PLUS_UN.AU_PLUS_UN,I_REGLE.REGLE,N_REGLE.REGLE):
"""
La classe utilise l'initialiseur de REGLE. Il n'est pas
- nécessaire d'expliciter son initialiseur car
+ necessaire d'expliciter son initialiseur car
V_AU_PLUS_UN.AU_PLUS_UN n'en a pas
"""
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_REGLE
from Ihm import I_REGLE, I_AVANT
class AVANT(I_AVANT.I_AVANT,I_REGLE.REGLE,N_REGLE.REGLE):
"""
La classe utilise l'initialiseur de REGLE. Il n'est pas
- nécessaire d'expliciter son initialiseur car
+ necessaire d'expliciter son initialiseur car
I_AVANT.I_AVANT n'en a pas
"""
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_REGLE
from Validation import V_A_CLASSER
from Ihm import I_A_CLASSER
class A_CLASSER(V_A_CLASSER.A_CLASSER,N_REGLE.REGLE,I_A_CLASSER.A_CLASSER):
"""
La classe utilise l'initialiseur du module V_.
- Il faut absolument que V_A_CLASSER soit en premier dans l'héritage
+ Il faut absolument que V_A_CLASSER soit en premier dans l'heritage
"""
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_BLOC
from Ihm import I_ENTITE
-import A_MCBLOC
+from . import A_MCBLOC
class BLOC(N_BLOC.BLOC,I_ENTITE.ENTITE):
class_instance=A_MCBLOC.MCBLOC
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_REGLE
from Validation import V_ENSEMBLE
from Ihm import I_REGLE
class ENSEMBLE(I_REGLE.REGLE,V_ENSEMBLE.ENSEMBLE,N_REGLE.REGLE):
"""
La classe utilise l'initialiseur de REGLE. Il n'est pas
- nécessaire d'expliciter son initialiseur car
+ necessaire d'expliciter son initialiseur car
V_ENSEMBLE.ENSEMBLE n'en a pas
"""
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_ETAPE
from Validation import V_ETAPE
from Ihm import I_ETAPE
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Ihm import I_EVAL
class EVAL(I_EVAL.EVAL):
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_REGLE
from Validation import V_EXCLUS
from Ihm import I_EXCLUS
class EXCLUS(I_EXCLUS.EXCLUS,V_EXCLUS.EXCLUS,N_REGLE.REGLE):
"""
La classe utilise l'initialiseur de REGLE. Il n'est pas
- nécessaire d'expliciter son initialiseur car
+ necessaire d'expliciter son initialiseur car
V_EXCLUS.EXCLUS n'en a pas
"""
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_FACT
from Ihm import I_ENTITE
-import A_MCFACT
-import A_MCLIST
+from . import A_MCFACT
+from . import A_MCLIST
class FACT(N_FACT.FACT,I_ENTITE.ENTITE):
class_instance=A_MCFACT.MCFACT
# (defined in Salome EFICAS module) when Eficas is launched in Salome context.
# It handles the objects that can be selected from Salome object browser.
+from __future__ import absolute_import
from Ihm import I_FICHIER
class Fichier (I_FICHIER.Fichier):
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_FORM
from Ihm import I_ENTITE
-import A_FORM_ETAPE
+from . import A_FORM_ETAPE
class FORM(N_FORM.FORM,I_ENTITE.ENTITE):
class_instance=A_FORM_ETAPE.FORM_ETAPE
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_FORM_ETAPE
from Validation import V_MACRO_ETAPE
from Ihm import I_FORM_ETAPE
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_JDC
from Validation import V_JDC
from Extensions import jdc
from Ihm import I_JDC
class JDC(jdc.JDC,I_JDC.JDC,V_JDC.JDC,N_JDC.JDC):
- from A_ASSD import CO,assd
+ from .A_ASSD import CO,assd
def __init__(self,*pos,**args):
N_JDC.JDC.__init__(self,*pos,**args)
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import A_JDC
+from __future__ import absolute_import
+from . import A_JDC
from Noyau import N_JDC_CATA
from Ihm import I_JDC_CATA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_MACRO
from Ihm import I_ENTITE
-import A_MACRO_ETAPE
+from . import A_MACRO_ETAPE
class MACRO(N_MACRO.MACRO,I_ENTITE.ENTITE):
class_instance=A_MACRO_ETAPE.MACRO_ETAPE
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_MACRO_ETAPE
from Validation import V_MACRO_ETAPE
from Ihm import I_MACRO_ETAPE
-from A_ASSD import CO
+from .A_ASSD import CO
class MACRO_ETAPE(I_MACRO_ETAPE.MACRO_ETAPE,
V_MACRO_ETAPE.MACRO_ETAPE,
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_MCBLOC
from Validation import V_MCBLOC
from Ihm import I_MCBLOC
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_MCFACT
from Validation import V_MCFACT
from Ihm import I_MCFACT
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
# ======================================================================
+from __future__ import absolute_import
from Noyau import N_MCLIST
from Validation import V_MCLIST
from Ihm import I_MCLIST
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Extensions import mcnuplet
from Ihm import I_MCCOMPO
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_MCSIMP
from Validation import V_MCSIMP
from Ihm import I_MCSIMP
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_REGLE
from Validation import V_MEME_NOMBRE
from Ihm import I_REGLE
class MEME_NOMBRE(V_MEME_NOMBRE.MEME_NOMBRE,I_REGLE.REGLE,N_REGLE.REGLE):
"""
La classe utilise l'initialiseur de REGLE. Il n'est pas
- nécessaire d'expliciter son initialiseur car
+ necessaire d'expliciter son initialiseur car
V_MEME_NOMBRE.MEME_NOMBRE n'en a pas
"""
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Extensions import nuplet
-import A_MCLIST
-import A_MCNUPLET
+from . import A_MCLIST
+from . import A_MCNUPLET
class NUPL(nuplet.NUPL):
class_instance=A_MCNUPLET.MCNUPLET
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_OPER
from Ihm import I_ENTITE
-import A_ETAPE
+from . import A_ETAPE
class OPER(N_OPER.OPER,I_ENTITE.ENTITE):
class_instance=A_ETAPE.ETAPE
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_REGLE
from Validation import V_PRESENT_ABSENT
from Ihm import I_PRESENT_ABSENT
N_REGLE.REGLE):
"""
La classe utilise l'initialiseur de REGLE. Il n'est pas
- nécessaire d'expliciter son initialiseur car
+ necessaire d'expliciter son initialiseur car
V_PRESENT_ABSENT.PRESENT_ABSENT n'en a pas
"""
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_REGLE
from Validation import V_PRESENT_PRESENT
from Ihm import I_PRESENT_PRESENT
N_REGLE.REGLE):
"""
La classe utilise l'initialiseur de REGLE. Il n'est pas
- nécessaire d'expliciter son initialiseur car
+ necessaire d'expliciter son initialiseur car
V_PRESENT_PRESENT.PRESENT_PRESENT n'en a pas
"""
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_PROC
from Ihm import I_ENTITE
-import A_PROC_ETAPE
+from . import A_PROC_ETAPE
class PROC(N_PROC.PROC,I_ENTITE.ENTITE):
class_instance=A_PROC_ETAPE.PROC_ETAPE
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_PROC_ETAPE
from Validation import V_PROC_ETAPE
from Ihm import I_PROC_ETAPE
# This empty class is replaced by the class eficas.SalomeEntry
# (defined in Salome EFICAS module) when Eficas is launched in Salome context.
# It handles the objects that can be selected from Salome object browser.
+#from builtins import object
+#class SalomeEntry(object):
class SalomeEntry:
pass
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Ihm import I_REGLE
from Noyau import N_SENSIBILITE
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_SIMP
from Ihm import I_ENTITE
-import A_MCSIMP
+from . import A_MCSIMP
class SIMP(N_SIMP.SIMP,I_ENTITE.ENTITE):
class_instance=A_MCSIMP.MCSIMP
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_REGLE
from Validation import V_UN_PARMI
from Ihm import I_UN_PARMI
class UN_PARMI(I_UN_PARMI.UN_PARMI,V_UN_PARMI.UN_PARMI,N_REGLE.REGLE):
"""
La classe utilise l'initialiseur de REGLE. Il n'est pas
- nécessaire d'expliciter son initialiseur car
+ necessaire d'expliciter son initialiseur car
V_UN_PARMI.UN_PARMI n'en a pas
"""
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Ihm.I_VALIDATOR import *
# permet de se proteger de l'oubli de carte coding
# ce warning deviendra fatal en python 2.4
+from __future__ import absolute_import
import warnings
warnings.filterwarnings('error','Non-ASCII character.*pep-0263',DeprecationWarning)
-from A_JDC_CATA import JDC_CATA
-from A_OPER import OPER
-from A_PROC import PROC
-from A_MACRO import MACRO
-from A_FORM import FORM
-from A_BLOC import BLOC
-from A_FACT import FACT
-from A_SIMP import SIMP
-from A_EVAL import EVAL
-from A_NUPLET import NUPL
+from .A_JDC_CATA import JDC_CATA
+from .A_OPER import OPER
+from .A_PROC import PROC
+from .A_MACRO import MACRO
+from .A_FORM import FORM
+from .A_BLOC import BLOC
+from .A_FACT import FACT
+from .A_SIMP import SIMP
+from .A_EVAL import EVAL
+from .A_NUPLET import NUPL
-from A_JDC import JDC
-from A_ETAPE import ETAPE
-from A_PROC_ETAPE import PROC_ETAPE
-from A_MACRO_ETAPE import MACRO_ETAPE
-from A_FORM_ETAPE import FORM_ETAPE
-from A_MCFACT import MCFACT
-from A_MCLIST import MCList
-from A_MCBLOC import MCBLOC
-from A_MCSIMP import MCSIMP
+from .A_JDC import JDC
+from .A_ETAPE import ETAPE
+from .A_PROC_ETAPE import PROC_ETAPE
+from .A_MACRO_ETAPE import MACRO_ETAPE
+from .A_FORM_ETAPE import FORM_ETAPE
+from .A_MCFACT import MCFACT
+from .A_MCLIST import MCList
+from .A_MCBLOC import MCBLOC
+from .A_MCSIMP import MCSIMP
# Les regles
-from A_AU_MOINS_UN import AU_MOINS_UN
-from A_MEME_NOMBRE import MEME_NOMBRE
-from A_AU_PLUS_UN import AU_PLUS_UN
-from A_UN_PARMI import UN_PARMI
-from A_PRESENT_PRESENT import PRESENT_PRESENT
-from A_PRESENT_ABSENT import PRESENT_ABSENT
-from A_EXCLUS import EXCLUS
-from A_ENSEMBLE import ENSEMBLE
-from A_A_CLASSER import A_CLASSER
-from A_AVANT import AVANT
+from .A_AU_MOINS_UN import AU_MOINS_UN
+from .A_MEME_NOMBRE import MEME_NOMBRE
+from .A_AU_PLUS_UN import AU_PLUS_UN
+from .A_UN_PARMI import UN_PARMI
+from .A_PRESENT_PRESENT import PRESENT_PRESENT
+from .A_PRESENT_ABSENT import PRESENT_ABSENT
+from .A_EXCLUS import EXCLUS
+from .A_ENSEMBLE import ENSEMBLE
+from .A_A_CLASSER import A_CLASSER
+from .A_AVANT import AVANT
-from A_ASSD import ASSD,assd
-from A_ASSD import GEOM,geom
+from .A_ASSD import ASSD,assd
+from .A_ASSD import GEOM,geom
# Pour le moment on laisse fonction (ceinture et bretelles)
-from A_ASSD import FONCTION, fonction
-from A_ASSD import formule
-from A_ASSD import formule_c
-from A_ASSD import CO
+from .A_ASSD import FONCTION, fonction
+from .A_ASSD import formule
+from .A_ASSD import formule_c
+from .A_ASSD import CO
from Noyau.N__F import _F
from Noyau.N_OPS import OPS, EMPTY_OPS
from Noyau.N_ASSD import not_checked
-from A_VALIDATOR import OrVal,AndVal,OnlyStr
-from A_VALIDATOR import OrdList,NoRepeat,LongStr,Compulsory,Absent,Together
-from A_VALIDATOR import RangeVal, EnumVal, TypeVal, PairVal
-from A_VALIDATOR import CardVal, InstanceVal
-from A_VALIDATOR import VerifTypeTuple, VerifExiste
-from A_VALIDATOR import FileExtVal, FunctionVal
-from A_VALIDATOR import CreeMotClef
+from .A_VALIDATOR import OrVal,AndVal,OnlyStr
+from .A_VALIDATOR import OrdList,NoRepeat,LongStr,Compulsory,Absent,Together
+from .A_VALIDATOR import RangeVal, EnumVal, TypeVal, PairVal
+from .A_VALIDATOR import CardVal, InstanceVal
+from .A_VALIDATOR import VerifTypeTuple, VerifExiste
+from .A_VALIDATOR import FileExtVal, FunctionVal
+from .A_VALIDATOR import CreeMotClef
# On remplace la factory des validateurs initialement dans Noyau par celle
# de A_VALIDATOR
-import A_VALIDATOR
+from .A_VALIDATOR import validatorFactory
import Noyau.N_ENTITE
-Noyau.N_ENTITE.ENTITE.factories['validator']=A_VALIDATOR.validatorFactory
+Noyau.N_ENTITE.ENTITE.factories['validator']=validatorFactory
-from A_SENSIBILITE import CONCEPT_SENSIBLE, REUSE_SENSIBLE, DERIVABLE
+from .A_SENSIBILITE import CONCEPT_SENSIBLE, REUSE_SENSIBLE, DERIVABLE
from Extensions.niveau import NIVEAU
from Extensions.etape_niveau import ETAPE_NIVEAU
from Extensions.commande_comm import COMMANDE_COMM
from Extensions.mcnuplet import MCNUPLET
-from A_SALOME_ENTRY import SalomeEntry
+from .A_SALOME_ENTRY import SalomeEntry
#
"""
"""
-# import généraux
-import types,string,os,glob,imp,sys
-from repr import Repr
+# import generaux
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+ from builtins import object
+except :
+ pass
+import types,os,glob,imp,sys
+from six.moves.reprlib import Repr
from copy import copy,deepcopy
# import du chargeur de composants
-from comploader import make_objecttreeitem
+from .comploader import make_objecttreeitem
from Ihm import CONNECTOR
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
+from six.moves import range
myrepr = Repr()
myrepr.maxstring = 100
myrepr.maxother = 100
-class TreeItem:
+class TreeItem(object):
"""Abstract class representing tree items.
"""
# itemNode est une factory qui doit retourner un objet de la classe Node
- # ou dérivé de cette classe.
- # Le widget arbre utilisera cet objet comme noeud associé au tree item.
+ # ou derive de cette classe.
+ # Le widget arbre utilisera cet objet comme noeud associe au tree item.
# Par defaut, utilise la classe Node de base
# La signature de la factory est la suivante :
# itemNode(treeOrNode,item,command,rmenu)
- # ou treeOrNode est le noeud parent, item est l'item associé
- # command est une fonction python appelée sur sélection graphique
- # du noeud et rmenu est une fonction python appelée sur click droit sur le noeud
+ # ou treeOrNode est le noeud parent, item est l'item associe
+ # command est une fonction python appelee sur selection graphique
+ # du noeud et rmenu est une fonction python appelee sur click droit sur le noeud
itemNode=None
def __init__(self):
def OnDoubleClick(self):
"""Called on a double-click on the item."""
-class Delegate:
+class Delegate(object):
def __init__(self, delegate=None):
self.object = delegate
self.__cache = {}
return attr
def resetcache(self):
- for key in self.__cache.keys():
+ for key in list(self.__cache.keys()):
try:
delattr(self, key)
except AttributeError:
self.__cache.clear()
def cachereport(self):
- keys = self.__cache.keys()
+ keys = list(self.__cache.keys())
keys.sort()
#print keys
def __init__(self, appli, labeltext, object, setfunction=None):
self.labeltext = labeltext
self.appli = appli
- # L'objet délegué est stocké dans l'attribut object
- # L'objet associé à l'item est stocké dans l'attribut _object
- # Il peut etre obtenu par appel à la méthode getObject
- # Attention : le délégué peut etre différent de l'objet associé (MCLIST)
- # Dans le cas d'une MCListe de longueur 1, l'objet associé est la MCListe
- # et l'objet délégué est le MCFACT (object = _object.data[0])
+ # L'objet delegue est stocke dans l'attribut object
+ # L'objet associe a l'item est stocke dans l'attribut _object
+ # Il peut etre obtenu par appel a la methode getObject
+ # Attention : le delegue peut etre different de l'objet associe (MCLIST)
+ # Dans le cas d'une MCListe de longueur 1, l'objet associe est la MCListe
+ # et l'objet delegue est le MCFACT (object = _object.data[0])
Delegate.__init__(self,object)
# On cache l'objet initial (pour destruction eventuelle
- # ultérieure)
+ # ulterieure)
self._object = object
self.setfunction = setfunction
self.expandable = 1
return self._object
def connect(self,channel,callable,args):
- """ Connecte la fonction callable (avec arguments args) à l'item self sur le
+ """ Connecte la fonction callable (avec arguments args) a l'item self sur le
canal channel
"""
#print self,channel,callable,args
def copy(self):
"""
- Crée un item copie de self
+ Cree un item copie de self
"""
object = self._object.copy()
appli = copy(self.appli)
def GetLabelText(self):
""" Retourne 3 valeurs :
- - le texte à afficher dans le noeud représentant l'item
+ - le texte a afficher dans le noeud representant l'item
- la fonte dans laquelle afficher ce texte
- la couleur du texte
"""
- # None --> fonte et couleur par défaut
+ # None --> fonte et couleur par defaut
return self.labeltext,None,None
def get_nature(self) :
return self.object.nature
def get_regles(self):
- """ retourne les règles de l'objet pointé par self """
+ """ retourne les regles de l'objet pointe par self """
return self.object.get_regles()
def get_liste_mc_presents(self):
- """ Retourne la liste des mots-clés fils de l'objet pointé par self """
+ """ Retourne la liste des mots-cles fils de l'objet pointe par self """
return self.object.liste_mc_presents()
def get_val(self):
- """ Retourne le nom de la valeur de l'objet pointé par self dans le cas
- où celle-ci est un objet (ASSD) """
+ """ Retourne le nom de la valeur de l'objet pointe par self dans le cas
+ ou celle-ci est un objet (ASSD) """
return self.object.getval()
def get_definition(self):
"""
- Retourne l'objet definition de l'objet pointé par self
+ Retourne l'objet definition de l'objet pointe par self
"""
return self.object.definition
def get_liste_mc_ordonnee(self,liste,dico):
- """ retourne la liste ordonnée (suivant le catalogue) brute des mots-clés
- d'une entité composée dont le chemin complet est donné sous forme
+ """ retourne la liste ordonnee (suivant le catalogue) brute des mots-cles
+ d'une entite composee dont le chemin complet est donne sous forme
d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
- il faut encore réarranger cette liste (certains mots-clés déjà
- présents ne doivent plus être proposés, règles ...)"""
+ il faut encore rearranger cette liste (certains mots-cles deja
+ presents ne doivent plus etre proposes, regles ...)"""
return self.object.get_liste_mc_ordonnee(liste,dico)
def get_liste_mc_ordonnee_brute(self,liste,dico):
"""
- retourne la liste ordonnée (suivant le catalogue) BRUTE des mots-clés
- d'une entité composée dont le chemin complet est donné sous forme
+ retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles
+ d'une entite composee dont le chemin complet est donne sous forme
d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
"""
return self.object.get_liste_mc_ordonnee_brute(liste,dico)
def get_genealogie(self):
"""
Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC ou ETAPE)
- de l'objet pointé par self
+ de l'objet pointe par self
"""
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é
+ Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
+ le nouveau mot-cle
"""
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
- le nouveau mot-clé
+ Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
+ le nouveau mot-cle
"""
liste_noms_mc_ordonnee = self.get_liste_mc_ordonnee_brute(self.get_genealogie(),self.get_jdc().cata_ordonne_dico)
liste_noms_mc_presents = self.object.liste_mc_presents()
for nom in liste_noms_mc_ordonnee:
if nom in liste_noms_mc_presents or nom == nom_fils:
l.append(nom)
- # l contient les anciens mots-clés + le nouveau dans l'ordre
+ # l contient les anciens mots-cles + le nouveau dans l'ordre
return l.index(nom_fils)
def append_child(self,name,pos=None):
"""
- Permet d'ajouter un item fils à self
+ Permet d'ajouter un item fils a self
"""
if pos == 'first':
index = 0
elif pos == 'last':
index = len(self.liste_mc_presents())
- elif type(pos) == types.IntType :
- # la position est fixée
+ elif type(pos) == int :
+ # la position est fixee
index = pos
elif type(pos) == types.InstanceType:
# pos est un item. Il faut inserer name apres pos
def append_brother(self,name,pos='after'):
"""
- Permet d'ajouter un frère à self
- par défaut on l'ajoute après self
+ Permet d'ajouter un frere a self
+ par defaut on l'ajoute apres self
"""
index = self._object.parent.get_index(self.getObject())
if pos == 'before':
elif pos == 'after':
index = index +1
else:
- print (tr("%d n'est pas un index valide pour append_brother", pos))
+ print((tr("%d n'est pas un index valide pour append_brother", pos)))
return
return self.parent.addobject(name,index)
return self.object.get_nom_etape()
def get_copie_objet(self):
- """ Retourne une copie de l'objet pointé par self """
+ """ Retourne une copie de l'objet pointe par self """
return self.object.copy()
def get_position(self):
- """ Retourne la valeur de l'attribut position de l'objet pointé par self """
+ """ Retourne la valeur de l'attribut position de l'objet pointe par self """
definition = self.get_definition()
try:
return getattr(definition,'position')
return 'local'
def get_nom(self):
- """ Retourne le nom de l'objet pointé par self """
+ """ Retourne le nom de l'objet pointe par self """
return self.object.nom
def get_jdc(self):
- """ Retourne le jdc auquel appartient l'objet pointé par self """
+ """ Retourne le jdc auquel appartient l'objet pointe par self """
return self.object.jdc
def get_valeur(self):
- """ Retourne la valeur de l'objet pointé par self """
+ """ Retourne la valeur de l'objet pointe par self """
return self.object.valeur
def get_cr(self):
def get_objet_commentarise(self):
"""
- Cette méthode retourne un objet commentarisé
- représentatif de self.object
- --> à surcharger par les différents items
+ Cette methode retourne un objet commentarise
+ representatif de self.object
+ --> a surcharger par les differents items
"""
raise EficasException("MESSAGE AU DEVELOPPEUR : il faut \
surcharger la methode get_objet_commentarise() \
pour la classe %s", self.__class__.__name__)
def isvalid(self):
- """ Retourne 1 si l'objet pointé par self est valide, 0 sinon"""
+ """ Retourne 1 si l'objet pointe par self est valide, 0 sinon"""
return self.object.isvalid()
def iscopiable(self):
"""
Retourne 1 si l'objet est copiable, 0 sinon
- Par défaut retourne 0
+ Par defaut retourne 0
"""
return 0
def get_mc_presents(self):
- """ Retourne le dictionnaire des mots-clés présents de l'objet pointé par self """
+ """ Retourne le dictionnaire des mots-cles presents de l'objet pointe par self """
return self.object.dict_mc_presents()
def verif_condition_regles(self,l_mc_presents):
return self.object.verif_condition_regles(l_mc_presents)
def get_fr(self):
- """ Retourne le fr de l'objet pointé par self """
+ """ Retourne le fr de l'objet pointe par self """
try:
return self.object.get_fr()
except:
return ""
def get_docu(self):
- """ Retourne la clé de doc de l'objet pointé par self """
+ """ Retourne la cle de doc de l'objet pointe par self """
return self.object.get_docu()
def set_valeur(self,new_valeur):
- """ Remplace la valeur de l'objet pointé par self par new_valeur """
+ """ Remplace la valeur de l'objet pointe par self par new_valeur """
return self.object.set_valeur(new_valeur)
def GetText(self):
return sublist
def wait_fichier_init(self):
- """ Retourne 1 si l'object pointé par self attend un fichier d'initialisation
+ """ Retourne 1 si l'object pointe par self attend un fichier d'initialisation
(ex: macros POURSUITE et INCLUDE de Code_Aster), 0 SINON """
return self.object.definition.fichier_ini
def make_objecttreeitem(self,appli,labeltext, object, setfunction=None):
"""
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.
+ de type item associe a l'object passe en argument.
"""
return make_objecttreeitem(appli,labeltext,object,setfunction)
return len(self._object)
def keys(self):
- return range(len(self._object))
+ return list(range(len(self._object)))
def GetIconName(self):
if self._object.isvalid():
return self._object.ajout_possible()
def get_index(self,child):
- """ Retourne le numéro de child dans la liste des enfants de self """
+ """ Retourne le numero de child dans la liste des enfants de self """
return self._object.get_index(child.getObject())
def GetText(self):
def suppitem(self,item):
try :
self._object.remove(item.getObject())
- # la liste peut être retournée vide !
+ # la liste peut etre retournee vide !
message = "Mot-clef " + item.getObject().nom + " supprime"
self.appli.affiche_infos(message)
return 1
Ce module contient la classe 3Dpilote qui va creer les ordres
de pilotage de l idl PAL pour un element de structure
"""
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import object
+except :
+ pass
import generator
from Extensions.i18n import tr
-class TroisDPilote:
+class TroisDPilote(object):
def __init__(self,node,appli):
self.node=node
"""
"""
format="vers3DSalome"
- if generator.plugins.has_key(format):
+ if format in generator.plugins :
# Le generateur existe on l'utilise
g=generator.plugins[format]()
g.init_jdc(self.node.get_jdc())
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce package contient les fonctionnalités COMMUNES nécessaires
- aux deux éditeurs graphiques QT et TK
+ Ce package contient les fonctionnalites COMMUNES necessaires
+ aux deux editeurs graphiques QT et TK
"""
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from string import split,strip,lowercase,uppercase
-import re,string,cPickle,os
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+ from builtins import object
+except :
+ pass
+
+import re,six.moves.cPickle,os
from Extensions.i18n import tr
from Noyau.N_CR import CR
+from six.moves import range
+
#
__Id__="$Id: analyse_catalogue.py,v 1.9.8.1.2.1.2.6 2014-01-23 09:14:44 pnoyret Exp $"
__version__="$Name: $"
return a.group(1)
def cherche_args(text):
- text = strip(text)
+ text = text.strip()
longueur = len(text)
if text[0] != '(u':
return 'erreur !'
except :
return text[1:i],''
-class ENTITE:
+class ENTITE(object):
def cherche_enfants(self):
try :
- self.text = strip(self.text)
+ self.text = self.text.strip()
liste = re.split(u'=',self.text,1)
if len(liste)>1 :
arg1=liste[0]
reste=liste[1]
- reste = strip(reste)
+ reste = reste.strip()
if reste[0:4] in l_noms :
nom_mc = cherche_nom(arg1+'=')
arg_mc, self.text = cherche_args(reste[4:])
mc = SIMP_CATA(nom_mc,self)
self.children.append(mc)
else :
- print (tr("Erreur dans la creation du mot-cle : %s", nom_mc))
+ print (tr("Erreur dans la creation du mot-cle : %s", nom_mc) )
def construit_liste_dico(self):
l=[]
texte_cmd = texte_cmd + child.affiche(1)
return texte_cmd
-class SIMP_CATA :
+class SIMP_CATA(object) :
def __init__(self,nom,parent):
self.nom = nom
self.cr = CR()
text = text + child.affiche(ind+1)
return text
-class CATALOGUE_CATA:
+class CATALOGUE_CATA(object):
def __init__(self,parent,fichier):
self.parent = parent
self.fichier=fichier
self.texte_complet=f.read()
f.close()
except :
- print (tr("Impossible d'ouvrir le fichier : %s ", str(self.fichier)))
+ print((tr("Impossible d'ouvrir le fichier : %s ", str(self.fichier))))
self.cr.fatal(tr("Impossible d'ouvrir le fichier : %s ", str(self.fichier)))
def constr_list_txt_cmd(self,text):
self.liste_textes_commandes.append(liste[i]+')')
def analyse_commande_old(self,text):
- #if strip(text) == '' or strip(text) ==')': return
liste = re.split(u'OPER *\(u',text,1)
if len(liste) < 2 :
liste = re.split(u'PROC *\(u',text,1)
fin = liste[1]
nom_cmd = cherche_nom(debut)
if nom_cmd == 'erreur !':
- print (tr("Erreur dans la recherche du nom de la commande : "), debut)
+ print((tr("Erreur dans la recherche du nom de la commande : "), debut))
args_cmd,toto = cherche_args(u'(u'+fin)
if args_cmd == 'erreur !':
- print (tr("Erreur dans la recherche des args de la commande :") , debut)
+ print((tr("Erreur dans la recherche des args de la commande :") , debut))
cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
self.liste_commandes.append(cmd)
def analyse_commande(self,text):
- #if strip(text) == '' or strip(text) ==')': return
for nom_cmd in l_noms_commandes:
liste = re.split(nom_cmd+' *\(u',text,1)
if len(liste) == 2 : break
if len(liste) < 2 :
- print (tr("le texte a analyser n'est pas celui d'une commande connue : \
- %(v_1)s %(v_2)s", {'v_1': str(l_noms_commandes), 'v_2': text}))
+ print((tr("le texte a analyser n'est pas celui d'une commande connue : \
+ %(v_1)s %(v_2)s", {'v_1': str(l_noms_commandes), 'v_2': text})))
self.cr.fatal(tr("le texte a analyser n'est pas celui d'une commande connue : \
%(v_1)s %(v_2)s", {'v_1': str(l_noms_commandes), 'v_2': text}))
return
fin = liste[1]
nom_cmd = cherche_nom(debut)
if nom_cmd == 'erreur !':
- print ( tr("Erreur dans la recherche du nom de la commande : "), debut)
+ print(( tr("Erreur dans la recherche du nom de la commande : "), debut))
args_cmd,toto = cherche_args(u'(u'+fin)
if args_cmd == 'erreur !':
- print ( tr("Erreur dans la recherche des args de la commande : "), debut)
- print (tr(fin))
+ print(( tr("Erreur dans la recherche des args de la commande : "), debut))
+ print((tr(fin)))
cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
self.liste_commandes.append(cmd)
fic_cata_p = os.path.splitext(fic_cata)[0]+'_pickled.py'
cata_ordonne = analyse_catalogue(None,fic_cata)
f = open(fic_cata_p,'w+')
- p = cPickle.Pickler(f)
+ p = six.moves.cPickle.Pickler(f)
p.dump(cata_ordonne.entites)
f.close()
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from string import split,strip,lowercase,uppercase
-import re,string,os
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import object
+except :
+ pass
+import re,os
from Extensions.i18n import tr
#
#
-class Catalogue_initial:
+class Catalogue_initial(object):
def __init__(self,fichier):
self.liste_commandes=[]
self.lignes=[]
self.lignes=f.readlines()
f.close()
except :
- print tr("Impossible d'ouvrir le fichier : %s", str(self.fichier))
+ print(tr("Impossible d'ouvrir le fichier : %s", str(self.fichier)))
def constr_list_txt_cmd(self):
pattern = '^# Ordre Catalogue '
if __name__ == "__main__" :
- monCata="/local/noyret/Install_Eficas/EficasQT4/Openturns_StudyOpenTURNS_Cata_Study_V4.py"
+ monCata="/local/noyret/Install_Eficas/EficasQT4/Openturns_StudyOpenTURNS_Cata_Study_V4.py"
analyse_catalogue(monCata)
Ce module sert a retrouver l'ordre des mots cles d'un catalogue de
commandes
"""
+from __future__ import absolute_import
+from __future__ import print_function
if __name__ == "__main__" :
import sys
sys.path[:0]=[".."]
de entite
"""
l=[]
- for k,v in entite.entites.items():
+ for k,v in list(entite.entites.items()):
if isinstance(v,NUPL):
traite_entiteNUPL(v)
else:
for mocle in entite.ordre_mc:
print_entite(entite.entites[mocle],dec=dec+' ')
- for k,v in dico.items():
+ for k,v in list(dico.items()):
print_entite(v,dec='')
- print (dico.keys())
+ print (dico)
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-class STYLE:
+try :
+ from builtins import object
+except : pass
+
+class STYLE(object):
background='gray90'
foreground='black'
entry_background='white'
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import object
+except :
+ pass
import sys,os
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..'))
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'../InterfaceQT4'))
return reparsed.toprettyxml(indent=" ")
-class CatalogueXML:
+class CatalogueXML(object):
def __init__(self,cata,cataName):
self.fichier="/tmp/XML/"+cataName+".xml"
self.cata=cata
f.write(prettify(self.first))
f.close()
except :
- print ("Impossible d'ecrire le fichier : "+ str(self.fichier))
+ print(("Impossible d'ecrire le fichier : "+ str(self.fichier)))
def constr_list_txt_cmd(self):
mesCommandes=self.cata.JdC.commandes
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-class CatalogDescription:
+try :
+ from builtins import object
+except : pass
+
+class CatalogDescription(object):
def __init__(self, identifier, cata_file_path, file_format = "python",
default = False, code = None,ss_code=None, user_name = None,
- gettreeitem(object) -> type d'item : fonction qui retourne un type
d'item correspondant au type de l'objet noyau fourni.
- make_objecttreeitem(appli,labeltext, object, setfunction=None) -> item : fonction qui retourne un item
- correspondant à l'objet noyau fourni.
+ correspondant a l'objet noyau fourni.
"""
-# import généraux
+# import generaux
+from __future__ import absolute_import
import os,glob,types
-# Dictionnaire {object : item} permettant d'associer un item à un object
-# Ce dictionnaire est renseigné par la méthode charger_composants
+# Dictionnaire {object : item} permettant d'associer un item a un object
+# Ce dictionnaire est renseigne par la methode charger_composants
composants = {}
def charger_composants(Ihm="TK"):
"""
Cette fonction a pour but de charger tous les modules composants graphiques
- (fichiers compo*.py dans le même répertoire que ce module )
- et de remplir le dictionnaire composants utilisé par make_objecttreeitem
+ (fichiers compo*.py dans le meme repertoire que ce module )
+ et de remplir le dictionnaire composants utilise par make_objecttreeitem
"""
reper=os.path.dirname(__file__)
if Ihm == "TK" :
def gettreeitem(object):
"""
- Cette fonction retourne la classe item associée à l'objet object.
- Cette classe item dépend bien sûr de la nature de object, d'où
+ Cette fonction retourne la classe item associee a l'objet object.
+ Cette classe item depend bien sur de la nature de object, d'ou
l'interrogation du dictionnaire composants
"""
# Si la definition de l'objet a un attribut itemeditor, il indique
pass
# Puis une eventuelle classe heritee (aleatoire car sans ordre)
- for e in composants.keys():
+ for e in list(composants.keys()):
if e and isinstance(object,e):
itemtype= composants[e]
return itemtype
def make_objecttreeitem(appli,labeltext, object, setfunction=None):
"""
Cette fonction permet de construire et de retourner un objet
- de type item associé à l'object passé en argument.
+ de type item associe a l'object passe en argument.
"""
c = gettreeitem(object)
#print appli,labeltext, object, setfunction
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2013 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# 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 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
-#
-"""
- Module de chargement des composants et de mapping des objets du noyau
- Accas vers les items d'EFICAS
-
- - composants : dictionnaire de stockage des relations entre types
- d'objet du noyau et types d'item
- - charger_composants() : fonction de chargement des composants. Retourne
- le dictionnaire composants.
- - gettreeitem(object) -> type d'item : fonction qui retourne un type
- d'item correspondant au type de l'objet noyau fourni.
- - make_objecttreeitem(appli,labeltext, object, setfunction=None) -> item : fonction qui retourne un item
- correspondant à l'objet noyau fourni.
-"""
-# import généraux
-import os,glob,types
-
-# Dictionnaire {object : item} permettant d'associer un item à un object
-# Ce dictionnaire est renseigné par la méthode charger_composants
-composants = {}
-
-def charger_composants(Ihm="TK"):
- """
- Cette fonction a pour but de charger tous les modules composants graphiques
- (fichiers compo*.py dans le même répertoire que ce module )
- et de remplir le dictionnaire composants utilisé par make_objecttreeitem
- """
- reper=os.path.dirname(__file__)
- if Ihm == "TK" :
- repertoire=reper+"/../InterfaceTK"
- package="InterfaceTK"
- else :
- repertoire=reper+"/../InterfaceQT4"
- package="InterfaceQT4"
- listfich=glob.glob(os.path.join(repertoire, "compo*.py"))
- for fichier in listfich:
- m= os.path.basename(fichier)[:-3]
- module=__import__(package,globals(),locals(),[m])
- module = getattr(module, m)
- composants[module.objet]=module.treeitem
- return composants
-
-def gettreeitem(object):
- """
- Cette fonction retourne la classe item associée à l'objet object.
- 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
-
- # 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 e and isinstance(object,e):
- itemtype= composants[e]
- return itemtype
-
- # Si on n'a rien trouve dans les composants on utilise l'objet par defaut
- itemtype=composants[None]
- return itemtype
-
-def make_objecttreeitem(appli,labeltext, object, setfunction=None):
- """
- Cette fonction 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)
-
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module réalise toutes les mises à jour du chemin pour
+ Ce module realise toutes les mises a jour du chemin pour
les imports de modules Python
"""
+from __future__ import absolute_import
import sys
import os
INSTALLDIR=prefs_Code.INSTALLDIR
# Ce chemin permet d'importer les modules Noyau et Validation
-# représentant le code utilisé (si fourni)
+# representant le code utilise (si fourni)
# Ensuite on utilise les packages de l'intallation
if hasattr(prefs_Code,'CODE_PATH'):
if prefs_Code.CODE_PATH:
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
+try :
+ from builtins import range
+ from builtins import object
+except : pass
import os
import re
+from six.moves import range
sous_menus={
# "OPENTURNS_STUDY" : {0:{"Essai":"Std.comm"}},
# "OPENTURNS_WRAPPER" : {0:{"Essai":"wrapper_exemple.comm"}},
}
-class listePatrons :
+class listePatrons(object) :
def __init__(self,code = "ASTER"):
repIni=os.path.dirname(os.path.abspath(__file__))
self.rep_patrons=repIni+"/Patrons/"+code
self.sous_menu={}
- if code in sous_menus.keys() :
+ if code in sous_menus :
self.sous_menu=sous_menus[code]
self.code=code
self.liste={}
self.traite_liste()
def traite_liste(self):
- if not (self.code in sous_menus.keys()) : return
+ if not (self.code in sous_menus) : return
if not (os.path.exists(self.rep_patrons)) : return
for file in os.listdir(self.rep_patrons):
for i in range(len(self.sous_menu)):
- clef=self.sous_menu[i].keys()[0]
+ clef=list(self.sous_menu[i].keys())[0]
chaine=self.sous_menu[i][clef]
if re.search(chaine,file) :
- if clef in self.liste.keys():
+ if clef in self.liste:
self.liste[clef].append(file)
else :
self.liste[clef]=[file]
La session utilisera le catalogue V7.3 en mode debug.
"""
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except :
+ pass
try:
import optparse
from optparse import OptionValueError
from Tools.optparse import OptionValueError
import os,traceback
-import ConfigParser
+import six.moves.configparser
import re
from Extensions.i18n import tr
parser : objet analyseur de la ligne de commande
fich : nom du fichier .ini en cours d'analyse
config : objet de la classe ConfigParser permettant de parser le fichier fich
- jdc : nom de la section du fichier fich à analyser
+ jdc : nom de la section du fichier fich a analyser
"""
d_study={}
if not hasattr(parser.values,"studies"):
parser.values.studies=[]
parser.values.comm=[]
- config = ConfigParser.ConfigParser()
+ config = six.moves.configparser.ConfigParser()
config.read([fich])
if not config.has_option(u"jdc","jdc"):
raise OptionValueError(tr(" jdc %s manque option jdc dans section jdc", str(fich)))
def print_pours(d_pours,dec=''):
# Les fichiers includes d'abord
- for k,v in d_pours.items():
+ for k,v in list(d_pours.items()):
if k in (u"pours","comm"):continue
- print ( tr("%(v_1)s include %(v_2)s : %(v_3)s", {'v_1': str(dec), 'v_2': str(k), 'v_3': str(v)}))
+ print(( tr("%(v_1)s include %(v_2)s : %(v_3)s", {'v_1': str(dec), 'v_2': str(k), 'v_3': str(v)})))
- if d_pours.has_key(u"pours"):
+ if "pours" in d_pours:
# Description de la poursuite
- print (tr("%(v_1)s fichier poursuite: %(v_2)s", {'v_1': dec, 'v_2': d_pours["pours"]["comm"]}))
+ print((tr("%(v_1)s fichier poursuite: %(v_2)s", {'v_1': dec, 'v_2': d_pours["pours"]["comm"]})))
print_pours(d_pours["pours"],dec=dec+"++")
def print_d_env():
if d_env.studies is None:return
for study in d_env.studies:
- print (tr("nom etude : %s", study["comm"]))
+ print((tr("nom etude : %s", study["comm"])))
print_pours(study,dec="++")
def create_parser():
options.comm.append(file)
options.studies.append({"comm":file})
elif len(args) == 1 and options.locale:
- print (tr("Localisation specifiee pour l'application."))
+ print((tr("Localisation specifiee pour l'application.")))
else:
parser.error(tr("Nombre incorrect d'arguments"))
def get_dunit(d_unit,appli):
d={}
- if d_unit.has_key(u"pours"):
+ if 'pours' in d_unit:
# on a une poursuite
comm=d_unit["pours"]["comm"]
g=get_dunit(d_unit["pours"],appli)
text=appli.get_source(comm)
d[None]=comm,text,g
- for k,v in d_unit.items():
+ for k,v in list(d_unit.items()):
if k in (u"pours","comm"): continue
text=appli.get_source(v)
d[k]=v,text,d
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
import os
import prefs
name='prefs_'+prefs.code
prefsCode=__import__(name)
-import basestyle
from basestyle import STYLE,style
inistylefile=os.path.join(prefsCode.repIni,"style.py")
if os.path.isfile(inistylefile):
- execfile(inistylefile)
-
-userstylefile=os.path.expanduser("~/Eficas_install/style.py")
-if os.path.isfile(userstylefile):
- execfile(userstylefile)
+ exec(compile(open(inistylefile).read(), inistylefile, 'exec'))
import fontes
for attr in dir(style):
Ce module sert a construire les structures de donnees porteuses
des informations liees aux groupes de commandes
"""
+from __future__ import absolute_import
import types
class UIINFO:
if groupes == None:
# L'entite n'a pas de groupe associe. On lui associe le groupe "DEFAUT"
self.groupes=("DEFAUT",)
- if type(self.groupes) != types.TupleType:
+ if type(self.groupes) != tuple:
self.groupes=(self.groupes,)
def traite_commande(commande,niveau):
#else:
# On ajoute la commande dans tous les groupes specifies
for grp in UI.groupes:
- if not niveau.dict_groupes.has_key(grp): niveau.dict_groupes[grp]=[]
+ if not grp in niveau.dict_groupes: niveau.dict_groupes[grp]=[]
niveau.dict_groupes[grp].append(commande.nom)
def traite_niveau(niveau):
traite_commande(oper,niveau)
# A la fin les cles du dictionnaire dict_groupes donnent la liste des groupes
# sans doublon
- niveau.liste_groupes=niveau.dict_groupes.keys()
+ niveau.liste_groupes=list(niveau.dict_groupes.keys())
# On ordonne les listes alphabetiquement
niveau.liste_groupes.sort()
for v in niveau.dict_groupes.values():v.sort()
traite_commande(commande,cata.JdC)
# A la fin les cles du dictionnaire dict_groupes donnent la liste des groupes
# sans doublon
- cata.JdC.liste_groupes=cata.JdC.dict_groupes.keys()
+ cata.JdC.liste_groupes=list(cata.JdC.dict_groupes.keys())
# On ordonne les listes alphabetiquement
cata.JdC.liste_groupes.sort()
for v in cata.JdC.dict_groupes.values():v.sort()
-
retourne 1 si OK 0 sinon
"""
try :
- import string
- #file=string.split(file,"/")[-1]
if dir != None:
os.chdir(dir)
f=open(file,'w')
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import os,traceback,string
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except : pass
+import os,traceback
import re
from Noyau.N_CR import CR
class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
- Cette classe sert à définir les objets de type Commande commentarisée
+ Cette classe sert a definir les objets de type Commande commentarisee
"""
nature = "COMMANDE_COMMENTARISEE"
idracine='_comm'
def report(self):
"""
- Génère l'objet rapport (classe CR)
+ Genere l'objet rapport (classe CR)
"""
self.cr=CR()
- if not self.isvalid(): self.cr.warn(tr("Objet commande commentarisé invalide"))
+ if not self.isvalid(): self.cr.warn(tr("Objet commande commentarise invalide"))
return self.cr
def copy(self):
def get_valeur(self) :
"""
- Retourne la valeur de self, cad le texte de la commande commentarisée
+ Retourne la valeur de self, cad le texte de la commande commentarisee
"""
return self.valeur
def register(self):
"""
- Enregistre la commande commenatrisée dans la liste des étapes de son parent lorsque celui-ci
+ Enregistre la commande commenatrisee dans la liste des etapes de son parent lorsque celui-ci
est un JDC
"""
self.parent.register(self)
def ident(self):
"""
- Retourne le nom interne associé à self
+ Retourne le nom interne associe a self
Ce nom n'est jamais vu par l'utilisateur dans EFICAS
"""
return self.nom
def isrepetable(self):
"""
- Indique si self est répétable ou non : retourne toujours 1
+ Indique si self est repetable ou non : retourne toujours 1
"""
return 1
def get_attribut(self,nom_attribut) :
"""
- Retourne l'attribut de nom nom_attribut de self (ou hérité)
+ Retourne l'attribut de nom nom_attribut de self (ou herite)
"""
if hasattr(self,nom_attribut) :
return getattr(self,nom_attribut)
def supprime(self):
"""
- Méthode qui supprime toutes les boucles de références afin que l'objet puisse
- être correctement détruit par le garbage collector
+ Methode qui supprime toutes les boucles de references afin que l'objet puisse
+ etre correctement detruit par le garbage collector
"""
self.parent = None
self.etape = None
def uncomment(self):
"""
- Cette méthode a pour but de décommentariser l'objet courant,
+ Cette methode a pour but de decommentariser l'objet courant,
cad de retourner un tuple contenant :
- - l'objet CMD associé
- - le nom de la sdprod éventuellement produite (sinon None)
+ - l'objet CMD associe
+ - le nom de la sdprod eventuellement produite (sinon None)
"""
- # on récupère le contexte avant la commande commentarisée
+ # on recupere le contexte avant la commande commentarisee
context_ini = self.jdc.get_contexte_avant(self)
try:
- # on essaie de créer un objet JDC...
+ # on essaie de creer un objet JDC...
CONTEXT.unset_current_step()
if re.search('Fin Commentaire',self.valeur) :
self.valeur=self.valeur.replace('Fin Commentaire','')
#self.jdc.set_context()
raise AsException(tr("Erreur"),e.__str__())
if len(J.cr.crfatal)>0 :
- # des erreurs fatales ont été rencontrées
+ # des erreurs fatales ont ete rencontrees
#self.jdc.set_context()
print ('erreurs fatales !!!')
- raise AsException(tr("Erreurs fatales"),string.join(J.cr.crfatal))
+ raise AsException(tr("Erreurs fatales"),''.join(J.cr.crfatal))
if not J.etapes :
- # des erreurs ont été rencontrées
+ # des erreurs ont ete rencontrees
raise AsException(tr("Impossible reconstruire commande\n"),str(J.cr))
#self.jdc.set_context()
def isactif(self):
"""
- Booléenne qui retourne 1 si self est valide, 0 sinon
+ Booleenne qui retourne 1 si self est valide, 0 sinon
"""
return self.actif
def verif_condition_bloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
- (en fonction du catalogue donc de la définition) de self et
+ (en fonction du catalogue donc de la definition) de self et
retourne deux listes :
- - la première contient les noms des blocs à rajouter
- - la seconde contient les noms des blocs à supprimer
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
"""
return [],[]
def verif_condition_regles(self,liste_presents):
"""
- Retourne la liste des mots-clés à rajouter pour satisfaire les règles
- en fonction de la liste des mots-clés présents
+ Retourne la liste des mots-cles a rajouter pour satisfaire les regles
+ en fonction de la liste des mots-cles presents
"""
return []
def verif_existence_sd(self):
"""
- Vérifie que les structures de données utilisées dans self existent bien dans le contexte
- avant étape, sinon enlève la référence à ces concepts
- --> sans objet pour les commandes commentarisées
+ Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
+ avant etape, sinon enleve la reference a ces concepts
+ --> sans objet pour les commandes commentarisees
"""
pass
def control_sdprods(self,d):
- """sans objet pour les commandes commentarisées"""
+ """sans objet pour les commandes commentarisees"""
pass
def close(self):
#
"""
Ce module contient la classe COMMENTAIRE qui sert dans EFICAS
- pour gérer les commentaires dans un JDC
+ pour gerer les commentaires dans un JDC
"""
+from __future__ import absolute_import
from Noyau.N_CR import CR
from Noyau import N_OBJECT
from Ihm import I_OBJECT
class COMMENTAIRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
- Cette classe permet de créer des objets de type COMMENTAIRE
+ Cette classe permet de creer des objets de type COMMENTAIRE
"""
nature = 'COMMENTAIRE'
idracine = '_comm'
self.jdc = self.parent = CONTEXT.get_current_step()
else:
self.jdc = self.parent = parent
- # La classe COMMENTAIRE n'a pas de définition. On utilise self
- # pour complétude
+ # La classe COMMENTAIRE n'a pas de definition. On utilise self
+ # pour completude
self.definition=self
self.nom=''
self.niveau = self.parent.niveau
def register(self):
"""
- Enregistre le commentaire dans la liste des étapes de son parent
+ Enregistre le commentaire dans la liste des etapes de son parent
lorsque celui-ci est un JDC
"""
if self.parent.nature == 'JDC':
# le commentaire est entre deux commandes:
- # il faut l'enregistrer dans la liste des étapes
+ # il faut l'enregistrer dans la liste des etapes
self.parent.register(self)
def copy(self):
return 0
def isrepetable(self):
- """ Indique si self est répétable ou non : retourne toujours 1 """
+ """ Indique si self est repetable ou non : retourne toujours 1 """
return 1
def active(self):
def isactif(self):
"""
- Booléenne qui retourne 1 si self est valide, 0 sinon
+ Booleenne qui retourne 1 si self est valide, 0 sinon
"""
return self.actif
def supprime(self):
"""
- Méthode qui supprime toutes les boucles de références afin que
- l'objet puisse être correctement détruit par le garbage collector
+ Methode qui supprime toutes les boucles de references afin que
+ l'objet puisse etre correctement detruit par le garbage collector
"""
self.parent=None
self.jdc=None
pass
def report(self):
- """ Génère l'objet rapport (classe CR) """
+ """ Genere l'objet rapport (classe CR) """
self.cr=CR()
if not self.isvalid(): self.cr.warn(tr("Objet commentaire non valorise"))
return self.cr
def ident(self):
- """ Retourne le nom interne associé à self
+ """ Retourne le nom interne associe a self
Ce nom n'est jamais vu par l'utilisateur dans EFICAS
"""
return self.nom
def verif_condition_bloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
- (en fonction du catalogue donc de la définition) de self et
+ (en fonction du catalogue donc de la definition) de self et
retourne deux listes :
- - la première contient les noms des blocs à rajouter
- - la seconde contient les noms des blocs à supprimer
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
"""
return [],[]
def verif_condition_regles(self,liste_presents):
"""
- Retourne la liste des mots-clés à rajouter pour satisfaire les règles
- en fonction de la liste des mots-clés présents
+ Retourne la liste des mots-cles a rajouter pour satisfaire les regles
+ en fonction de la liste des mots-cles presents
"""
return []
the ``i18n`` module.
"""
+from __future__ import absolute_import
class EficasException(Exception):
"""
``EficasException`` class, which embeds the translation mechanism.
Ce module contient la classe ETAPE_NIVEAU qui sert a
concretiser les niveaux au sein d'un JDC
"""
+from __future__ import absolute_import
import traceback
from Noyau import N_OBJECT
def register(self,etape):
"""
- Enregistre la commande étape :
+ Enregistre la commande etape :
- si editmode = 0 : on est en mode relecture d'un fichier de commandes
- auquel cas on ajoute etape à la fin de la liste self.etapes
- - si editmode = 1 : on est en mode ajout d'étape depuis eficas auquel cas
- cette méthode ne fait rien, c'est addentité qui enregistre etape
- à la bonne place dans self.etapes
+ auquel cas on ajoute etape a la fin de la liste self.etapes
+ - si editmode = 1 : on est en mode ajout d'etape depuis eficas auquel cas
+ cette methode ne fait rien, c'est addentite qui enregistre etape
+ a la bonne place dans self.etapes
"""
if self.editmode : return
self.etapes.append(etape)
if self.definition.actif == 1 :
return 1
else :
- # self.actif est une condition à évaluer dans un certain contexte ...
+ # self.actif est une condition a evaluer dans un certain contexte ...
d = self.cree_dict_valeurs()
try:
t=eval(self.definition.actif,d)
def cree_dict_valeurs(self):
"""
- Retourne le dictionnaire des frères aînés de self composé des couples :
- {nom_frère isvalid()}
+ Retourne le dictionnaire des freres aines de self compose des couples :
+ {nom_frere isvalid()}
"""
d={}
for niveau in self.parent.etapes_niveaux:
return d
def isvalid(self):
- """ Méthode booléenne qui retourne 0 si le niveau est invalide, 1 sinon """
+ """ Methode booleenne qui retourne 0 si le niveau est invalide, 1 sinon """
if self.etapes_niveaux == []:
if len(self.etapes) == 0:
return self.definition.valide_vide
def suppentite(self,etape) :
""" Classe ETAPE_NIVEAU
- Supprime une étape
+ Supprime une etape
"""
self.jdc.suppentite(etape)
It is usable from both Qt and non-Qt environments.
``PyQt4`` is currently supported.
"""
-
-from translation import tr, tr_qt
-from localisation import localise
+from __future__ import absolute_import
+from .translation import tr, tr_qt
+from .localisation import localise
__all__ = ['tr', 'tr_qt', 'localise']
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import string,re,sys,types
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
+import re,sys,types
from Noyau.N_CR import CR
from Extensions.i18n import tr
-#def group(*choices): return '(' + string.join(choices, '|') + ')'
+#def group(*choices): return '(' + ''.join(choices, '|') + ')'
#def any(*choices): return apply(group, choices) + '*'
#def maybe(*choices): return apply(group, choices) + '?'
def __str__(self):
return str(self.args)
-class Interpreteur_Formule:
+class Interpreteur_Formule(object):
"""
Cette classe sert a construire un interpreteur de formules Aster
"""
"""
texte = self.t_formule[3]
if not texte : return
- if type(texte) != types.ListType:
+ if type(texte) != list:
texte = [texte,]
for text_arg in texte:
- text_arg = string.replace(text_arg,'\n','')
+ text_arg = text_arg.replace('\n','')
# Enleve les espaces
- text_arg = string.replace(text_arg,' ','')
+ text_arg = text_arg.replace(' ','')
try:
self.l_operateurs.append(self.split_operateurs(text_arg))
except InterpreteurException as e:
# dans ce cas il n'y a pas d'arguments puisque pas de fonction ...
if args :
args = args[1:-1] # on enleve les parentheses ouvrante et fermante
- l_args = string.split(args,',')
+ l_args = args.split(',')
for arg in l_args:
- typ,nom = string.split(arg,':')
- nom = string.strip(nom)
+ typ,nom = arg.split(':')
+ nom = nom.strip()
self.l_constantes.append(nom)
# on considere que les fonctions unaires de base sont toutes a un seul argument :
l_f = []
for new_fonc in self.new_fonctions_unaires:
self.d_fonctions_unaires[new_fonc[0]] = self.get_nb_args(new_fonc)
#self.d_fonctions_unaires.update(self.new_fonctions_unaires)
- self.l_fonctions_unaires = self.d_fonctions_unaires.keys()
+ self.l_fonctions_unaires = list(self.d_fonctions_unaires.keys())
def ordonne_listes(self):
"""
N'analyse pas l'interieur des operateurs (ne fait qu'une passe)
"""
l_operateurs = []
- texte = string.strip(texte)
+ texte = texte.strip()
# on recherche un nombre en debut de texte
try:
oper,reste = self.cherche_nombre(texte)
# d'un operateur binaire
l_operateurs.append(oper)
if reste :
- texte = string.strip(reste)
+ texte = reste.strip()
oper,reste = self.cherche_operateur_binaire(texte)
if not oper :
# on a un reste et pas d'operateur binaire --> erreur
Retourne ce nombre et le reste ou None et le texte initial
Peut lever une InterpreteurException dans le cas ou le nombre n'est pas valide
"""
- texte = string.strip(texte)
+ texte = texte.strip()
m = pat_number_complet.match(texte)
if m:
# on a trouve un nombre avec exposant
nb = nb+l_groups[2]
nombre = sgn+nb
# il faut verifier si ce nombre n'est pas suivi d'un exposant incomplet ...
- reste = string.strip(l_groups[3])
+ reste = l_groups[3].strip()
if reste == '':
return nombre,l_groups[3]
if reste[0] in ('e','E','d','D') :
Retourne None,texte si aucune constante trouvee
"""
txt = None
- texte = string.strip(texte)
+ texte = texte.strip()
for cte in self.l_constantes:
- index = string.find(texte,cte)
+ index = texte.find(cte)
#if index == 0 : print 'on a trouve %s dans %s en %d' %(cte,texte,index)
if index == 0 :
txt = cte
- zz,reste = string.split(texte,cte,1)
+ zz,reste = texte.split(cte,1)
break
if txt :
return txt,reste
Retourne None,texte si aucune constante trouvee
"""
txt = None
- texte = string.strip(texte)
+ texte = texte.strip()
m = pat_constante.match(texte)
if m :
# on a trouve un identificateur en debut de texte
l_groups = m.groups()
sgn = l_groups[0]
- identificateur = string.strip(l_groups[1])
+ identificateur = l_groups[1].strip()
reste = l_groups[2]
# il faut verifier qu'il ne s'agit pas d'un appel a une fonction
if reste :
Cherche dans texte un operateur unaire
"""
txt = None
- texte = string.strip(texte)
+ texte = texte.strip()
for oper in self.l_fonctions_unaires:
- index = string.find(texte,oper)
+ index = texte.find(oper)
if index == 0 :
txt = oper
- zz,reste = string.split(texte,oper,1)
+ zz,reste = texte.split(oper,1)
break
if txt :
#print 'on a trouve :',txt
Cherche dans texte un operateur unaire
"""
txt = None
- texte = string.strip(texte)
+ texte = texte.strip()
m = pat_constante.match(texte)
if m :
# on a trouve un identificateur en debut de texte
# il faut encore verifier que l'on a bien a faire a un appel de fonction ...
l_groups = m.groups()
sgn = l_groups[0]
- identificateur = string.strip(l_groups[1])
+ identificateur = l_groups[1].strip()
reste = l_groups[2]
try:
args,reste = self.cherche_args(reste)
Cherche dans texte un operateur unaire
"""
txt = None
- texte = string.strip(texte)
+ texte = texte.strip()
for oper in self.l_fonctions_binaires:
- index = string.find(texte,oper)
+ index = texte.find(oper)
#if index != -1 : print 'on a trouve %s dans %s en %d' %(oper,texte,index)
if index == 0 :
txt = oper
- zz,reste = string.split(texte,oper,1)
+ zz,reste = texte.split(oper,1)
break
if txt :
return txt,reste
"""
Cherche en debut de texte une expression entre parentheses
"""
- args,reste = self.cherche_args(string.strip(texte))
+ args,reste = self.cherche_args(texte.strip())
if not args :
return None,texte
else:
"""
args = args[1:-1] # on enleve les parentheses ouvrante et fermante
if nb_args == 1 : return args
- l_args = string.split(args,',')
+ l_args = args.split(',')
if len(l_args) != nb_args:
raise InterpreteurException ("La fonction %s requiert %d arguments : %d fourni(s)" %(nom_fonction,nb_args,len(l_args)))
else:
- unknown
et son nom
"""
- texte = string.strip(texte)
+ texte = texte.strip()
if '(' not in texte:
return 'constante',texte
if texte[-1] != ')':
return 'unknown',''
- nom_oper,args = string.split(texte,'(',1)
+ nom_oper,args = texte.split('(',1)
return 'fonction',nom_oper
def get_nb_args(self,formule):
Retourne le nombre d'arguments dans la definition de formule (sous forme de tuple)
"""
args = formule[2][1:-1] # on enleve les parentheses ouvrante et fermante
- l_args = string.split(args,',')
+ l_args = args.split(',')
return len(l_args)
if __name__ == '__main__':
constantes = constantes,
fonctions = fonctions_unaires)
txt = i.str()
- print ('\nformule %s = %s' %(str(formule),txt))
+ print(('\nformule %s = %s' %(str(formule),txt)))
#if i.isvalid() :
# print "\n\tPas d'erreur !"
#else:
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient la classe mixin qui porte les méthodes
+ Ce module contient la classe mixin qui porte les methodes
pour traiter les niveaux au sein d'un JDC
"""
-import etape_niveau
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
-class JDC:
+from . import etape_niveau
+
+class JDC(object):
def __init__(self):
self.dict_niveaux={}
self.build_niveaux()
que le jeu de commandes inclus est valide et compatible
avec le contexte avant et apres l'insertion
"""
+from __future__ import absolute_import
import string
from Accas import JDC,ASSD,AsException,JDC_CATA
from Ihm import CONNECTOR
non utilise
Ajoute un prefixe s'il est specifie (INCLUDE_MATERIAU)
Si le nom est deja utilise, leve une exception
- Met le concept créé dans le contexe global g_context
+ Met le concept cree dans le contexe global g_context
"""
#print "NommerSdprod",sd,sdnom,restrict
if self.prefix_include:
#
# nom commencant par __ : il s'agit de concepts qui seront detruits
# nom commencant par _ : il s'agit de concepts intermediaires qui seront gardes
- # ATTENTION : il faut traiter différemment les concepts dont le nom
- # commence par _ mais qui sont des concepts nommés automatiquement par
- # une éventuelle sous macro.
+ # ATTENTION : il faut traiter differemment les concepts dont le nom
+ # commence par _ mais qui sont des concepts nommes automatiquement par
+ # une eventuelle sous macro.
if sdnom[1] in string.digits:
# Ce concept provient probablement d'une sous macro (cas improbable)
#pas de renommage
pass
elif sdnom[1] == '_':
- #cas d'un concept à ne pas conserver apres execution de la commande
+ #cas d'un concept a ne pas conserver apres execution de la commande
sdnom=sd.id[2:]
pass
else:
return j_context
def force_contexte(self,contexte):
- for nom_sd,sd in contexte.items():
+ for nom_sd,sd in list(contexte.items()):
if not isinstance(sd,ASSD):continue
autre_sd= self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
etape=self.etape_include)
def verif_contexte(self,context):
"""
- Cette methode verifie si le contexte passé en argument (context)
- peut etre inséré dans le jdc pere de l'include.
+ Cette methode verifie si le contexte passe en argument (context)
+ peut etre insere dans le jdc pere de l'include.
Elle verifie que les concepts contenus dans ce contexte n'entrent
pas en conflit avec les concepts produits dans le jdc pere
apres l'include.
- Si le contexte ne peut pas etre inséré, la méthode leve une
- exception sinon elle retourne le contexte inchangé
+ Si le contexte ne peut pas etre insere, la methode leve une
+ exception sinon elle retourne le contexte inchange
"""
#print "verif_contexte"
- for nom_sd,sd in context.items():
+ for nom_sd,sd in list(context.items()):
if not isinstance(sd,ASSD):continue
autre_sd= self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
etape=self.etape_include)
# Il existe un concept produit par une etape apres self
# => impossible d'inserer
raise Exception("Impossible d'inclure le fichier. Un concept de nom " +
- "%s existe déjà dans le jeu de commandes." % nom_sd)
+ "%s existe deja dans le jeu de commandes." % nom_sd)
return context
def init_modif(self):
"""
- Met l'état de l'étape à : modifié
+ Met l'etat de l'etape a : modifie
Propage la modification au parent
- Attention : init_modif doit etre appelé avant de réaliser une modification
- La validité devra etre recalculée apres cette modification
- mais par un appel à fin_modif pour préserver l'état modified
+ Attention : init_modif doit etre appele avant de realiser une modification
+ La validite devra etre recalculee apres cette modification
+ mais par un appel a fin_modif pour preserver l'etat modified
de tous les objets entre temps
"""
#print "jdc_include.init_modif",self,self.etape_include
def fin_modif(self):
"""
- Méthode appelée une fois qu'une modification a été faite afin de
- déclencher d'éventuels traitements post-modification
+ Methode appelee une fois qu'une modification a ete faite afin de
+ declencher d'eventuels traitements post-modification
ex : INCLUDE et POURSUITE
"""
#print "jdc_include.fin_modif",self,self.etape_include
def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
"""
- Cette méthode retourne la SD de nom nom_sd qui est éventuellement
- définie apres etape
+ Cette methode retourne la SD de nom nom_sd qui est eventuellement
+ definie apres etape
Si avec vaut 'non' exclut etape de la recherche
"""
if self.etape_include:
def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
"""
On veut savoir ce que devient le concept sd de nom nom_sd apres etape.
- Il peut etre detruit, remplacé ou conservé
- Cette méthode retourne la SD sd de nom nom_sd qui est éventuellement
- définie apres etape en tenant compte des concepts detruits
+ Il peut etre detruit, remplace ou conserve
+ Cette methode retourne la SD sd de nom nom_sd qui est eventuellement
+ definie apres etape en tenant compte des concepts detruits
Si avec vaut 'non' exclut etape de la recherche
"""
#print "jdc_include.get_sd_apres_etape_avec_detruire",nom_sd,sd,id(sd)
def delete_concept(self,sd):
"""
- Fonction : Mettre a jour les etapes du JDC suite à la disparition du
+ Fonction : Mettre a jour les etapes du JDC suite a la disparition du
concept sd
Seuls les mots cles simples MCSIMP font un traitement autre
que de transmettre aux fils
def delete_concept_after_etape(self,etape,sd):
"""
- Fonction : Mettre à jour les étapes du JDC qui sont après etape suite à
+ Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite a
la disparition du concept sd
"""
# Nettoyage des etapes de l'include
def replace_concept_after_etape(self,etape,old_sd,sd):
"""
- Fonction : Mettre à jour les étapes du JDC qui sont après etape suite au
+ Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite au
remplacement du concept old_sd par sd
"""
# Nettoyage des etapes de l'include
def control_context_apres(self,etape):
"""
- Cette méthode verifie que les etapes apres l'etape etape
+ Cette methode verifie que les etapes apres l'etape etape
ont bien des concepts produits acceptables (pas de conflit de
nom principalement)
- Si des concepts produits ne sont pas acceptables ils sont supprimés.
+ Si des concepts produits ne sont pas acceptables ils sont supprimes.
Effectue les verifications sur les etapes du jdc mais aussi sur les
jdc parents s'ils existent.
"""
"""
+from __future__ import absolute_import
+from __future__ import print_function
import os
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtCore import QTranslator
-else :
- from PyQt4.QtCore import QTranslator
-qt_translator = QTranslator()
+from PyQt5.QtCore import QTranslator
+
+code_translator = QTranslator()
eficas_translator = QTranslator()
-def localise(application, locale=None,file=None ):
+def localise(application, locale=None,file=None,translatorFichier=None ):
"""
"""
- if monEnvQT5 :
- from PyQt5.QtCore import QLibraryInfo
- from PyQt5.QtCore import QLocale
- from PyQt5.QtWidgets import QApplication
- monPath=os.path.join(os.path.dirname(__file__),'..','UiQT5')
- else :
- from PyQt4.QtCore import QLibraryInfo
- from PyQt4.QtCore import QLocale
- from PyQt4.QtGui import QApplication
- monPath=os.path.join(os.path.dirname(__file__),'..','UiQT4')
+ from PyQt5.QtCore import QLibraryInfo
+ from PyQt5.QtCore import QLocale
+ from PyQt5.QtWidgets import QApplication
+ monPath=os.path.join(os.path.dirname(__file__),'..','UiQT5')
sys_locale = QLocale.system().name()
if locale is None: locale="fr"
- global eficas_translator
if locale=="ang" : locale="en"
if file != None :
print ('chargement de ', file,monPath)
print (eficas_translator.load(file,monPath))
print (QApplication.installTranslator(eficas_translator))
- return
-
- if eficas_translator.load("eficas_" + locale, monPath):
- QApplication.installTranslator(eficas_translator)
+ elif eficas_translator.load("eficas_" + locale, monPath):
+ QApplication.installTranslator(eficas_translator)
else:
- print ("Unable to load Eficas translator!")
+ print ("Unable to load Eficas translator!")
+
+ global code_translator
+ if translatorFichier != None :
+ if (code_translator.load(translatorFichier)):
+ print (translatorFichier, ' loaded')
+ elif (code_translator.load(translatorFichier+'_'+locale)):
+ print(translatorFichier+'_'+locale+ ' loaded')
+ else :
+ print ("Unable to load Code translator!" + translatorFichier)
+ print (QApplication.installTranslator(code_translator))
if __name__ == "__main__":
"""
"""
# Modules Python
-import string
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
# Modules Eficas
from Noyau import N_MCCOMPO
self.niveau = self.parent.niveau
self.etape = self.parent.etape
else:
- # Le mot cle a été créé sans parent
+ # Le mot cle a ete cree sans parent
self.jdc = None
self.niveau = None
self.etape = None
def build_mc(self):
"""
Construit la liste des sous-entites de MCNUPLET
- à partir de la liste des arguments (valeur)
+ a partir de la liste des arguments (valeur)
"""
args = self.valeur
if args ==None : args =()
mc_liste=[]
- # on crée les sous entites du NUPLET a partir des valeurs initiales
+ # on cree les sous entites du NUPLET a partir des valeurs initiales
k=0
for v in self.definition.entites:
if k < len(args):
val=args[k]
else:
val=None
- objet=v(val=val,nom=`k`,parent=self)
+ objet=v(val=val,nom=repr(k),parent=self)
if hasattr(objet.definition,'position'):
if objet.definition.position == 'global' :
self.append_mc_global(objet)
if len(self.mc_liste) != len(self.definition.entites):
valid=0
if cr == 'oui' :
- self.cr.fatal(string.join(("Nuplet : ",self.nom,tr("Longueur incorrecte"))))
+ self.cr.fatal(''.join(("Nuplet : ",self.nom,tr("Longueur incorrecte"))))
self.valid = valid
self.state = 'unchanged'
if old_valid:
def __getitem__(self,key):
"""
- Retourne le key ème élément du nuplet
+ Retourne le key eme element du nuplet
"""
# Un nuplet est toujours une liste de mots cles simples
# On retourne donc la valeur
def __str__(self):
"""
- Retourne une représentation du nuplet sous forme de chaine
- de caractères
+ Retourne une representation du nuplet sous forme de chaine
+ de caracteres
"""
s='('
for e in self.mc_liste:
def __repr__(self):
"""
- Retourne une représentation du nuplet sous forme de chaine
- de caractères
+ Retourne une representation du nuplet sous forme de chaine
+ de caracteres
"""
s='('
for e in self.mc_liste:
def get_regles(self):
"""
- Retourne la liste des règles attachées au nuplet
+ Retourne la liste des regles attachees au nuplet
"""
return []
def verif_condition_bloc(self):
"""
- Vérifie s'il y a des blocs sous le nuplet et retourne
+ Verifie s'il y a des blocs sous le nuplet et retourne
les blocs en question
"""
# Il n y a pas de BLOCs sous un NUPLET
def isrepetable(self):
"""
- Indique si le NUPLET peut etre répété.
+ Indique si le NUPLET peut etre repete.
Retourne 1 si c'est le cas.
Retourne 0 dans le cas contraire.
- L'information est donnée par le catalogue, cad la définition de self
+ L'information est donnee par le catalogue, cad la definition de self
"""
if self.definition.min != self.definition.max :
return 1
def get_valeur(self):
"""
- Cette méthode doit retourner la valeur de l'objet. Elle est utilisée par
- cree_dict_valeurs pour construire un dictionnaire contenant les mots clés
- d'une étape.
+ Cette methode doit retourner la valeur de l'objet. Elle est utilisee par
+ cree_dict_valeurs pour construire un dictionnaire contenant les mots cles
+ d'une etape.
Dans le cas d'un nuplet, on retournera comme valeur une liste des valeurs
- des mots clé simples contenus.
+ des mots cle simples contenus.
"""
l=[]
for v in self.mc_liste:
def get_val(self):
"""
- Une autre méthode qui retourne une "autre" valeur du mot clé facteur.
- Elle est utilisée par la méthode get_mocle
+ Une autre methode qui retourne une "autre" valeur du mot cle facteur.
+ Elle est utilisee par la methode get_mocle
"""
l=[]
for v in self.mc_liste:
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient la classe NIVEAU qui sert à définir
+ Ce module contient la classe NIVEAU qui sert a definir
des groupes de commandes dans le catalogue
"""
-class NIVEAU:
+try :
+ from builtins import object
+except : pass
+
+class NIVEAU(object):
def __init__(self,nom='',label='',niveaux=(),valide_vide=1,actif=1):
self.nom = nom
self.label = label
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient la classe de définition pour les nuplets NUPL
+ Ce module contient la classe de definition pour les nuplets NUPL
"""
# Modules Python
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
import types
# Modules Eficas
from Noyau import N_ENTITE,N_MCLIST,N_CR
from Ihm import I_ENTITE
from Extensions.i18n import tr
-import mcnuplet
+from . import mcnuplet
class NUPL(N_ENTITE.ENTITE,I_ENTITE.ENTITE):
"""
self.defaut=defaut
self.min=min
self.max=max
+ if self.max =='**' : self.max=float('inf')
+ if self.min =='**' : self.min=float('-inf')
self.entites=elements
self.regles=()
# on force le statut des sous entites a obligatoire
def verif_cata(self):
"""
- Cette methode sert à valider les attributs de l'objet de définition
+ Cette methode sert a valider les attributs de l'objet de definition
de la classe NUPL
"""
- if type(self.min) != types.IntType :
- if self.min != '**':
+ if type(self.min) != int :
+ if self.min != '**' and self.min != float('-inf'):
self.cr.fatal(tr("L'attribut 'min' doit etre un entier : ")+str(self.min))
- if type(self.max) != types.IntType :
- if self.max != '**' :
+ if type(self.max) != int :
+ if self.max != '**' and self.max != float('inf'):
self.cr.fatal(tr("L'attribut 'max' doit etre un entier : ")+str(self.max))
if self.min > self.max :
self.cr.fatal(tr("Nombres d'occurrence min et max invalides :") +str(self.min)+","+str(self.max))
- if type(self.fr) != types.StringType :
+ if type(self.fr) != bytes :
self.cr.fatal(tr("L'attribut 'fr' doit etre une chaine de caracteres"))
if self.statut not in ['o','f','c','d']:
self.cr.fatal(tr("L'attribut 'statut' doit valoir 'o','f','c' ou 'd'"))
- if type(self.docu) != types.StringType :
+ if type(self.docu) != bytes :
self.cr.fatal(tr("L'attribut 'docu' doit etre une chaine de caracteres"))
self.verif_cata_regles()
Construit la structure de donnees pour un NUPLET a partir de sa definition (self)
de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
"""
- if (type(val) == types.TupleType or type(val) == types.ListType) and type(val[0]) == types.TupleType:
+ if (type(val) == tuple or type(val) == list) and type(val[0]) == tuple:
# On est en presence d une liste de nuplets
l=self.list_instance()
l.init(nom=nom,parent=parent)
def report(self):
"""
- Méthode qui crée le rapport de vérification du catalogue du nuplet
+ Methode qui cree le rapport de verification du catalogue du nuplet
"""
self.cr = self.CR()
self.verif_cata()
def affecter_parente(self):
"""
Cette methode a pour fonction de donner un nom et un pere aux
- sous entités qui n'ont aucun moyen pour atteindre leur parent
+ sous entites qui n'ont aucun moyen pour atteindre leur parent
directement
Il s'agit principalement des mots cles
"""
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
from __future__ import division
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except : pass
import math
import types
+import six
try:
import Numeric
except:
- import numpy
- Numeric = numpy
+ try:
+ import numpy
+ Numeric = numpy
+ except ImportError:
+ Numeric = None
+
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(1), type(1.5), type(1j),type("hh")) :
return Constant(value)
elif isinstance(value, Formula):
return value
return Constant(value)
else:
# return Constant(value)
- raise TypeError, ("Can't make formula from", value)
+ raise TypeError("Can't make formula from", value)
#class Formula(object):
-class Formula:
+class Formula(object):
def __len__(self):
val=self.eval()
if val is None:return 0
return 1
def __complex__(self): return complex(self.eval())
def __int__(self): return int(self.eval())
- def __long__(self): return long(self.eval())
+ def __long__(self): return int(self.eval())
def __float__(self): return float(self.eval())
def __pos__(self): return self # positive
def __neg__(self): return Unop('-', self)
def __hash__(self):return id(self)
def _div(a,b):
- if isinstance(a,(int,long)) and isinstance(b,(int,long)):
+ if isinstance(a,six.integer_types) and isinstance(b,six.integer_types):
if a%b:
return a/b
else:
def Eval(f):
if isinstance(f,Formula):
f=f.eval()
- elif type(f) in (types.ListType, ):
+ elif type(f) in (list, ):
f=[Eval(i) for i in f]
- elif type(f) in (types.TupleType,):
+ elif type(f) in (tuple,):
f=tuple([Eval(i) for i in f])
return f
def cos(f): return Unop('ncos', f)
def sin(f): return Unop('nsin', f)
def array(f,*tup,**args):
- """array de Numeric met en défaut la mécanique des parametres
- on la supprime dans ce cas. Il faut que la valeur du parametre soit bien définie
+ """array de Numeric met en defaut la mecanique des parametres
+ on la supprime dans ce cas. Il faut que la valeur du parametre soit bien definie
"""
originalMath=OriginalMath()
original_narray=originalMath.original_narray
def __init__(self):
if hasattr(self,'pi') :return
import math
- self.toSurcharge()
+ try :
+ self.toSurcharge()
+ except : pass
def toSurcharge(self):
self.numeric_ncos=Numeric.cos
import numpy
Numeric = numpy
- Numeric.cos=originalMath.numeric_ncos
- Numeric.sin=originalMath.numeric_nsin
- Numeric.array=originalMath.numeric_narray
+ try :
+ Numeric.cos=originalMath.numeric_ncos
+ Numeric.sin=originalMath.numeric_nsin
+ Numeric.array=originalMath.numeric_narray
+ except : pass
math.sin=originalMath.sin
math.cos=originalMath.cos
math.sqrt=originalMath.sqrt
"""
# import de modules Python
-import string,types
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+ from builtins import object
+except : pass
+
+import types
from math import *
import traceback
from Noyau.N_CR import CR
from Noyau import N_OBJECT
from Ihm import I_OBJECT
-from param2 import *
+from .param2 import *
from Ihm import CONNECTOR
from Extensions.i18n import tr
+from six.moves import range
class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
"""
# La classe PARAMETRE n'a pas de definition : on utilise self pour
# completude
self.definition=self
- # parent ne peut être qu'un objet de type JDC
+ # parent ne peut etre qu'un objet de type JDC
self.jdc = self.parent = CONTEXT.get_current_step()
self.niveau=self.parent.niveau
self.actif=1
def interprete_valeur(self,val):
"""
- Essaie d'interpreter val (chaîne de caracteres)comme :
+ Essaie d'interpreter val (chaine de caracteres)comme :
- un entier
- un reel
- - une chaîne de caracteres
+ - une chaine de caracteres
- une liste d'items d'un type qui precede
Retourne la valeur interpretee
"""
#if not val : return None
valeur = None
- if type(val) == types.ListType:
+ if type(val) == list:
# Un premier traitement a ete fait lors de la saisie
# permet de tester les parametres qui sont des listes
l_new_val = []
return None
return l_new_val
- if type(val) == types.StringType:
+ if type(val) == bytes:
# 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)
#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:
+ if type(valeur) == tuple:
l_new_val = []
typ = None
for v in valeur :
# la liste est heterogene --> on refuse d'interpreter
# self comme une liste
# on retourne la string initiale
- print ('liste heterogene ',val)
+ print(('liste heterogene ',val))
return val
l_new_val.append(v)
return tuple(l_new_val)
def supprime(self):
"""
Methode qui supprime toutes les boucles de references afin que
- l'objet puisse être correctement detruit par le garbage collector
+ l'objet puisse etre correctement detruit par le garbage collector
"""
self.parent = None
self.jdc = None
"""
Donne un echo de self sous la forme nom = valeur
"""
- if type(self.valeur) == types.StringType:
+ if type(self.valeur) == bytes:
if self.valeur.find('\n') == -1:
# pas de retour chariot, on utilise repr
return self.nom+' = '+ repr(self.valeur)
else:
return self.nom+' = '+ repr(self.valeur)
else:
- if type(self.valeur) == types.ListType :
+ if type(self.valeur) == list :
aRetourner=self.nom+' = ['
for l in self.valeur :
aRetourner=aRetourner+str(l) +","
def __adapt__(self,validator):
return validator.adapt(self.eval())
-class COMBI_PARAMETRE :
+class COMBI_PARAMETRE(object) :
def __init__(self,chainevaleur,valeur):
self.chainevaleur=chainevaleur
self.valeur=valeur
if self.valeur and self.chainevaleur:
return 1
-class ITEM_PARAMETRE :
+class ITEM_PARAMETRE(object) :
def __init__(self,param_pere,item=None):
self.param_pere = param_pere
self.item = item
de l'utilisateur par le parseur de fichiers Python
"""
# import de modules Python
-import string,types,re
+from __future__ import absolute_import
+from __future__ import print_function
+import types,re
import traceback
# import modules Eficas
-import interpreteur_formule
+from . import interpreteur_formule
from Noyau.N_CR import CR
from Extensions.i18n import tr
-import parametre
+from . import parametre
pattern_eval = re.compile(r'^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)')
def interprete_valeur(self,val):
"""
- Essaie d'interpreter val (chaîne de caracteres ou None) comme :
+ Essaie d'interpreter val (chaine de caracteres ou None) comme :
une instance de Accas.EVAL
Retourne la valeur interpretee
"""
if not val : return None
d={}
- val = string.strip(val)
+ val = val.strip()
if val[-1] == ';' : val = val[0:-1]
d['EVAL'] = self.Accas_EVAL
try:
return valeur
except:
traceback.print_exc()
- print ("Le texte %s n'est pas celui d'un parametre evalue" %val)
+ print(("Le texte %s n'est pas celui d'un parametre evalue" %val))
return None
def set_valeur(self,new_valeur):
if cr == 'oui' :
if not verificateur.cr.estvide():
self.cr.fatal(verificateur.cr.get_mess_fatal())
- return verificateur.isvalid(),string.join(verificateur.cr.crfatal)
+ return verificateur.isvalid(),''.join(verificateur.cr.crfatal)
else:
# pas d'expression EVAL --> self non valide
if cr == 'oui' :
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient le chargeur dynamique de plugins (emprunté à HappyDoc)
+ Ce module contient le chargeur dynamique de plugins (emprunte a HappyDoc)
"""
+from __future__ import absolute_import
import glob,os,sys,traceback
-import UserDict
+try:
+ from UserDict import UserDict
+except ImportError:
+ from collections import UserDict
-class PluginLoader(UserDict.UserDict):
+
+class PluginLoader(UserDict):
def __init__(self,module):
- UserDict.UserDict.__init__(self)
+ UserDict.__init__(self)
self.plugin_dir=module.__path__[0]
self.plugin_set_name=module.__name__
_module_list = glob.glob( os.path.join( self.plugin_dir,
-from determine import monEnvQT5
-if monEnvQT5 :
- from translationQT5 import tr
- from translationQT5 import tr_qt
-else :
- from translationQT4 import tr
- from translationQT4 import tr_qt
+from __future__ import absolute_import
+from .translationQT5 import tr
+from .translationQT5 import tr_qt
``PyQt4`` is currently supported.
"""
-from eficas_exception import EficasException
+from __future__ import absolute_import
+try :
+ from builtins import zip
+ from builtins import map
+ from builtins import range
+except :
+ pass
+from .eficas_exception import EficasException
#from Extensions.eficas_exception import EficasException
import re
+from six.moves import map
+import six
+from six.moves import range
+from six.moves import zip
regex=re.compile(r"% *[0-9]+")
"""
from PyQt5.QtCore import QRegExp
reg = QRegExp("\%\.[1-9]{1,2}f")
- for p, j in zip(params, range(len(params))):
+ for p, j in zip(params, list(range(len(params)))):
try:
i += 1 + qstring[i + 1:].indexOf("%")
except NameError:
if i == reg.indexIn(qstring):
precision = reg.cap(0).split('.')[1].split('f')[0]
qstring = qstring[:i + 2 + len(precision)].\
- replace("%." + precision, "%" + unicode(1 + j)) + \
+ replace("%." + precision, "%" + six.text_type(1 + j)) + \
qstring[i + 3 + len(precision):]
qstring=regex.sub("{}",qstring)
#qstring = qstring.format(QString.number(float(params[j]), 'f', int(precision)))
qstring = qstring.format(float(params[j]))
else:
- qstring = qstring[:i + 1].replace("%", "%" + unicode(1 + j)) + \
+ qstring = qstring[:i + 1].replace("%", "%" + six.text_type(1 + j)) + \
qstring[i + 2:]
- if isinstance(params[j], unicode):
+ if isinstance(params[j], six.text_type):
qstring=regex.sub("{}",qstring)
qstring = qstring.format(params[j])
elif isinstance(params[j], float):
and a dictionary specifying the parameters of the string.
"""
from PyQt5.QtCore import QRegExp
- for p, j in zip(params, range(len(params))):
+ for p, j in zip(params, list(range(len(params)))):
p_reg = QRegExp("\%\("+ p + "\)\.[1-9]{1,2}f")
p_index = p_reg.indexIn(qstring)
if p_index != -1:
# arg(QString.number(float(params[p]), \
# 'f', \
# int(precision)))
- qstring = qstring.replace("%(" + p + ")." + precision + "f","%" + unicode(1 + j))
+ qstring = qstring.replace("%(" + p + ")." + precision + "f","%" + six.text_type(1 + j))
qstring=regex.sub("{}",qstring)
qstring = qstring.format(float(params[p]))
else:
qstring.remove(QRegExp("\\)[sdf]{1}"))
- qstring = qstring.replace("%(" + p, "%" + unicode(1 + j))
- if isinstance(params[p], unicode):
+ qstring = qstring.replace("%(" + p, "%" + six.text_type(1 + j))
+ if isinstance(params[p], six.text_type):
qstring=regex.sub("{}",qstring)
qstring = qstring.format(params[p])
elif isinstance(params[p], float):
qstring.append("%1")
try:
qstring=regex.sub("{}",qstring)
- qstring = qstring.format(unicode(params))
+ qstring = qstring.format(six.text_type(params))
except AttributeError:
qstring=regex.sub("{}",qstring)
qstring = qstring.format(params)
else:
qstring = qstring[:i + 1].replace("%", "%1") + \
qstring[i + 2:]
- if isinstance(params, (unicode, str)):
+ if isinstance(params, (six.text_type, str)):
qstring = qstring.format(_preprocess_atom(params))
elif isinstance(params, float):
#qstring = qstring.format(QString.number(params, 'f', \
# XXX to add further functionality, e.g. list processing
# when ``%`` not at the end.
if qstring.count("%") == 1 and \
- unicode(qstring).strip()[:-1].endswith("%"):
+ six.text_type(qstring).strip()[:-1].endswith("%"):
qstring = qstring[:qstring.indexOf("%") + 1].append("1")
qstring=regex.sub("{}",qstring)
- qstring = qstring.format(u' '.join(map(unicode, params)))
+ qstring = qstring.format(u' '.join(map(six.text_type, params)))
elif qstring.count("%") == 0:
qstring.append("%1")
qstring=regex.sub("{}",qstring)
- qstring = qstring.format(u' '.join(map(unicode, params)))
+ qstring = qstring.format(u' '.join(map(six.text_type, params)))
else:
raise EficasException("ValueError: i18n.translation: \
At most one '%' expected!")
a Unicode object out of it. To this end, assume the string is encoded
in utf-8; if this fails, then assume the string is encoded in Latin-9.
"""
- if isinstance(string, (unicode, int, float, complex)):
+ if isinstance(string, (six.text_type, int, float, complex)):
return string
elif isinstance(string, str):
return _str_to_unicode(string)
Latin-9 encoded.
"""
try:
- string = unicode(string, "utf-8")
+ string = six.text_type(string, "utf-8")
except UnicodeDecodeError:
try:
- string = unicode(string, "iso-8859-15")
+ string = six.text_type(string, "iso-8859-15")
except UnicodeDecodeError:
raise EficasException("UnicodeDecodeError: UTF-8, Latin-1 \
or Latin-9 expected")
from PyQt5.QtWidgets import QApplication
string = _preprocess_atom(string)
if len(args) == 0:
- r = unicode(QApplication.translate("@default", string))
+ r = six.text_type(QApplication.translate("@default", string))
elif len(args) == 1:
if isinstance(args[0], (dict, tuple)):
if string.count("%") == len(args[0]):
- r = unicode(QApplication.translate("@default", string)) % args[0]
+ r = six.text_type(QApplication.translate("@default", string)) % args[0]
elif string.count("%") == 1 and string.count("%(") == 0:
- r = unicode(QApplication.translate("@default", string))\
+ r = six.text_type(QApplication.translate("@default", string))\
% _preprocess_atom(repr(args[0]))
elif string.count("%") == 0:
- r = (unicode(QApplication.translate("@default", string)), args[0])
+ r = (six.text_type(QApplication.translate("@default", string)), args[0])
else:
raise EficasException("ValueError: i18n.translate.tr: \
Improper input string formatting")
- elif isinstance(args[0], (unicode, str, int, float, complex)):
+ elif isinstance(args[0], (six.text_type, str, int, float, complex)):
if string.count("%") == 1:
- r = unicode(QApplication.translate("@default", string))\
+ r = six.text_type(QApplication.translate("@default", string))\
% _preprocess_atom(args[0])
else:
- r = unicode(QApplication.translate("@default", string)) +\
- unicode(_preprocess_atom(args[0]))
+ r = six.text_type(QApplication.translate("@default", string)) +\
+ six.text_type(_preprocess_atom(args[0]))
elif isinstance(args[0], list) or args[0] is None:
if string.count("%") == 1:
- r = unicode(QApplication.translate("@default", string))\
+ r = six.text_type(QApplication.translate("@default", string))\
% _preprocess_atom(repr(args[0]))
else:
- r = (unicode(QApplication.translate("@default", string)), args[0])
+ r = (six.text_type(QApplication.translate("@default", string)), args[0])
else:
raise EficasException("ValueError: i18n.translation.tr: \
else:
raise EficasException("ValueError: i18n.translation.tr_qt: \
Improper formatting string parameters")
- elif isinstance(args[0], (unicode, str, int, float, complex)):
+ elif isinstance(args[0], (six.text_type, str, int, float, complex)):
r = _reformat_qstring_from_atom(r, args[0])
elif isinstance(args[0], list):
r = _reformat_qstring_from_list(r, args[0])
else:
raise EficasException("ValueError: i18n.translation.tr_qt: \
Improper formatted string parameter set")
- return unicode(r)
+ return six.text_type(r)
if __name__ == "__main__":
-# -*- coding: utf-8 -*-
+#i -*- coding: utf-8 -*-
# Copyright (C) 2007-2013 EDF R&D
#
# This library is free software; you can redistribute it and/or
listener(cargs+args)
"""
+from __future__ import absolute_import
+from __future__ import print_function
import traceback
from copy import copy
import weakref
-from Extensions.i18n import tr
-from Extensions.eficas_exception import EficasException
class ConnectorError(Exception):
pass
self.connections={}
def Connect(self, object, channel, function, args):
- ###print "Connect",object, channel, function, args
+ #print ("Connect",object, channel, function, args)
idx = id(object)
- if self.connections.has_key(idx):
+ #if self.connections.has_key(idx):
+ if idx in self.connections :
channels = self.connections[idx]
else:
channels = self.connections[idx] = {}
- if channels.has_key(channel):
+ #if channels.has_key(channel):
+ if channel in channels :
receivers = channels[channel]
else:
receivers = channels[channel] = []
receivers.remove((funct,fargs))
receivers.append((ref(function),args))
- ###print "Connect",receivers
def Disconnect(self, object, channel, function, args):
try:
receivers = self.connections[id(object)][channel]
except KeyError:
- raise ConnectorError, \
- 'no receivers for channel %s of %s' % (channel, object)
+ raise ConnectorError (
+ 'no receivers for channel %s of %s' % (channel, object))
for funct,fargs in receivers[:]:
if funct() is None:
del self.connections[id(object)]
return
- raise ConnectorError,\
+ raise ConnectorError(
'receiver %s%s is not connected to channel %s of %s' \
- % (function, args, channel, object)
+ % (function, args, channel, object))
try:
receivers = self.connections[id(object)][channel]
except KeyError:
- #print "ds except"
return
#print "Emit",object, channel, receivers
# Attention : copie pour eviter les pbs lies aux deconnexion reconnexion
try:
func=rfunc()
if func:
- apply(func, args + fargs)
+ #print (func,args,fargs)
+ #rint args + fargs
+ #apply(func, args + fargs)
+ if args + fargs == () : func()
+ else : func ( args + fargs)
else:
# Le receveur a disparu
if (rfunc,fargs) in receivers:receivers.remove((rfunc,fargs))
traceback.print_exc()
def ref(target,callback=None):
- if hasattr(target,"im_self"):
+ #if hasattr(target,"im_self"):
+ # return BoundMethodWeakref(target)
+ if hasattr(target,"__self__"):
return BoundMethodWeakref(target)
else:
return weakref.ref(target,callback)
class BoundMethodWeakref(object):
def __init__(self,callable):
- self.Self=weakref.ref(callable.im_self)
- self.Func=weakref.ref(callable.im_func)
+ #self.Self=weakref.ref(callable.im_self)
+ #self.Func=weakref.ref(callable.im_func)
+ self.Self=weakref.ref(callable.__self__)
+ self.Func=weakref.ref(callable.__func__)
def __call__(self):
target=self.Self()
if __name__ == "__main__":
class A:
pass
+
class B:
def add(self,a):
- print ("add ", self , a)
+ print(("--------------------------------add ", self , a))
+
def __del__(self):
- print ("__del__", self)
+ print(("__del__", self))
def f(a):
- print (f, a)
+ print((f, a))
+
a=A()
b=B()
c=B()
+
Connect(a,"add",b.add,())
Connect(a,"add",b.add,())
Connect(a,"add",c.add,())
Connect(a,"add",f,())
+
Emit(a,"add",1)
+
print ("del b")
del b
+
Emit(a,"add",1)
print ("del f")
del f
+
Emit(a,"add",1)
Disconnect(a,"add",c.add,())
Emit(a,"add",1)
#from I_VALIDATOR import ValidException
+from __future__ import absolute_import
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
from Noyau.N_VALIDATOR import ValError
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
+from __future__ import print_function
import types
def __init__(self,*args):
if len(args) > 2 :
- print ("Erreur a la creation de la regle A_CLASSER(",args,")")
+ print(("Erreur a la creation de la regle A_CLASSER(",args,")"))
return
- if type(args[0]) == types.TupleType:
- self.listeAvant=args[0]
+ if type(args[0]) == tuple:
+ self.listeAvant=args[0]
else :
- self.listeAvant=(args[0],)
- if type(args[1]) == types.TupleType:
- self.listeApres=args[1]
+ self.listeAvant=(args[0],)
+ if type(args[1]) == tuple:
+ self.listeApres=args[1]
else :
- self.listeApres=(args[1],)
+ self.listeApres=(args[1],)
def verif(self,args):
"""
boolListeApres=0
boolOK=1
for nom in args:
- if nom in self.listeAvant :
+ if nom in self.listeAvant :
boolListeAvant=1
- if boolListeApres == 1 :
+ if boolListeApres == 1 :
boolOK = 0
if nom in self.listeApres :
boolListeApres=1
"""
"""
-import string
+from __future__ import absolute_import
-import I_REGLE
+from . import I_REGLE
+import six
class A_CLASSER(I_REGLE.REGLE):
def gettext(self):
text = 'Regle ' + self.__class__.__name__+ ' :\n'
t=" D'abord :\n"+' '*8
for arg in self.args0:
- t=t+string.strip(arg)+' ou '
+ t=t+arg.strip()+' ou '
text = text + t[0:-4] +'\n'
t = " Ensuite :\n"+' '*8
for arg in self.args1:
- t=t+string.strip(arg)+' ou '
+ t=t+arg.strip()+' ou '
text = text + t[0:-4] +'\n'
- return unicode(text)
+ return six.text_type(text)
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
+import six
_no=0
import Accas
(self.ang != "" and self.ang != None) ):
dico={}
if self.get_docu() !=None : dico["docu"]=self.get_docu()
- if self.fr != None : dico["fr"]=unicode(self.fr,"iso-8859-1")
+ if self.fr != None : dico["fr"]=six.text_type(self.fr,"iso-8859-1")
if self.ang != None : dico["ang"]=self.ang
doc=ET.SubElement(moi,'doc')
doc.attrib=dico
# les attributs sont toujours du texte
dico={}
if (self.defaut != None) and (self.defaut != 'None') :
- if isinstance(self.defaut,str ) : dico["defaut"]=unicode(self.defaut,"iso-8859-1")
+ if isinstance(self.defaut,str ) : dico["defaut"]=six.text_type(self.defaut,"iso-8859-1")
else :dico["defaut"]=str(self.defaut)
if self.get_sug() !=None:
- if isinstance(self.get_sug(),str ) : dico["sug"]=unicode(self.get_sug(),"iso-8859-1")
+ if isinstance(self.get_sug(),str ) : dico["sug"]=six.text_type(self.get_sug(),"iso-8859-1")
else :dico["sug"]=str(self.get_sug())
doc=ET.SubElement(moi,'ValeurDef')
typeAttendu=ET.SubElement(moi,'typeAttendu')
l=[]
for t in self.type:
- if type(t) == types.TypeType : l.append(t.__name__)
+ if type(t) == type : l.append(t.__name__)
else : l.append(t)
typeAttendu.text=str(l)
"""
"""
# Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
import sys,re
-import string,types
+import types
from copy import copy
from Extensions.i18n import tr
# fin import a resorber
# Modules EFICAS
-import I_MCCOMPO
-import CONNECTOR
+from . import I_MCCOMPO
+from . import CONNECTOR
from Extensions import commande_comm
class ETAPE(I_MCCOMPO.MCCOMPO):
def get_sdname(self):
#print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
if CONTEXT.debug :
- print ("SDNAME ", self.reuse, self.sd, self.sd.get_name())
+ print(("SDNAME ", self.reuse, self.sd, self.sd.get_name()))
sdname=''
if self.reuse != None:
sdname= self.reuse.get_name()
else:
if self.sd:sdname=self.sd.get_name()
- if string.find(sdname,'sansnom') != -1 or string.find(sdname,'SD_') != -1:
+ if sdname.find('sansnom') != -1 or sdname.find('SD_') != -1:
# dans le cas ou la SD est 'sansnom' ou 'SD_' on retourne la chaine vide
return ''
return sdname
else :
#Un concept produit preexiste
old_nom=self.sd.nom
- if string.find(old_nom,'sansnom') :
+ if old_nom.find('sansnom') :
# Dans le cas ou old_nom == sansnom, isvalid retourne 0 alors que ...
# par contre si le concept existe et qu'il s'appelle sansnom c'est que l'etape est valide
# on peut donc le nommer sans test prealable
"""
#print "control_sdprods",d.keys(),self.sd and self.sd.nom,self.nom
if self.sd:
- if d.has_key(self.sd.nom):
+ if self.sd.nom in d :
# Le concept est deja defini
if self.reuse and self.reuse is d[self.sd.nom]:
# Le concept est reutilise : situation normale
if type(self.definition.sd_prod) == types.FunctionType:
d=self.cree_dict_valeurs(self.mc_liste)
try:
- classe_sd_prod = apply(self.definition.sd_prod,(),d)
+ classe_sd_prod = self.definition.sd_prod(*(), **d)
except:
return []
else:
texte_commande = g.gener(self,format='beautifie')
# Il faut enlever la premiere ligne vide de texte_commande que
# rajoute le generator
- #rebut,texte_commande = string.split(texte_commande,'\n',1)
# on construit l'objet COMMANDE_COMM repesentatif de self mais non
# enregistre dans le jdc (pas ajoute dans jdc.etapes)
parent=self.parent
"""
try:
sd=Noyau.N_ETAPE.ETAPE.Build_sd(self,nom)
- except AsException,e :
+ except AsException as e :
# Une erreur s'est produite lors de la construction du concept
# Comme on est dans EFICAS, on essaie de poursuivre quand meme
# Si on poursuit, on a le choix entre deux possibilites :
"""
"""
-import I_REGLE
+from __future__ import absolute_import
+from . import I_REGLE
class EXCLUS(I_REGLE.REGLE):
def purge_liste(self,liste_a_purger,liste_mc_presents):
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import types,string
+from __future__ import absolute_import
+import types
class Fichier:
def __convert__(self,valeur):
# Attention ne verifie pas grand chose
# cela vaut-il la peine de refaire ce que Qt fait tres bien
- if type(valeur) != types.StringType :
+ if type(valeur) != bytes :
return None
return valeur
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import string
-from I_ASSD import ASSD
+from __future__ import absolute_import
+from __future__ import print_function
+from .I_ASSD import ASSD
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
try :
res=eval(self.expression,self.jdc.const_context, context)
except :
-####### A TRAVAILLER DEPUIS ICI !!
- print (tr(75 * '!'))
- print ('! ' + tr(string.ljust("Erreur evaluation formule %s", 72), self.nom) + '!')
- print (tr(75 * '!'))
+ print (75 * '!')
+ print ('! ' + "Erreur evaluation formule %s" % self.nom + 20*'!')
+ print (75 * '!')
raise EficasException
return res
#
"""
"""
+from __future__ import absolute_import
import string,traceback,re
identifier = re.compile(r"^[^\d\W]\w*\Z", re.UNICODE)
from Extensions.i18n import tr
-from I_MACRO_ETAPE import MACRO_ETAPE
+from .I_MACRO_ETAPE import MACRO_ETAPE
from Extensions import interpreteur_formule
from Editeur import analyse_catalogue
-analyse_catalogue.l_noms_commandes.append('FORM') # déclare le nom FORM à l'analyseur de catalogue
+analyse_catalogue.l_noms_commandes.append('FORM') # declare le nom FORM a l'analyseur de catalogue
class FORM_ETAPE(MACRO_ETAPE):
def McBuild(self):
self.mc_liste=self.build_mc()
- # on crée la liste des types autorisés (liste des noms de mots-clés
+ # on cree la liste des types autorises (liste des noms de mots-cles
# simples dans le catalogue de FORMULE)
- self.l_types_autorises = self.definition.entites.keys()
+ self.l_types_autorises = list(self.definition.entites.keys())
# en plus de la construction traditionnelle des fils de self
- # il faut pour les FORMULE décortiquer l'expression ...
+ # il faut pour les FORMULE decortiquer l'expression ...
self.type_retourne,self.arguments,self.corps = self.analyse_formule()
def analyse_formule(self):
"""
- Cette méthode décortique l'expression de la FORMULE.
+ Cette methode decortique l'expression de la FORMULE.
Elle retourne 3 valeurs:
- - le type retourné par la FORMULE
+ - le type retourne par la FORMULE
- les arguments de la FORMULE
- le corps de la FORMULE, cad son expression
"""
if len(self.mc_liste) == 0:
- # pas de fils pour self --> la FORMULE est incomplète
+ # pas de fils pour self --> la FORMULE est incomplete
return None,None,None
type_retourne="REEL"
if len(self.mc_liste) > 0:
def get_formule(self):
"""
- Retourne un tuple décrivant la formule :
+ Retourne un tuple decrivant la formule :
(nom,type_retourne,arguments,corps)
"""
t,a,c = self.analyse_formule()
def verif_arguments(self,arguments = None):
"""
- Vérifie si les arguments passés en argument (si aucun prend les arguments courants)
+ Verifie si les arguments passes en argument (si aucun prend les arguments courants)
sont des arguments valide pour une FORMULE.
Retourne :
- - un booléen, qui vaut 1 si arguments licites, 0 sinon
+ - un booleen, qui vaut 1 si arguments licites, 0 sinon
- un message d'erreurs ('' si illicites)
"""
if not arguments :
arguments = self.arguments
if not arguments :
return 0,"Une formule doit avoir au minimum un argument"
- # il faut au préalable enlever les parenthèses ouvrantes et fermantes
+ # il faut au prealable enlever les parentheses ouvrantes et fermantes
# encadrant les arguments
arguments = string.strip(arguments)
if arguments[0] != '(':
# on peut tester la syntaxe de chaque argument maintenant
erreur=''
test = 1
- arguments = arguments[1:-1] # on enlève les parenthèses ouvrante et fermante
+ arguments = arguments[1:-1] # on enleve les parentheses ouvrante et fermante
l_arguments = string.split(arguments,',')
for a in l_arguments :
if not re.match(identifier,str(a)) : return 0, str(a)+" n est pas un identifiant"
def verif_corps(self,corps=None,arguments=None):
"""
- Cette méthode a pour but de vérifier si le corps de la FORMULE
+ Cette methode a pour but de verifier si le corps de la FORMULE
est syntaxiquement correct.
Retourne :
- - un booléen, qui vaut 1 si corps de FORMULE licite, 0 sinon
+ - un booleen, qui vaut 1 si corps de FORMULE licite, 0 sinon
- un message d'erreurs ('' si illicite)
"""
if not corps :
if not arguments :
arguments = self.arguments
formule=(self.get_nom(),self.type_retourne,arguments,corps)
- # on récupère la liste des constantes et des autres fonctions prédéfinies
- # et qui peuvent être utilisées dans le corps de la formule courante
+ # on recupere la liste des constantes et des autres fonctions predefinies
+ # et qui peuvent etre utilisees dans le corps de la formule courante
l_ctes,l_form = self.jdc.get_parametres_fonctions_avant_etape(self)
- # on crée un objet vérificateur
+ # on cree un objet verificateur
try:
verificateur = self.interpreteur(formule=formule,
constantes = l_ctes,
def verif_nom(self,nom=None):
"""
- Vérifie si le nom passé en argument (si aucun prend le nom courant)
+ Verifie si le nom passe en argument (si aucun prend le nom courant)
est un nom valide pour une FORMULE.
Retourne :
- - un booléen, qui vaut 1 si nom licite, 0 sinon
+ - un booleen, qui vaut 1 si nom licite, 0 sinon
- un message d'erreurs ('' si illicite)
"""
if not nom :
def verif_type(self,type=None):
"""
- Vérifie si le type passé en argument (si aucun prend le type courant)
+ Verifie si le type passe en argument (si aucun prend le type courant)
est un type valide pour une FORMULE.
Retourne :
- - un booléen, qui vaut 1 si type licite, 0 sinon
+ - un booleen, qui vaut 1 si type licite, 0 sinon
- un message d'erreurs ('' si illicite)
"""
if not type:
def verif_formule(self,formule=None):
"""
- Vérifie la validité de la formule passée en argument.
- Cette nouvelle formule est passée sous la forme d'un tuple : (nom,type_retourne,arguments,corps)
- Si aucune formule passée, prend les valeurs courantes de la formule
+ Verifie la validite de la formule passee en argument.
+ Cette nouvelle formule est passee sous la forme d'un tuple : (nom,type_retourne,arguments,corps)
+ Si aucune formule passee, prend les valeurs courantes de la formule
Retourne :
- - un booléen, qui vaut 1 si formule licite, 0 sinon
+ - un booleen, qui vaut 1 si formule licite, 0 sinon
- un message d'erreurs ('' si illicite)
"""
if not formule :
test_corps,erreur_corps = self.verif_corps(corps = formule[3], arguments = args)
# test global = produit des tests partiels
test = test_nom*test_type*test_arguments*test_corps
- # message d'erreurs global = concaténation des messages partiels
+ # message d'erreurs global = concatenation des messages partiels
erreur = ''
if not test :
for mess in (erreur_nom,erreur_type,erreur_arguments,erreur_corps):
def update(self,formule):
"""
- Méthode externe.
- Met à jour les champs nom, type_retourne,arguments et corps de la FORMULE
- par les nouvelles valeurs passées dans le tuple formule.
- On stocke les valeurs SANS vérifications.
+ Methode externe.
+ Met a jour les champs nom, type_retourne,arguments et corps de la FORMULE
+ par les nouvelles valeurs passees dans le tuple formule.
+ On stocke les valeurs SANS verifications.
"""
self.type_retourne = formule[1]
self.arguments = '('+formule[2]+')'
self.corps = formule[3]
- # il faut ajouter le mot-clé simple correspondant dans mc_liste
- # pour cela on utilise la méthode générale build_mc
- # du coup on est obligé de modifier le dictionnaire valeur de self ...
+ # il faut ajouter le mot-cle simple correspondant dans mc_liste
+ # pour cela on utilise la methode generale build_mc
+ # du coup on est oblige de modifier le dictionnaire valeur de self ...
self.valeur = {}
self.valeur[self.type_retourne] = self.arguments+' = ' + self.corps
self.McBuild()
mocles["VALE_C"]=formule[2]
for k,v in self.definition.entites.items():
- if not mocles.has_key(k):continue
+ if not k in mocles : continue
child=self.definition.entites[k](None,nom=k,parent=self)
child.valeur=mocles[k]
child.state = 'modified'
- sd=concept detruit
Fonction :
Mettre a jour les mots cles de l etape et eventuellement le concept produit si reuse
- suite à la disparition du concept sd
+ suite a la disparition du concept sd
Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils,
- sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas
- utilisé dans le corps de la fonction
+ sauf les objets FORM_ETAPE qui doivent verifier que le concept detruit n'est pas
+ utilise dans le corps de la fonction
"""
self.init_modif()
- old_sd=concept remplace
- sd = nouveau concept
Fonction :
- Les objets FORM_ETAPE devraient vérifier que le concept remplacé n'est pas
- utilisé dans le corps de la fonction
+ Les objets FORM_ETAPE devraient verifier que le concept remplace n'est pas
+ utilise dans le corps de la fonction
"""
self.init_modif()
"""
"""
# Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
import types,traceback,sys,os
-import string,linecache
+import linecache
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
# Modules Eficas
-import I_OBJECT
+from . import I_OBJECT
import Noyau
from Noyau.N_ASSD import ASSD
#from Noyau.N_LASSD import LASSD
from Noyau.N_ETAPE import ETAPE
from Noyau.N_Exception import AsException
from Extensions import commentaire,parametre,parametre_eval
-import CONNECTOR
+from . import CONNECTOR
import Validation
class LASSD:
return 1
elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' :
return 1
- elif type(type_ok) != types.ClassType and not isinstance(type_ok,type):
+ elif type(type_ok) != type and not isinstance(type_ok,type):
continue
elif v.__class__ == type_ok or issubclass(v.__class__,type_ok):
return 1
if isinstance(child,commentaire.COMMENTAIRE):
ind = ind+1
objet = commentaire.COMMENTAIRE('',parent=self)
- objet.nom = "_comm_"+`ind`
+ objet.nom = "_comm_"+repr(ind)
if pos == None : pos = 0
self.etapes.insert(pos,objet)
self.reset_context()
et du contexte gobal
"""
if param in self.params : self.params.remove(param)
- if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
+ if param.nom in self.g_context : del self.g_context[param.nom]
def get_parametres_fonctions_avant_etape(self,etape):
"""
for param in self.params:
nom = param.nom
if not nom : continue
- if d.has_key(nom): l_constantes.append(nom)
+ if nom in d: l_constantes.append(nom)
# construction de l_fonctions
for form in self.fonctions:
nom = form.nom
if not nom : continue
- if d.has_key(nom): l_fonctions.append(form.get_formule())
+ if nom in d: l_fonctions.append(form.get_formule())
# on ajoute les concepts produits par DEFI_VALEUR
# XXX On pourrait peut etre faire plutot le test sur le type
#print "del_sdprod",self.g_context
#print "del_sdprod",self.sds_dict
#if sd in self.sds : self.sds.remove(sd)
- if self.g_context.has_key(sd.nom) : del self.g_context[sd.nom]
- if self.sds_dict.has_key(sd.nom) : del self.sds_dict[sd.nom]
+ if sd.nom in self.g_context : del self.g_context[sd.nom]
+ if sd.nom in self.sds_dict : del self.sds_dict[sd.nom]
def del_param(self,param):
"""
et du contexte gobal
"""
if param in self.params : self.params.remove(param)
- if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
+ if param.nom in self.g_context : del self.g_context[param.nom]
def del_fonction(self,fonction):
"""
et du contexte gobal
"""
if fonction in self.fonctions : self.fonctions.remove(fonction)
- if self.g_context.has_key(fonction.nom) : del self.g_context[fonction.nom]
+ if fonction.nom in self.g_context: del self.g_context[fonction.nom]
def append_sdprod(self,sd):
"""
child.update_concept(sd)
def dump_state(self):
- print ("JDC.state: ",self.state)
+ print(("JDC.state: ",self.state))
for etape in self.etapes :
- print (etape.nom+".state: ",etape.state)
+ print((etape.nom+".state: ",etape.state))
def change_unit(self,unit,etape,old_unit):
#print "change_unit",unit,etape,old_unit
# Cette etape est indiquee par l'attribut _etape_context qui a ete
# positionne prealablement par un appel a set_etape_context
- if CONTEXT.debug : print ("JDC.NommerSdprod ",sd,sdnom)
+ if CONTEXT.debug : print(("JDC.NommerSdprod ",sd,sdnom))
if self._etape_context:
o=self.get_contexte_avant(self._etape_context).get(sdnom,None)
text=fproc.read()
fproc.close()
#if file == None : return None,None
- text=string.replace(text,'\r\n','\n')
+ text=text.replace('\r\n','\n')
if file:
- linecache.cache[file]=0,0,string.split(text,'\n'),file
+ linecache.cache[file]=0,0,text.split('\n'),file
return file,text
def isvalid(self,cr='non'):
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau import N_JDC_CATA
class JDC_CATA:
return
-#ATTENTION SURCHARGE: cette methode doit etre synchronisée avec celle du Noyau
+#ATTENTION SURCHARGE: cette methode doit etre synchronisee avec celle du Noyau
def enregistre(self,commande):
"""
- Cette méthode surcharge la méthode de la classe du Noyau
- Marche avec Noyau mais si un autre package l'a déjà surchargée ???
+ Cette methode surcharge la methode de la classe du Noyau
+ Marche avec Noyau
"""
N_JDC_CATA.JDC_CATA.enregistre(self,commande)
self.l_noms_entites.append(commande.nom)
"""
"""
# Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
import sys
import os.path as osp
-import traceback,types,string
+import traceback,types
# Modules Eficas
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
-import exceptions
-import I_ETAPE
-import I_ENTITE
-import I_OBJECT
+from . import I_ETAPE
+from . import I_ENTITE
+from . import I_OBJECT
import Noyau
from Noyau.N_ASSD import ASSD
from Noyau import N__F
from Noyau import N_Exception
from Noyau.N_Exception import AsException
import Accas # attention aux imports circulaires
+import six
+from six.moves import range
# fin import a resorber
class MACRO_ETAPE(I_ETAPE.ETAPE):
if co.nom == nom_sd:return co
if type(self.definition.op_init) == types.FunctionType:
d={}
- apply(self.definition.op_init,(self,d))
+ self.definition.op_init(*(self,d))
return d.get(nom_sd,None)
return None
ou leve une exception
--> utilisee par ops.POURSUITE et INCLUDE
"""
- #print "get_contexte_jdc",self,self.nom
+ print ("get_contexte_jdc",self,self.nom)
# On recupere l'etape courante
step=CONTEXT.get_current_step()
try:
+ #if 1 :
# on essaie de creer un objet JDC auxiliaire avec un contexte initial
# Attention get_contexte_avant retourne un dictionnaire qui contient
# le contexte courant. Ce dictionnaire est reactualise regulierement.
format=self.jdc.appli.format_fichier.get()
#on force a python pour Carmel
if format=="CARMEL3D" : format="python"
- if convert.plugins.has_key(format):
+ if format in convert.plugins :
# Le convertisseur existe on l'utilise
p=convert.plugins[format]()
p.text=text
self.jdc.jdcDict=self.jdc_aux
except:
+ #else :
traceback.print_exc()
# On retablit l'etape courante step
CONTEXT.unset_current_step()
#print j.isvalid()
CONTEXT.unset_current_step()
CONTEXT.set_current_step(step)
- raise exceptions.Exception(tr("Impossible de relire le fichier %s \n ")+ unicode(j.cr))
+ raise EficasException(tr("Impossible de relire le fichier %s \n ")+ six.text_type(j.cr))
if not j.isvalid():
# le nommage est possible
self.g_context.clear()
for k,v in j_context.items():
- if not context_ini.has_key(k) or context_ini[k] != v:
+ if (not k in context_ini) or (context_ini[k] != v):
self.g_context[k]=v
self.parent.sds_dict[k]=v
if callable(v):continue
self.g_context[k]=param2.Variable(k,v)
+ print ('kljkljkljlkjklj')
# On recupere le contexte courant
self.current_context=j.current_context
self.index_etape_courante=j.index_etape_courante
CONTEXT.unset_current_step()
CONTEXT.set_current_step(step)
+ print ('kljkljkljlkjklj')
return j_context
def reevalue_sd_jdc(self):
if not hasattr(self,'old_contexte_fichier_init'):return [],[]
l_sd_suppressed = []
l_sd_replaced = []
- for old_key in self.old_contexte_fichier_init.keys():
- if not self.contexte_fichier_init.has_key(old_key):
+ for old_key in self.old_contexte_fichier_init:
+ if not old_key in self.contexte_fichier_init:
if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
else:
"""
#print "I_MACRO_ETAPE.control_sdprods",d.keys(),self.nom,self.sd and self.sd.nom
if self.sd:
- if d.has_key(self.sd.nom):
+ if self.sd.nom in d:
# Le concept est deja defini
if self.reuse and self.reuse is d[self.sd.nom]:
# Le concept est reutilise : situation normale
sdprods=self.sdprods[:]
self.sdprods=[]
for co in sdprods:
- if d.has_key(co.nom) and co is not d[co.nom] :
+ if co.nom in d and co is not d[co.nom] :
#nettoie les mots cles de l'etape qui ont comme valeur co
self.delete_concept(co)
#supprime les references a co dans les etapes suivantes
self.make_contexte_include(new_fic,text)
except:
l=traceback.format_exception_only(tr("Fichier invalide %s", sys.exc_info()[1]))
- self.fichier_err=string.join(l)
+ self.fichier_err=''.join(l)
raise EficasException(self.fichier_err)
# L'evaluation de text dans un JDC auxiliaire s'est bien passe
self.g_context.clear()
context_ini=self.jdc_aux.context_ini
for k,v in j_context.items():
- if not context_ini.has_key(k) or context_ini[k] != v:
+ if not k in context_ini or context_ini[k] != v:
self.g_context[k]=v
self.parent.sds_dict[k]=v
# On recupere le contexte courant
l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
if self.jdc.appli is not None:
self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
- message= tr("Ce fichier ne sera pas pris en compte\n %s",string.join(l)))
+ message= tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
self.g_context={}
self.etapes=[]
self.jdc_aux=None
- self.fichier_err = string.join(l)
+ self.fichier_err = ''.join(l)
self.contexte_fichier_init={}
self.init_modif()
self.fin_modif()
"""
Cette methode sert a craer un contexte en interpratant un texte source Python.
"""
- #print "make_contexte_include",fichier
+ print ("make_contexte_include",fichier)
# on recupere le contexte d'un nouveau jdc dans lequel on interprete text
contexte = self.get_contexte_jdc(fichier,text)
+ print ("make_contexte_include",fichier)
if contexte == None :
raise EficasException("Impossible de construire le jeu de commandes correspondant au fichier")
else:
# g_context est utilise pour avoir les concepts produits par la macro
# contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro
self.contexte_fichier_init = contexte
- #print "fin make_contexte_include",fichier
+ print ("fin make_contexte_include",fichier)
def reevalue_fichier_init_OBSOLETE(self):
"""Recalcule les concepts produits par le fichier enregistre"""
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.fichier_err = ''.join(l)
self.g_context={}
self.etapes=[]
self.jdc_aux=None
l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
# On conserve la memoire du nouveau fichier
# mais on n'utilise pas les concepts crees par ce fichier
- # on met l'etape en erreur : fichier_err=string.join(l)
- self.fichier_err=string.join(l)
+ # on met l'etape en erreur : fichier_err=''.join(l)
+ self.fichier_err=''.join(l)
self.g_context={}
self.etapes=[]
self.jdc_aux=None
# On est dans le cas d'un include. On reutilise toutes les unites de parent
units=self.parent.recorded_units
- if self.parent.recorded_units.has_key(unite):
+ if unite in self.parent.recorded_units:
f,text,units=self.parent.recorded_units[unite]
elif self.jdc :
if fname:
if not osp.exists(fname):
raise AsException(fname + tr(" n'est pas un fichier existant"))
f = fname
- text = open(fname, 'rb').read()
+ text = open(fname, 'r').read()
else:
f,text=self.jdc.get_file(unite=unite, fic_origine=fic_origine)
else:
return
if type(self.definition.op_init) == types.FunctionType:
- apply(self.definition.op_init,(self,d))
+ self.definition.op_init(*(self,d))
if self.sd != None:d[self.sd.nom]=self.sd
for co in self.sdprods:
d[co.nom]=co
def make_includeCND(self,fichier=None):
unite=999
if fichier==None : return
- if hasattr(self,'fichier_ini') : print (self.fichier_ini)
+ if hasattr(self,'fichier_ini') : print((self.fichier_ini))
if hasattr(self,'fichier_ini') : return
self.fichier_ini=fichier
from acquiertGroupes import getGroupes
raise EficasException(" ")
if nbVariableOut != 1 :
- print (nbVariableOut ,"nbVariableOut")
+ print((nbVariableOut ,"nbVariableOut"))
self.make_incl2_except(mess=tr("le fichier doit contenir une unique variable de sortie"))
raise EficasException(" ")
raise EficasException(" ")
try:
- print (self.fichier_ini ,self.fichier_text)
+ print((self.fichier_ini ,self.fichier_text))
self.make_contexte_include(self.fichier_ini ,self.fichier_text)
self.old_context_fichier_init=self.contexte_fichier_init
self.parent.record_unit(unite,self)
if mess == None :
self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
message= tr("Le contenu de ce fichier ne sera pas pris en compte\n %s",\
- string.join(l)))
+ ''.join(l)))
else :
self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
self.g_context={}
self.etapes=[]
self.jdc_aux=None
- self.fichier_err = string.join(l)
+ self.fichier_err = ''.join(l)
self.contexte_fichier_init={}
try :
MCFils=self.get_child('FileName')
l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
if self.jdc.appli:
self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
- message=tr("Le contenu de ce fichier ne sera pas pris en compte\n"+string.join(l)))
+ message=tr("Le contenu de ce fichier ne sera pas pris en compte\n"+''.join(l)))
self.parent.record_unit(unite,self)
self.g_context={}
self.etapes=[]
self.jdc_aux=None
- self.fichier_err = string.join(l)
+ self.fichier_err = ''.join(l)
self.contexte_fichier_init={}
raise EficasException(" ")
raise EficasException(" ")
try:
self.make_contexte_include(self.fichier_ini ,self.fichier_text)
- if not self.g_context.has_key(self.nom_mater):
+ if not self.nom_mater in self.g_context :
#Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
self.g_context[self.nom_mater]=None
if self.parent: self.parent.g_context[self.nom_mater]=None
except:
l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
- self.fichier_err = string.join(l)
+ self.fichier_err = ''.join(l)
self.g_context={}
#Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
if self.parent:
l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
if self.jdc.appli:
self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier poursuite"),
- message=tr("Ce fichier ne sera pas pris en compte\n %s",string.join(l)))
+ message=tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
self.parent.record_unit(None,self)
self.g_context={}
self.etapes=[]
self.jdc_aux=None
- self.fichier_err = string.join(l)
+ self.fichier_err = ''.join(l)
self.contexte_fichier_init={}
raise EficasException(" ")
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import I_MCCOMPO
+from __future__ import absolute_import
+from . import I_MCCOMPO
class MCBLOC(I_MCCOMPO.MCCOMPO):pass
#
"""
"""
+from __future__ import absolute_import
+from __future__ import print_function
import string,types,sys
from copy import copy
import traceback
+import Validation
from Extensions.i18n import tr
-from Noyau.N_MCLIST import MCList
from Noyau.N_MCSIMP import MCSIMP
from Noyau.N_MCFACT import MCFACT
from Noyau.N_MCBLOC import MCBLOC
-import I_OBJECT
-import Validation
+from Noyau.N_MCLIST import MCList
+from . import I_OBJECT
-import CONNECTOR
+from . import CONNECTOR
class MCCOMPO(I_OBJECT.OBJECT):
def getlabeltext(self):
dico=objet_cata.entites
l=[]
specifique=0
- for obj in dico.keys() :
+ for obj in list(dico.keys()) :
if not(hasattr(dico[obj],'cache')) or dico[obj].cache==0 :
l.append(obj)
else :
pass
else :
#XXX CCAR : les MCNUPLET ne sont pas traites
- if CONTEXT.debug : print ' ',k,' est un objet de type inconnu :',type(objet)
+ if CONTEXT.debug : print(' ',k,' est un objet de type inconnu :',type(objet))
else :
# l'objet est absent : on enleve de la liste les blocs
if self.definition.entites[k].statut=='c' :
d_mc[mc.nom]=mc
# on construit la liste des objets ordonnes
for nom_mc in liste_noms_mc_ordonnee:
- if d_mc.has_key(nom_mc):
+ if nom_mc in d_mc:
liste.append(d_mc.get(nom_mc))
# on la retourne
return liste
l'objet MCCOMPOSE
"""
self.init_modif()
- if type(name)==types.StringType :
+ if type(name)==bytes :
# on est en mode creation d'un motcle
if self.ispermis(name) == 0 : return 0
objet=self.definition.entites[name](val=None,nom=name,parent=self)
est bien permis, cad peut bien etre un fils de self,
Retourne 0 sinon
"""
- if type(fils) == types.StringType :
+ if type(fils) == bytes :
# on veut juste savoir si self peut avoir un fils de nom 'fils'
- if self.definition.entites.has_key(fils):
+ if fils in self.definition.entites:
return 1
else :
return 0
# la verification du nom de suffit pas (plusieurs commandes
# ont le meme mot-cle facteur AFFE ... et c'est l'utilisateur
# qui choisit le pere d'ou un risque d'erreur)
- if not self.definition.entites.has_key(fils.nom):
+ if not fils.nom in self.definition.entites:
return 0
else:
if fils.parent.nom != self.nom : return 0
try :
motcle.update_mc_global()
except :
- pass
+ pass
def init_modif_up(self):
Validation.V_MCCOMPO.MCCOMPO.init_modif_up(self)
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Extensions.i18n import tr
-import CONNECTOR
-import I_MCCOMPO
+from . import CONNECTOR
+from . import I_MCCOMPO
import Noyau
-import string
class MCFACT(I_MCCOMPO.MCCOMPO):
def isrepetable(self):
"""
- Indique si l'objet est répétable.
- Retourne 1 si le mot-clé facteur self peut être répété
+ Indique si l'objet est repetable.
+ Retourne 1 si le mot-cle facteur self peut etre repete
Retourne 0 dans le cas contraire
"""
if self.definition.max > 1:
try:
if len(objet) > 1 :
- index = objet.get_index(self)+1 # + 1 à cause de la numérotation qui commence à 0
- return self.nom +'_'+`index`+':'
+ index = objet.get_index(self)+1 # + 1 a cause de la numerotation qui commence a 0
+ return self.nom +'_'+repr(index)+':'
else:
return self.nom
except:
if nom[-1]==':' : nom=nom[0:-1]
if self.parent:
l=self.parent.get_genealogie_precise()
- l.append(string.strip(nom))
+ l.append(nom.strip())
return l
else:
- return [string.strip(nom)]
+ return [nom.strip()]
def init_modif(self):
"""
- Met l'état de l'objet à modified et propage au parent
+ Met l'etat de l'objet a modified et propage au parent
qui vaut None s'il n'existe pas
"""
self.state = 'modified'
def fin_modif(self):
"""
- Méthode appelée après qu'une modification a été faite afin de déclencher
- d'éventuels traitements post-modification
+ Methode appelee apres qu'une modification a ete faite afin de declencher
+ d'eventuels traitements post-modification
"""
#print "fin_modif",self
- # pour les objets autres que les commandes, aucun traitement spécifique
+ # pour les objets autres que les commandes, aucun traitement specifique
# on remonte l'info de fin de modif au parent
CONNECTOR.Emit(self,"valid")
parent= hasattr(self,"alt_parent") and self.alt_parent or self.parent
parent.fin_modif()
def normalize(self):
- """ Retourne le MCFACT normalisé. Pour un MCFACT isolé, l'objet normalisé
+ """ Retourne le MCFACT normalise. Pour un MCFACT isole, l'objet normalise
est une MCLIST de longueur 1 qui contient ce MCFACT
"""
new_obj = self.definition.list_instance()
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
import types,traceback
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
from copy import copy
-import CONNECTOR
+from . import CONNECTOR
class MCList:
def isMCList(self):
"""
- Retourne 1 si self est une MCList (liste de mots-clés), 0 sinon (défaut)
+ Retourne 1 si self est une MCList (liste de mots-cles), 0 sinon (defaut)
"""
return 1
def ajout_possible(self):
"""
- Méthode booléenne qui retourne 1 si on peut encore ajouter une occurrence
- de l'élément que contient self, 0 sinon
+ Methode booleenne qui retourne 1 si on peut encore ajouter une occurrence
+ de l'element que contient self, 0 sinon
"""
max = self.data[0].definition.max
- if max == '**':
+ if max == '**' or max == float('inf'):
return 1
else:
if len(self) < max :
def isrepetable(self):
"""
- Indique si l'objet est répétable.
- Retourne 1 si le mot-clé facteur self peut être répété
+ Indique si l'objet est repetable.
+ Retourne 1 si le mot-cle facteur self peut etre repete
Retourne 0 dans le cas contraire
"""
if self.data[0].definition.max > 1:
def isoblig(self):
"""
- Une MCList n'est jamais obligatoire (même si le MCFACT qu'elle représente l'est
+ Une MCList n'est jamais obligatoire (meme si le MCFACT qu'elle represente l'est
"""
return self.data[0].definition.statut=='o'
Ajoute le mot cle facteur obj a la MCLIST a la position pos
Retourne None si l'ajout est impossible
"""
- if type(obj)==types.StringType :
- # on est en mode création d'un motcle
+ if type(obj)==bytes :
+ # on est en mode creation d'un motcle
raise EficasException(tr("traitement non-prevu"))
if not self.ajout_possible():
def replace_concept(self,old_sd,sd):
"""
Inputs :
- - old_sd=concept remplacé
+ - old_sd=concept remplace
- sd=nouveau concept
Fonction : Mettre a jour les fils de l objet suite au remplacement
du concept old_sd
def get_liste_mc_inconnus(self):
"""
- Retourne la liste des mots-clés inconnus dans self
+ Retourne la liste des mots-cles inconnus dans self
"""
l_mc = []
for mcfact in self.data :
def verif_condition_regles(self,liste_presents):
"""
- Retourne la liste des mots-clés à rajouter pour satisfaire les règles
- en fonction de la liste des mots-clés présents
+ Retourne la liste des mots-cles a rajouter pour satisfaire les regles
+ en fonction de la liste des mots-cles presents
"""
- # Sans objet pour une liste de mots clés facteurs
+ # Sans objet pour une liste de mots cles facteurs
return []
def deep_update_condition_bloc(self):
def verif_condition_bloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
- (en fonction du catalogue donc de la définition) de self et
+ (en fonction du catalogue donc de la definition) de self et
retourne deux listes :
- - la première contient les noms des blocs à rajouter
- - la seconde contient les noms des blocs à supprimer
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
"""
- # Sans objet pour une liste de mots clés facteurs (a voir !!!)
+ # Sans objet pour une liste de mots cles facteurs (a voir !!!)
return [],[]
def init_modif(self):
"""
- Met l'état de l'objet à modified et propage au parent
+ Met l'etat de l'objet a modified et propage au parent
qui vaut None s'il n'existe pas
"""
self.state = 'modified'
def fin_modif(self):
"""
- Méthode appelée après qu'une modification a été faite afin de déclencher
- d'éventuels traitements post-modification
+ Methode appelee apres qu'une modification a ete faite afin de declencher
+ d'eventuels traitements post-modification
"""
#print "fin_modif",self
CONNECTOR.Emit(self,"valid")
def get_genealogie(self):
"""
Retourne la liste des noms des ascendants.
- Un objet MCList n'est pas enregistré dans la genealogie.
+ Un objet MCList n'est pas enregistre dans la genealogie.
XXX Meme si le MCFACT fils ne l'est pas lui non plus ????
"""
if self.parent:
def get_liste_mc_ordonnee_brute(self,liste,dico):
"""
- Retourne la liste ordonnée (suivant le catalogue) BRUTE des mots-clés
- d'une entité composée dont le chemin complet est donné sous forme
+ Retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles
+ d'une entite composee dont le chemin complet est donne sous forme
d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
"""
for arg in liste:
def verif_existence_sd(self):
"""
- Vérifie que les structures de données utilisées dans self existent bien dans le contexte
- avant étape, sinon enlève la référence à ces concepts
+ Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
+ avant etape, sinon enleve la reference a ces concepts
"""
for motcle in self.data :
motcle.verif_existence_sd()
en tenant compte de la langue
"""
try :
- return self.data[0].get_fr()
+ return self.data[0].get_fr().decode('latin-1')
except:
return ''
def normalize(self):
"""
- Retourne l'objet normalisé. Une liste est déjà normalisée
+ Retourne l'objet normalise. Une liste est deja normalisee
"""
return self
def update_mc_global(self):
"""
- Met a jour les mots cles globaux enregistrés dans l'étape parente
+ Met a jour les mots cles globaux enregistres dans l'etape parente
et dans le jdc parent.
Une liste ne peut pas etre globale. Elle se contente de passer
la requete a ses fils.
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import types,string
+from __future__ import absolute_import
+import types
import traceback
from copy import copy
-from repr import Repr
+from six.moves.reprlib import Repr
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
+from six.moves import range
myrepr = Repr()
myrepr.maxstring = 100
myrepr.maxother = 100
from Noyau.N_utils import repr_float
import Validation
-import CONNECTOR
+from . import CONNECTOR
# Attention : les classes ASSD,.... peuvent etre surchargees
# dans le package Accas. Il faut donc prendre des precautions si
from Extensions import parametre
from Extensions import param2
-import I_OBJECT
-import CONNECTOR
-from I_VALIDATOR import ValError,listProto
+from . import I_OBJECT
+from . import CONNECTOR
+from .I_VALIDATOR import ValError,listProto
class MCSIMP(I_OBJECT.OBJECT):
if self.valeur == None :
return None
- elif type(self.valeur) == types.FloatType :
+ elif type(self.valeur) == float :
# Traitement d'un flottant isole
txt = str(self.valeur)
clefobj=self.GetNomConcept()
- if self.jdc.appli.appliEficas.dict_reels.has_key(clefobj):
- if self.jdc.appli.appliEficas.dict_reels[clefobj].has_key(self.valeur):
+ if clefobj in self.jdc.appli.appliEficas.dict_reels :
+ if self.valeur in self.jdc.appli.appliEficas.dict_reels[clefobj]:
txt=self.jdc.appli.appliEficas.dict_reels[clefobj][self.valeur]
- elif type(self.valeur) in (types.ListType,types.TupleType) :
+ elif type(self.valeur) in (list,tuple) :
if self.valeur==[] or self.valeur == (): return str(self.valeur)
# Traitement des listes
txt='('
sep=''
for val in self.valeur:
- if type(val) == types.FloatType :
+ if type(val) == float :
clefobj=self.GetNomConcept()
- if self.jdc.appli.appliEficas.dict_reels.has_key(clefobj):
- if self.jdc.appli.appliEficas.dict_reels[clefobj].has_key(val):
+ if clefobj in self.jdc.appli.appliEficas.dict_reels:
+ if val in self.jdc.appli.appliEficas.dict_reels[clefobj]:
txt=txt + sep +self.jdc.appli.appliEficas.dict_reels[clefobj][val]
else :
txt=txt + sep + str(val)
else :
txt=txt + sep + str(val)
else:
- if isinstance(val,types.TupleType):
+ if isinstance(val,tuple):
texteVal='('
for i in val :
- if isinstance(i, types.StringType) : texteVal = texteVal +"'"+str(i)+"',"
+ if isinstance(i, bytes) : texteVal = texteVal +"'"+str(i)+"',"
else : texteVal = texteVal + str(i)+','
texteVal=texteVal[:-1]+')'
else :
- if isinstance(val,types.StringType): texteVal="'"+str(val)+"'"
+ if isinstance(val,bytes): texteVal="'"+str(val)+"'"
else :texteVal=str(val)
txt = txt + sep+ texteVal
## break
sep=','
# cas des listes de tuples de longueur 1
- if isinstance(val,types.TupleType) and len(self.valeur) == 1 : txt=txt+','
+ if isinstance(val,tuple) and len(self.valeur) == 1 : txt=txt+','
txt=txt+')'
else:
# Traitement des autres cas
Retourne une chaine de caractere representant la valeur de self
"""
val=self.valeur
- if type(val) == types.FloatType :
+ if type(val) == float :
clefobj=self.GetNomConcept()
- if self.jdc.appli.appliEficas.dict_reels.has_key(clefobj):
- if self.jdc.appli.appliEficas.appliEficas.dict_reels[clefobj].has_key(val):
+ if clefobj in self.jdc.appli.appliEficas.dict_reels :
+ if val in self.jdc.appli.appliEficas.appliEficas.dict_reels[clefobj] :
return self.jdc.appli.appliEficas.dict_reels[clefobj][val]
- if type(val) != types.TupleType :
+ if type(val) != tuple :
try:
return val.get_name()
except:
try :
s=s+item.get_name()+','
except:
- s=s+`item`+','
+ s=s+repr(item)+','
s=s+' )'
return s
def wait_bool(self):
for typ in self.definition.type:
try :
- if typ == types.BooleanType: return True
+ if typ == bool: return True
except :
pass
return False
qui n'existe pas encore (type CO()), 0 sinon
"""
for typ in self.definition.type:
- if type(typ) == types.ClassType or isinstance(typ,type):
+ if type(typ) == type or isinstance(typ,type):
if issubclass(typ,CO) :
return 1
return 0
ou derive, 0 sinon
"""
for typ in self.definition.type:
- if type(typ) == types.ClassType or isinstance(typ,type):
+ if type(typ) == type or isinstance(typ,type):
if issubclass(typ,ASSD) and not issubclass(typ,GEOM):
return 1
return 0
Retourne 0 dans le cas contraire
"""
for typ in self.definition.type:
- if type(typ) == types.ClassType or isinstance(typ,type):
+ if type(typ) == type or isinstance(typ,type):
if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
return 1
return 0
Retourne 0 dans le cas contraire
"""
for typ in self.definition.type:
- if type(typ) == types.ClassType or isinstance(typ,type):
+ if type(typ) == type or isinstance(typ,type):
if issubclass(typ,GEOM) : return 1
return 0
"""
if self.valeur == None:
return []
- elif type(self.valeur) == types.TupleType:
+ elif type(self.valeur) == tuple:
return list(self.valeur)
- elif type(self.valeur) == types.ListType:
+ elif type(self.valeur) == list:
return self.valeur
else:
return [self.valeur]
if new_valeur in ('True','False') and 'TXM' in self.definition.type :
valeur=self.eval_val_item(str(new_valeur))
return new_valeur
- if type(new_valeur) in (types.ListType,types.TupleType):
+ if type(new_valeur) in (list,tuple):
valeurretour=[]
for item in new_valeur :
valeurretour.append(self.eval_val_item(item))
return None
def update_concept(self,sd):
- if type(self.valeur) in (types.ListType,types.TupleType) :
+ if type(self.valeur) in (list,tuple) :
if sd in self.valeur:
self.init_modif()
self.fin_modif()
du concept sd
Attention aux matrices
"""
- if type(self.valeur) == types.TupleType :
+ if type(self.valeur) == tuple :
if sd in self.valeur:
self.init_modif()
self.valeur=list(self.valeur)
self.valeur.remove(sd)
self.fin_modif()
- elif type(self.valeur) == types.ListType:
+ elif type(self.valeur) == list:
if sd in self.valeur:
self.init_modif()
self.valeur.remove(sd)
du concept old_sd
"""
#print "replace_concept",old_sd,sd
- if type(self.valeur) == types.TupleType :
+ if type(self.valeur) == tuple :
if old_sd in self.valeur:
self.init_modif()
self.valeur=list(self.valeur)
i=self.valeur.index(old_sd)
self.valeur[i]=sd
self.fin_modif()
- elif type(self.valeur) == types.ListType:
+ elif type(self.valeur) == list:
if old_sd in self.valeur:
self.init_modif()
i=self.valeur.index(old_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_sd_avant_etape = list(self.jdc.get_contexte_avant(self.etape).values())
+ if type(self.valeur) in (tuple,list) :
l=[]
for sd in self.valeur:
if isinstance(sd,ASSD) :
if cr == "oui" : self.cr.fatal(tr("La matrice n'a pas le bon entete"))
return 0
if self.monType.methodeCalculTaille != None :
- apply (MCSIMP.__dict__[self.monType.methodeCalculTaille],(self,))
+ MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,))
try :
#if 1 :
ok=0
#
"""
"""
-import string
+from __future__ import absolute_import
import Noyau
-import CONNECTOR
+from . import CONNECTOR
class OBJECT:
from Noyau.N_CO import CO
def get_genealogie_precise(self):
if self.parent:
l=self.parent.get_genealogie_precise()
- l.append(string.strip(self.nom))
+ l.append(self.nom.strip())
return l
else:
- return [string.strip(self.nom)]
+ return [self.nom.strip()]
def get_genealogie(self):
"""
"""
if self.parent:
l=self.parent.get_genealogie()
- l.append(string.strip(self.nom))
+ l.append(self.nom.strip())
return l
else:
- return [string.strip(self.nom)]
+ return [self.nom.strip()]
def get_fr(self):
"""
"""
try:
#if 1 :
- return getattr(self.definition,self.jdc.lang)
+ c=getattr(self.definition,self.jdc.lang).decode('latin-1','ignore')
+ return c
except:
#else:
try :
- return getattr(self.definition,"fr")
+ c=getattr(self.definition,"fr").decode('latin-1','ignore')
+ return c
except :
return ''
"""
"""
-import I_REGLE
+from __future__ import absolute_import
+from . import I_REGLE
class PRESENT_ABSENT(I_REGLE.REGLE):
def purge_liste(self,liste_a_purger,liste_mc_presents):
"""
"""
-import I_REGLE
+from __future__ import absolute_import
+from . import I_REGLE
class PRESENT_PRESENT(I_REGLE.REGLE):
def verif_condition_regle(self,liste,l_mc_presents):
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import I_ETAPE
+from __future__ import absolute_import
+from . import I_ETAPE
-# import rajoutés suite à l'ajout de Build_sd --> à résorber
+# import rajoutes suite a l'ajout de Build_sd --> a resorber
import sys
-import traceback,types,string
+import traceback,types
import Noyau
from Noyau import N_Exception
from Noyau.N_Exception import AsException
def delete_concept(self,sd):
"""
Fonction : Mettre a jour les mots cles de l etape
- suite à la disparition du concept sd
+ suite a la disparition du concept sd
Seuls les mots cles simples MCSIMP font un traitement autre
que de transmettre aux fils
suite au remplacement du concept old_sd
Inputs :
- - old_sd=concept remplacé
+ - old_sd=concept remplace
- sd=nouveau concept
"""
for child in self.mc_liste :
except AsException :
# Une erreur s'est produite lors de la construction du concept
# Comme on est dans EFICAS, on essaie de poursuivre quand meme
- # Si on poursuit, on a le choix entre deux possibilités :
- # 1. on annule la sd associée à self
+ # Si on poursuit, on a le choix entre deux possibilites :
+ # 1. on annule la sd associee a self
# 2. on la conserve mais il faut la retourner
# En plus il faut rendre coherents sdnom et sd.nom
self.sd=None
#
"""
"""
-import string
+from __future__ import absolute_import
class REGLE:
def gettext(self):
text = self.__class__.__name__+ ' :\n'
for mc in self.mcs :
- text = text + '\t' + string.strip(mc) + '\n'
+ text = text + '\t' + mc.strip() + '\n'
return text
def purge_liste(self,liste_a_purger,liste_mc_presents):
"""
- Cette méthode doit retirer de la liste liste_a_purger
- les éléments qui ne doivent plus apparaitre en fonction du contexte
+ Cette methode doit retirer de la liste liste_a_purger
+ les elements qui ne doivent plus apparaitre en fonction du contexte
"""
- # Dans le cas général on ne touche pas à la liste
+ # Dans le cas general on ne touche pas a la liste
return liste_a_purger
def has_operande(self,nom):
"""
"""
-import I_REGLE
+from __future__ import absolute_import
+from . import I_REGLE
class UN_PARMI(I_REGLE.REGLE):
break
if not regle_active : return liste_a_purger
- # Si un des mots clés est présent, on les enlève tous
+ # Si un des mots cles est present, on les enleve tous
# sauf celui ci
for mc in self.mcs:
if mc in liste_a_purger and mc not in liste_mc_presents:
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Noyau.N_VALIDATOR import *
class Compulsory(Compulsory):
class OrdList(OrdList):
def valide_liste_partielle(self,liste_courante=None):
"""
- Méthode de validation de liste partielle pour le validateur OrdList
+ Methode de validation de liste partielle pour le validateur OrdList
"""
try:
self.convert(liste_courante)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce package contient les fonctionnalités supplémentaires nécessaires
- pour l'éditeur graphique EFICAS
+ Ce package contient les fonctionnalites supplementaires necessaires
+ pour l'editeur graphique EFICAS
"""
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import string,re
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+except : pass
+import re
import types,sys,os
import traceback
-import typeNode
+from . import typeNode
#import pdb
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QTreeWidget , QTreeWidgetItem,QApplication
- from PyQt5.QtGui import QIcon
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+import six
+from six.moves import range
+from PyQt5.QtWidgets import QTreeWidget , QTreeWidgetItem, QApplication, QMessageBox
+from PyQt5.QtGui import QIcon
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
-from gereRegles import GereRegles
-from monChoixCommande import MonChoixCommande
+from .gereRegles import GereRegles
+from .monChoixCommande import MonChoixCommande
class JDCTree( QTreeWidget,GereRegles ):
def __init__( self, jdc_item, QWParent):
self.itemCourrant=None
- if monEnvQT5 :
- self.itemClicked.connect(self.handleOnItem)
- self.itemCollapsed.connect(self.handleCollapsedItem)
- self.itemExpanded.connect(self.handleExpandedItem)
- else :
- self.connect(self, SIGNAL("itemClicked ( QTreeWidgetItem * ,int) "), self.handleOnItem)
- self.connect(self, SIGNAL("itemCollapsed ( QTreeWidgetItem *) "), self.handleCollapsedItem)
- self.connect(self, SIGNAL("itemExpanded ( QTreeWidgetItem *) "), self.handleExpandedItem)
+ self.itemClicked.connect(self.handleOnItem)
+ self.itemCollapsed.connect(self.handleCollapsedItem)
+ self.itemExpanded.connect(self.handleExpandedItem)
#PNPNPN verifier dans quel cas on se trouve : affiche l arbre ou la commande
self.node_selected=self.racine
self.inhibeExpand=False
#print "self.editor.afficheCommandesPliees", self.editor.afficheCommandesPliees
if self.racine.children !=[] :
- self.editor.initSplitterSizes(3)
+ #self.editor.initSplitterSizes(3)
if self.editor.afficheCommandesPliees : self.racine.children[0].plieToutEtReaffiche()
else : self.racine.children[0].deplieToutEtReaffiche()
self.racine.children[0].fenetre.donnePremier()
else :
- self.editor.initSplitterSizes(2)
+ #self.editor.initSplitterSizes(2)
self.racine.affichePanneau()
#print self.editor.splitter.sizes()
#PNPNPN
try :
fr = item.item.get_fr()
- if self.editor: self.editor.affiche_commentaire(unicode(fr))
+ if self.editor: self.editor.affiche_commentaire(six.text_type(fr))
except:
pass
item.select()
value = tr(str( item.GetText() ) )
- if monEnvQT5:
- if self.editor.enteteQTree=='complet':mesColonnes=(name,value)
- else : mesColonnes=(name,)
- else :
- mesColonnes=QStringList()
- if self.editor.enteteQTree=='complet': mesColonnes << name << value
- else : mesColonnes << name
+ if self.editor.enteteQTree=='complet':mesColonnes=(name,value)
+ else : mesColonnes=(name,)
if self.treeParent.plie==True :
self.plie = True
else :
QTreeWidgetItem.__init__(self,self.treeParent,mesColonnes)
- if monEnvQT5 :
- self.setToolTip(0,self.item.get_fr())
- self.setToolTip(1,self.item.get_fr())
- repIcon=self.appliEficas.repIcon
- else :
- self.setToolTip(0,QString(self.item.get_fr()))
- self.setToolTip(1,QString(self.item.get_fr()))
- repIcon=QString(self.appliEficas.repIcon)
+ self.setToolTip(0,self.item.get_fr())
+ self.setToolTip(1,self.item.get_fr())
+ repIcon=self.appliEficas.repIcon
monIcone = QIcon(repIcon+"/" +self.item.GetIconName() + ".png")
self.setIcon(0,monIcone)
# on resoudera a ce moment la
# pour l instant pas de poussiere sous le tapis
if not(self.item.isactif()) :
- from monWidgetInactif import MonWidgetInactif
+ from .monWidgetInactif import MonWidgetInactif
self.fenetre = MonWidgetInactif(self,self.editor)
else:
itemParent=self
itemParent.affichePanneau()
return
self.fenetre=self.getPanel()
- self.editor.restoreSplitterSizes()
+ #self.editor.restoreSplitterSizes()
for indiceWidget in range(self.editor.widgetCentraleLayout.count()):
widget=self.editor.widgetCentraleLayout.itemAt(indiceWidget)
self.editor.fenetreCentraleAffichee.deleteLater()
self.editor.widgetCentraleLayout.addWidget(self.fenetre)
- #print "j ajoute ", self.fenetre, self.fenetre.node.item.nom
+ #print ("j ajoute ", self.fenetre, self.fenetre.node.item.nom)
self.editor.fenetreCentraleAffichee=self.fenetre
self.tree.node_selected= self
"""
Cette methode a pour but de commentariser la commande pointee par self
"""
- # On traite par une exception le cas ou l'utilisateur final cherche a désactiver
+ # On traite par une exception le cas ou l'utilisateur final cherche a desactiver
# (commentariser) un commentaire.
try :
pos=self.treeParent.children.index(self)
if pos == 'before': index = index
elif pos == 'after': index = index +1
else:
- print unicode(pos), tr(" n'est pas un index valide pour append_brother")
+ print(six.text_type(pos), tr(" n'est pas un index valide pour append_brother"))
return 0
return self.treeParent.append_child(name,pos=index,plier=plier)
index = 0
elif pos == 'last':
index = len(self.children)
- elif type(pos) == types.IntType :
+ elif type(pos) == int :
# position fixee
index = pos
elif type(pos) == types.InstanceType:
if noeud.treeParent.children.index(noeud) < index : index=noeud.treeParent.children.index(noeud)
if index < 0 : index =0
- # Cas ou on détruit dans une ETape
+ # Cas ou on detruit dans une ETape
if index == 9999 :
parentPosition=self.treeParent
while not(isinstance(parentPosition, compojdc.Node)):
"""Cette methode remet a jour la validite du noeud (icone)
Elle appelle isvalid
"""
- if monEnvQT5 : repIcon=self.appliEficas.repIcon
- else : repIcon=QString(self.appliEficas.repIcon)
+ repIcon=self.appliEficas.repIcon
monIcone = QIcon(repIcon+"/" +self.item.GetIconName() + ".png")
self.setIcon(0,monIcone)
def update_node_label_in_blue(self):
- if hasattr(self.appliEficas,'noeudColore'):
- if monEnvQT5 :
- self.appliEficas.noeudColore.setForeground(0,Qt.black)
- else :
- self.appliEficas.noeudColore.setTextColor( 0,Qt.black)
- self.appliEficas.noeudColore.update_node_label()
- if monEnvQT5 :
- self.setForeground(0,Qt.blue)
- else :
- self.setTextColor( 0,Qt.blue )
+ if hasattr(self.appliEficas,'noeudColore'): self.appliEficas.noeudColore.setForeground(0,Qt.black)
+ self.setForeground(0,Qt.blue)
labeltext,fonte,couleur = self.item.GetLabelText()
self.setText(0, labeltext)
self.appliEficas.noeudColore=self
def doPaste(self,node_selected,pos='after'):
"""
- Déclenche la copie de l'objet item avec pour cible
- l'objet passé en argument : node_selected
+ Declenche la copie de l'objet item avec pour cible
+ l'objet passe en argument : node_selected
"""
#print 'je passe dans doPaste'
objet_a_copier = self.item.get_copie_objet()
def doPasteCommande(self,objet_a_copier,pos='after'):
"""
- Réalise la copie de l'objet passé en argument qui est nécessairement
+ Realise la copie de l'objet passe en argument qui est necessairement
une commande
"""
child=None
def doPastePremier(self,objet_a_copier):
"""
- Réalise la copie de l'objet passé en argument (objet_a_copier)
+ Realise la copie de l'objet passe en argument (objet_a_copier)
"""
objet = objet_a_copier.item.get_copie_objet()
child = self.append_child(objet,pos='first')
def setPlie(self):
#print "je mets inhibeExpand a true dans setPlie"
#print "je suis dans plieTout", self.item.get_nom()
- import compojdc
+ from . import compojdc
if self.fenetre == self.editor.fenetreCentraleAffichee and isinstance(self.treeParent,compojdc.Node):
return
self.tree.inhibeExpand=True
#
+from __future__ import absolute_import
from Editeur import Objecttreeitem
-import compofact
-import browser
-import typeNode
+from . import compofact
+from . import browser
+from . import typeNode
class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
maCommande=commande
if hasattr(parentQt,'niveau'): self.niveau=parentQt.niveau+1
else : self.niveau=1
- from monWidgetBloc import MonWidgetBloc
+ from .monWidgetBloc import MonWidgetBloc
widget=MonWidgetBloc(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import string
+from __future__ import absolute_import
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QAction
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QAction
from Editeur import Objecttreeitem
-import browser
-import typeNode
+from . import browser
+from . import typeNode
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
def getPanel( self ):
"""
"""
- from monWidgetCommentaire import MonWidgetCommentaire
+ from .monWidgetCommentaire import MonWidgetCommentaire
return MonWidgetCommentaire(self,self.editor,self.item.object)
def createPopUpMenu(self):
typeNode.PopUpMenuNodePartiel.createPopUpMenu(self)
self.Decommente = QAction(tr("Decommenter"),self.tree)
- if monEnvQT5 : self.Decommente.triggered(self.Decommenter)
- else : self.tree.connect(self.Decommente,SIGNAL("triggered()"),self.Decommenter)
+ self.Decommente.triggered(self.Decommenter)
self.Decommente.setStatusTip(tr("Decommente la commande "))
if hasattr(self.item,'uncomment'):
def GetIconName(self):
"""
- Retourne le nom de l'icône associée au noeud qui porte self,
- dépendant de la validité de l'objet
+ Retourne le nom de l'icone associee au noeud qui porte self,
+ dependant de la validite de l'objet
NB : un commentaire est toujours valide ...
"""
return "ast-white-percent"
def GetLabelText(self):
""" Retourne 3 valeurs :
- - le texte à afficher dans le noeud représentant l'item
+ - le texte a afficher dans le noeud representant l'item
- la fonte dans laquelle afficher ce texte
- la couleur du texte
"""
def GetText(self):
texte = self.object.valeur
- texte = string.split(texte,'\n')[0]
+ texte = texte.split('\n')[0]
if len(texte) < 25 :
return texte
else :
def set_valeur(self,valeur):
"""
- Afecte valeur à l'objet COMMENTAIRE
+ Affecte valeur a l'objet COMMENTAIRE
"""
self.object.set_valeur(valeur)
def get_objet_commentarise(self):
"""
- La méthode get_objet_commentarise() de la classe compocomm.COMMTreeItem
- surcharge la méthode get_objet_commentarise de la classe Objecttreeitem.ObjectTreeItem
+ La methode get_objet_commentarise() de la classe compocomm.COMMTreeItem
+ surcharge la methode get_objet_commentarise de la classe Objecttreeitem.ObjectTreeItem
elle a pour but d'empecher l'utilisateur final de commentariser un commentaire.
"""
raise EficasException( 'Impossible de commentariser un commentaire' )
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
import traceback
-import string
from Editeur import Objecttreeitem
from Extensions.eficas_exception import EficasException
-import compocomm
+from . import compocomm
class COMMANDE_COMMTreeItem(Objecttreeitem.ObjectTreeItem):
itemNode=compocomm.Node
def GetIconName(self):
"""
- Retourne le nom de l'icône associée au noeud qui porte self,
- dépendant de la validité de l'objet
- NB : une commande commentarisée est toujours valide ...
+ Retourne le nom de l'icone associee au noeud qui porte self,
+ dependant de la validite de l'objet
+ NB : une commande commentarisee est toujours valide ...
"""
if self.isvalid():
return "ast-green-percent"
def GetLabelText(self):
""" Retourne 3 valeurs :
- - le texte à afficher dans le noeud représentant l'item
+ - le texte a afficher dans le noeud representant l'item
- la fonte dans laquelle afficher ce texte
- la couleur du texte
"""
def get_valeur(self):
"""
- Retourne la valeur de la commande commentarisée cad son texte
+ Retourne la valeur de la commande commentarisee cad son texte
"""
return self.object.get_valeur() or ''
def GetText(self):
texte = self.object.valeur
- texte = string.split(texte,'\n')[0]
+ texte = texte.split('\n')[0]
if len(texte) < 25 :
return texte
else :
def set_valeur(self,valeur):
"""
- Afefcte valeur à l'objet commande commentarisée
+ Afefcte valeur a l'objet commande commentarisee
"""
self.object.set_valeur(valeur)
def uncomment(self):
"""
- Demande à l'objet commande commentarisée de se décommentariser.
- Si l'opération s'effectue correctement, retourne l'objet commande
- et éventuellement le nom de la sd produite, sinon lève une exception
+ Demande a l'objet commande commentarisee de se decommentariser.
+ Si l'operation s'effectue correctement, retourne l'objet commande
+ et eventuellement le nom de la sd produite, sinon leve une exception
"""
try:
commande,nom = self.object.uncomment()
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import browser
-import typeNode
+from __future__ import absolute_import
+from . import browser
+from . import typeNode
from Extensions.i18n import tr
from Editeur import Objecttreeitem
+import six
class Node(browser.JDCNode,typeNode.PopUpMenuNodePartiel):
else : self.niveau=1
#if hasattr(self,'plie') :print self.item.nom, self.plie
if hasattr(self,'plie') and self.plie==True :
- from monWidgetFactPlie import MonWidgetFactPlie
+ from .monWidgetFactPlie import MonWidgetFactPlie
widget=MonWidgetFactPlie(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
else:
- from monWidgetFact import MonWidgetFact
+ from .monWidgetFact import MonWidgetFact
widget=MonWidgetFact(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
return widget
else:
return "ast-yel-los"
- def keys(self):
- keys=self.object.mc_dict.keys()
- return keys
+ #PNPN ????
+ #def keys(self):
+ # keys=self.object.mc_dict
+ # return keys
def GetSubList(self):
"""
return (0, tr('Impossible de supprimer un mot-cle obligatoire '))
if self.object.suppentite(itemobject):
- message = tr("Mot-cle %s supprime")+ unicode(itemobject.nom)
+ message = tr("Mot-cle %s supprime")+ six.text_type(itemobject.nom)
#self.editor.affiche_commentaire(message)
return (1, message)
else:
#
"""
-Ce module contient les classes permettant de définir les objets graphiques
-représentant un objet de type FORMULE, cad le panneau et l'item de l'arbre
+Ce module contient les classes permettant de definir les objets graphiques
+representant un objet de type FORMULE, cad le panneau et l'item de l'arbre
d'EFICAS
"""
-import string
-import compooper
-import browser
-import typeNode
+from __future__ import absolute_import
+from . import compooper
+from . import browser
+from . import typeNode
class FormuleNode(browser.JDCNode,typeNode.PopUpMenuNode):
def getPanel(self):
- from monWidgetFormule import MonWidgetFormule
+ from .monWidgetFormule import MonWidgetFormule
return MonWidgetFormule(self,self.editor,self.item.object)
class FORMULETreeItem(compooper.EtapeTreeItem):
"""
- Classe servant a définir l'item porté par le noeud de l'arbre d'EFICAS
- qui représente la FORMULE
+ Classe servant a definir l'item porte par le noeud de l'arbre d'EFICAS
+ qui represente la FORMULE
"""
itemNode=FormuleNode
def GetSubList(self):
"""
Retourne la liste des fils de self
- On considére que FORMULE n'a pas de fils
+ On considere que FORMULE n'a pas de fils
--> modification par rapport a MACRO classique
"""
- # dans EFICAS on ne souhaite pas afficher les mots-clés fils de FORMULE
- # de façon traditionnelle
+ # dans EFICAS on ne souhaite pas afficher les mots-cles fils de FORMULE
+ # de facon traditionnelle
return []
def GetIconName(self):
"""
- Retourne le nom de l'icone à afficher dans l'arbre
- Ce nom dépend de la validité de l'objet
+ Retourne le nom de l'icone a afficher dans l'arbre
+ Ce nom depend de la validite de l'objet
"""
if self.object.isactif():
if self.object.isvalid():
def GetLabelText(self):
""" Retourne 3 valeurs :
- - le texte a afficher dans le noeud représentant l'item
+ - le texte a afficher dans le noeud representant l'item
- la fonte dans laquelle afficher ce texte
- la couleur du texte
"""
return self.labeltext,None,None
#if self.object.isactif():
- # None --> fonte et couleur par défaut
+ # None --> fonte et couleur par defaut
# return tr(self.labeltext),None,None
#else:
# return tr(self.labeltext),None,None
#return self.labeltext,fontes.standard_italique,None
# ---------------------------------------------------------------------------
-# Méthodes permettant la modification et la lecture des attributs
-# du paramètre = API graphique de la FORMULE pour Panel et EFICAS
+# Methodes permettant la modification et la lecture des attributs
+# du parametre = API graphique de la FORMULE pour Panel et EFICAS
# ---------------------------------------------------------------------------
def get_nom(self):
def get_type(self):
"""
- Retourne le type de la valeur retournée par la FORMULE
+ Retourne le type de la valeur retournee par la FORMULE
"""
return self.object.type_retourne
if args :
if args[0] == "(" and args[-1] ==")":
args=args[1:-1]
- # transforme en tuple si ce n est pas déja le casa
+ # transforme en tuple si ce n est pas deja le casa
try :
- args=string.split(args,',')
+ args=args.split(',')
except :
pass
return args
def save_formule(self,new_nom,new_typ,new_arg,new_exp):
"""
- Vérifie si (new_nom,new_typ,new_arg,new_exp) définit bien une FORMULE
+ Verifie si (new_nom,new_typ,new_arg,new_exp) definit bien une FORMULE
licite :
- - si oui, stocke ces paramètres comme nouveaux paramètres de la
+ - si oui, stocke ces parametres comme nouveaux parametres de la
FORMULE courante et retourne 1
- - si non, laisse les paramètres anciens de la FORMULE inchangés et
+ - si non, laisse les parametres anciens de la FORMULE inchanges et
retourne 0
"""
test,erreur = self.object.verif_formule_python(formule=(new_nom,new_typ,new_arg,
new_exp))
if test :
- # la formule est bien correcte : on sauve les nouveaux paramètres
+ # la formule est bien correcte : on sauve les nouveaux parametres
test=self.object.update_formule_python(formule=(new_nom,new_typ,new_exp,new_arg))
return test,erreur
# ---------------------------------------------------------------------------
-# Accès aux méthodes de vérification de l'objet FORM_ETAPE
+# Acces aux methodes de verification de l'objet FORM_ETAPE
# ---------------------------------------------------------------------------
def verif_nom(self,nom):
"""
- Lance la vérification du nom passé en argument
+ Lance la verification du nom passe en argument
"""
return self.object.verif_nom(nom)
def verif_arguments(self,arguments):
"""
- Lance la vérification des arguments passés en argument
+ Lance la verification des arguments passes en argument
"""
return self.object.verif_arguments('('+arguments+')')
def verif_formule(self,formule):
"""
- Lance la vérification de FORMULE passée en argument
+ Lance la verification de FORMULE passee en argument
"""
return self.object.verif_formule(formule=formule)
def verif_formule_python(self,formule):
"""
- Lance la vérification de FORMULE passée en argument
+ Lance la verification de FORMULE passee en argument
"""
return self.object.verif_formule_python(formule=formule)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Editeur import Objecttreeitem
-import browser
-import typeNode
+from . import browser
+from . import typeNode
from Extensions.i18n import tr
class Node(browser.JDCNode,typeNode.PopUpMenuRacine):
def getPanel(self):
- from monChoixCommande import MonChoixCommande
+ from .monChoixCommande import MonChoixCommande
return MonChoixCommande(self,self.item, self.editor)
else:
return "ast-red-square"
- def keys(self):
- if self.object.etapes_niveaux != []:
- return range(len(self.object.etapes_niveaux))
- else:
- return range(len(self.object.etapes))
+ #def keys(self):
+ # if self.object.etapes_niveaux != []:
+ # return range(len(self.object.etapes_niveaux))
+ # else:
+ # return range(len(self.object.etapes))
def additem(self,name,pos):
cmd = self._object.addentite(name,pos)
#
# Modules Python
-import os,sys,string
+from __future__ import absolute_import
+import os,sys
import types
import traceback
# Modules Eficas
from Editeur import Objecttreeitem
from Extensions.i18n import tr
-import compooper
-import browser
-import typeNode
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QAction
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from . import compooper
+from . import browser
+from . import typeNode
+from PyQt5.QtWidgets import QAction
+from PyQt5.QtCore import Qt
class MACRONode(browser.JDCNode,typeNode.PopUpMenuNode):
def getPanel(self):
- from monWidgetCommande import MonWidgetCommande
+ from .monWidgetCommande import MonWidgetCommande
return MonWidgetCommande (self,self.editor ,self.item.object)
typeNode.PopUpMenuNode.createPopUpMenu(self)
if ("AFFE_CARA_ELEM" in self.item.get_genealogie()) and self.editor.salome:
self.ViewElt = QAction(tr('View3D'),self.tree)
- if monEnvQT5:
- self.ViewElt.triggered.connect(self.view3D)
- else :
- self.tree.connect(self.ViewElt,SIGNAL("triggered()"),self.view3D)
+ self.ViewElt.triggered.connect(self.view3D)
self.ViewElt.setStatusTip(tr("affiche dans Geom les elements de structure"))
self.menu.addAction(self.ViewElt)
if self.item.isvalid() :
class MACROTreeItem(compooper.EtapeTreeItem):
-# """ Cette classe hérite d'une grande partie des comportements
+# """ Cette classe herite d'une grande partie des comportements
# de la classe compooper.EtapeTreeItem
# """
itemNode=MACRONode
class INCLUDENode(browser.JDCNode,typeNode.PopUpMenuNode):
def getPanel(self):
- from monWidgetCommande import MonWidgetCommande
+ from .monWidgetCommande import MonWidgetCommande
return MonWidgetCommande (self,self.editor ,self.item.object)
def createPopUpMenu(self):
# ------------------------------------
-# Classes necessaires à POURSUITE
+# Classes necessaires a POURSUITE
# ------------------------------------
class POURSUITENode(browser.JDCNode, typeNode.PopUpMenuNode):
def getPanel(self):
- from monWidgetCommande import MonWidgetCommande
+ from .monWidgetCommande import MonWidgetCommande
return MonWidgetCommande (self,self.editor ,self.item.object)
def createPopUpMenu(self):
class MATERIAUNode(MACRONode):
def getPanel(self):
- from monWidgetCommande import MonWidgetCommande
+ from .monWidgetCommande import MonWidgetCommande
return MonWidgetCommande (self,self.editor ,self.item.object)
def createPopUpMenu(self):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
import types
import traceback
-import compofact
-import browser
-import typeNode
+from . import compofact
+from . import browser
+from . import typeNode
from Extensions.i18n import tr
from Editeur import Objecttreeitem
else : self.niveau=1
if not (monObjet.isMCList()) :
if hasattr(self,'plie') and self.plie==True :
- from monWidgetFactPlie import MonWidgetFactPlie
+ from .monWidgetFactPlie import MonWidgetFactPlie
widget=MonWidgetFactPlie(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
else:
- from monWidgetFact import MonWidgetFact
+ from .monWidgetFact import MonWidgetFact
widget=MonWidgetFact(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
else :
- from monWidgetBloc import MonWidgetBloc
+ from .monWidgetBloc import MonWidgetBloc
widget=MonWidgetBloc(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
return widget
# else:
# QMessageBox.information( self, "Copie impossible",
- # "Vous ne pouvez coller le mot-clé facteur copié à ce niveau de l'arborescence !")
- # self.editor.affiche_infos("Copie refusée")
+ # "Vous ne pouvez coller le mot-cle facteur copie a ce niveau de l'arborescence !")
+ # self.editor.affiche_infos("Copie refusee")
# return child
class MCListTreeItem(Objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
""" La classe MCListTreeItem joue le role d'un adaptateur pour les objets
du noyau Accas instances de la classe MCLIST.
- Elle adapte ces objets pour leur permettre d'etre intégrés en tant que
+ Elle adapte ces objets pour leur permettre d'etre integres en tant que
noeuds dans un arbre graphique (voir treewidget.py et ObjectTreeItem.py).
- Cette classe délègue les appels de méthode et les accès
- aux attributs à l'objet du noyau soit manuellement soit
+ Cette classe delegue les appels de methode et les acces
+ aux attributs a l'objet du noyau soit manuellement soit
automatiquement (voir classe Delegate et attribut object).
"""
itemNode=Node
def panel(self,jdcdisplay,pane,node):
""" Retourne une instance de l'objet panneau associe a l'item (self)
- Si la liste ne contient qu'un mot clé facteur, on utilise le panneau
+ Si la liste ne contient qu'un mot cle facteur, on utilise le panneau
FACTPanel.
Si la liste est plus longue on utilise le panneau MCLISTPanel.
"""
return "ast-yel-los"
def get_docu(self):
- """ Retourne la clef de doc de l'objet pointé par self """
+ """ Retourne la clef de doc de l'objet pointe par self """
return self.object.get_docu()
def iscopiable(self):
def isMCFact(self):
"""
- Retourne 1 si l'objet pointé par self est un MCFact, 0 sinon
+ Retourne 1 si l'objet pointe par self est un MCFact, 0 sinon
"""
return len(self._object) <= 1
def isMCList(self):
"""
- Retourne 1 si l'objet pointé par self est une MCList, 0 sinon
+ Retourne 1 si l'objet pointe par self est une MCList, 0 sinon
"""
return len(self._object) > 1
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
import os
import tempfile
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QMessageBox, QAction, QApplication
- from PyQt5.QtGui import QCursor
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QMessageBox, QAction, QApplication
+from PyQt5.QtGui import QCursor
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
from Editeur import Objecttreeitem
-import browser
-import typeNode
+from . import browser
+from . import typeNode
class Node(browser.JDCNode, typeNode.PopUpMenuNode):
self.editor.affiche_commentaire(tr("Nommage du concept effectue"))
self.onValid()
try :
- self.fenetre.LENom.setText(nom)
+ self.fenetre.LENom.setText(nom)
except :
- pass
+ pass
def getPanel(self):
- from monWidgetCommande import MonWidgetCommande
+ from .monWidgetCommande import MonWidgetCommande
return MonWidgetCommande(self,self.editor,self.item.object)
def createPopUpMenu(self):
self.ViewElt.setStatusTip(tr("affiche dans Geom les elements de structure"))
self.menu.addAction(self.ViewElt)
if self.item.isvalid() :
- self.ViewElt.setEnabled(1)
+ self.ViewElt.setEnabled(1)
else:
- self.ViewElt.setEnabled(0)
+ self.ViewElt.setEnabled(0)
if self.item.get_nom() == "DISTRIBUTION" :
self.Graphe = QAction(tr('Graphique'),self.tree)
- if monEnvQT5 : self.Graphe.triggered.connect(self.viewPng)
- else : self.tree.connect(self.Graphe,SIGNAL("triggered()"),self.viewPng)
+ self.Graphe.triggered.connect(self.viewPng)
self.Graphe.setStatusTip(tr("affiche la distribution "))
self.menu.addAction(self.Graphe)
if self.item.isvalid() :
- self.Graphe.setEnabled(1)
+ self.Graphe.setEnabled(1)
else:
- self.Graphe.setEnabled(0)
+ self.Graphe.setEnabled(0)
def view3D(self) :
from Editeur import TroisDPal
g = generator.plugins[self.appliEficas.format_fichier]()
g.gener(self.item.object, format='beautifie')
stdGener = g.getGenerateur()
- loi = g.dictMCLois.keys()[0]
+ loi = list(g.dictMCLois.keys())[0]
nomLoi = loi.get_name()
(fd, fichier) = tempfile.mkstemp(prefix = "openturns_graph_", suffix = ".png")
os.close(fd)
script = stdGener.GraphiquePDF(loi, chemin, base)
#print script
d = {}
- exec script in d
+ exec(script, d)
widgetPng=MonLabelPixmap(self.appliEficas,fichier,nomLoi)
os.remove(fichier)
QApplication.restoreOverrideCursor()
except:
return ''
- def keys(self):
- keys=self.object.mc_dict.keys()
- return keys
+ # PNPN ????
+ #def keys(self):
+ # keys=self.object.mc_dict
+ # return keys
def GetSubList(self):
"""
oldnom=self.object.sd.nom
test,mess= self.object.nomme_sd(nom)
if test:self.object.parent.reset_context()
- if (test and self.appli.dict_reels.has_key(oldnom) ):
+ if (test and oldnom in self.appli.dict_reels ):
self.appli.dict_reels[nom]=self.appli.dict_reels[oldnom]
return test,mess
Cette méthode retourne un objet commentarisé
représentatif de self.object
"""
- import generator,string,Accas
+ import generator,Accas
# Format de fichier utilisé
format=self.appli.appliEficas.format_fichier
g=generator.plugins[format]()
texte_commande = g.gener(self.object,format='beautifie')
# Il faut enlever la premiere ligne vide de texte_commande que
# rajoute le generator
- rebut,texte_commande = string.split(texte_commande,'\n',1)
+ rebut,texte_commande = texte_commande.split('\n',1)
# on construit l'objet COMMANDE_COMM repésentatif de self mais non
# enregistré dans le jdc
commande_comment = Accas.COMMANDE_COMM(texte=texte_commande,reg='non',
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient les classes permettant de définir les objets graphiques
- représentant un objet de type PARAMETRE, cad le panneau et l'item de l'arbre
+ Ce module contient les classes permettant de definir les objets graphiques
+ representant un objet de type PARAMETRE, cad le panneau et l'item de l'arbre
d'EFICAS
"""
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
# import modules Python
-import string, types
+import types
from Extensions.i18n import tr
# import modules EFICAS
from Editeur import Objecttreeitem
-import browser
-import typeNode
+from . import browser
+from . import typeNode
class Node(browser.JDCNode,typeNode.PopUpMenuNodePartiel):
def getPanel(self):
"""
"""
- from monWidgetParam import MonWidgetParam
+ from .monWidgetParam import MonWidgetParam
return MonWidgetParam(self, self.editor,self.item.object)
def createPopUpMenu(self):
class PARAMTreeItem(Objecttreeitem.ObjectTreeItem):
"""
- Classe servant à définir l'item porté par le noeud de l'arbre d'EFICAS
- qui représente le PARAMETRE
+ Classe servant a definir l'item porte par le noeud de l'arbre d'EFICAS
+ qui represente le PARAMETRE
"""
itemNode=Node
def GetIconName(self):
"""
- Retourne le nom de l'icone associée au noeud qui porte self,
- dépendant de la validité de l'objet
+ Retourne le nom de l'icone associee au noeud qui porte self,
+ dependant de la validite de l'objet
NB : un PARAMETRE est toujours valide ...
"""
if self.isactif():
def GetLabelText(self):
""" Retourne 3 valeurs :
- - le texte à afficher dans le noeud représentant l'item
+ - le texte a afficher dans le noeud representant l'item
- la fonte dans laquelle afficher ce texte
- la couleur du texte
"""
def GetText(self):
"""
- Retourne le texte à afficher aprês le nom de la commande (ici apres 'parametre')
- Ce texte est tronqué à 25 caractêres
+ Retourne le texte a afficher apres le nom de la commande (ici apres 'parametre')
+ Ce texte est tronque a 25 caracteres
"""
texte=self.object.nom+"="+str(self.object.valeur)
- if type(self.object.valeur) == types.ListType :
+ if type(self.object.valeur) == list :
texte=self.nom+' = ['
for l in self.object.valeur :
texte=texte+str(l) +","
texte=texte[0:-1]+']'
- texte = string.split(texte,'\n')[0]
+ texte = texte.split('\n')[0]
if len(texte) < 25 :
return texte
else :
return []
# ---------------------------------------------------------------------------
-# Méthodes permettant la modification et la lecture des attributs
+# Methodes permettant la modification et la lecture des attributs
# du parametre = API graphique du PARAMETRE pour Panel et EFICAS
# ---------------------------------------------------------------------------
def set_valeur(self,new_valeur):
"""
- Affecte valeur à l'objet PARAMETRE
+ Affecte valeur a l'objet PARAMETRE
"""
self.object.set_valeur(new_valeur)
def get_fr(self):
"""
- Retourne le fr associé au parametre, cad la bulle d'aide pour EFICAS
+ Retourne le fr associe au parametre, cad la bulle d'aide pour EFICAS
"""
return tr("Definition d'un parametre")
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
from Editeur import Objecttreeitem
-import compooper
-import browser
-import typeNode
+from . import compooper
+from . import browser
+from . import typeNode
class Node(browser.JDCNode,typeNode.PopUpMenuNode):
def getPanel(self):
#print "getPanel de compoproc"
- from monWidgetCommande import MonWidgetCommande
+ from .monWidgetCommande import MonWidgetCommande
return MonWidgetCommande(self,self.editor,self.item.object)
def createPopUpMenu(self):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except : pass
+
+import types,os
from copy import copy,deepcopy
import traceback
-import typeNode
+from . import typeNode
# Modules Eficas
from Editeur import Objecttreeitem
-import browser
+from . import browser
from Noyau.N_CR import justify_text
from Accas import SalomeEntry
# label informatif
if monObjet.isInformation():
- from monWidgetInfo import MonWidgetInfo
+ from .monWidgetInfo import MonWidgetInfo
widget=MonWidgetInfo(self,maDefinition,monNom,monObjet,parentQt,maCommande)
self.widget=widget
return widget
# a gerer comme dans composimp
# Gestion des matrices
if self.item.wait_matrice ():
- from monWidgetMatrice import MonWidgetMatrice
+ from .monWidgetMatrice import MonWidgetMatrice
widget=MonWidgetMatrice(self,maDefinition,monNom,monObjet,parentQt,maCommande)
self.widget=widget
return widget
# A verifier
if maDefinition.into != [] and maDefinition.into != None:
if len(maDefinition.into) < 4 :
- from monWidgetRadioButton import MonWidgetRadioButton
+ from .monWidgetRadioButton import MonWidgetRadioButton
widget=MonWidgetRadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif len(maDefinition.into) < 7 :
- from monWidget4a6RadioButton import MonWidget4a6RadioButton
+ from .monWidget4a6RadioButton import MonWidget4a6RadioButton
widget=MonWidget4a6RadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
- from monWidgetCB import MonWidgetCB
+ from .monWidgetCB import MonWidgetCB
widget=MonWidgetCB(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.wait_bool() :
- from monWidgetSimpBool import MonWidgetSimpBool
+ from .monWidgetSimpBool import MonWidgetSimpBool
widget=MonWidgetSimpBool(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.wait_fichier():
- from monWidgetSimpFichier import MonWidgetSimpFichier
+ from .monWidgetSimpFichier import MonWidgetSimpFichier
widget=MonWidgetSimpFichier(self,maDefinition,monNom,monObjet,parentQt,maCommande)
# PNPNPN - a faire
elif self.item.wait_date():
- from monWidgetDate import MonWidgetDate
+ from .monWidgetDate import MonWidgetDate
widget=MonWidgetDate(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.wait_heure():
- from monWidgetHeure import MonWidgetHeure
+ from .monWidgetHeure import MonWidgetHeure
widget=MonWidgetHeure(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.wait_tuple() :
if self.item.object.definition.type[0].ntuple == 2:
- from monWidgetSimpTuple2 import MonWidgetSimpTuple2
+ from .monWidgetSimpTuple2 import MonWidgetSimpTuple2
widget=MonWidgetSimpTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.object.definition.type[0].ntuple == 3 :
- from monWidgetSimpTuple3 import MonWidgetSimpTuple3
+ from .monWidgetSimpTuple3 import MonWidgetSimpTuple3
widget=MonWidgetSimpTuple3(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
print ("Pas de Tuple de longueur > 3")
print ("Prevenir la maintenance ")
elif self.item.wait_complex():
- from monWidgetSimpComplexe import MonWidgetSimpComplexe
+ from .monWidgetSimpComplexe import MonWidgetSimpComplexe
widget=MonWidgetSimpComplexe(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.wait_co():
if len(self.item.get_sd_avant_du_bon_type()) == 0 :
- from monWidgetUniqueSDCO import MonWidgetUniqueSDCO
+ from .monWidgetUniqueSDCO import MonWidgetUniqueSDCO
widget=MonWidgetUniqueSDCO(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
- from monWidgetSDCOInto import MonWidgetSDCOInto
+ from .monWidgetSDCOInto import MonWidgetSDCOInto
widget=MonWidgetSDCOInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.wait_assd():
if len(self.item.get_sd_avant_du_bon_type()) == 0 :
- from monWidgetVide import MonWidgetVide
+ from .monWidgetVide import MonWidgetVide
widget=MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
if len(self.item.get_sd_avant_du_bon_type()) < 4 :
- from monWidgetRadioButton import MonWidgetRadioButtonSD
+ from .monWidgetRadioButton import MonWidgetRadioButtonSD
widget=MonWidgetRadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif len(self.item.get_sd_avant_du_bon_type()) < 7 :
- from monWidget4a6RadioButton import MonWidget4a6RadioButtonSD
+ from .monWidget4a6RadioButton import MonWidget4a6RadioButtonSD
widget=MonWidget4a6RadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
- from monWidgetCB import MonWidgetCBSD
+ from .monWidgetCB import MonWidgetCBSD
widget=MonWidgetCBSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.wait_Salome() and self.editor.salome:
- # Pas fait
- from monWidgetSimpSalome import MonWidgetSimpSalome
+ from .monWidgetSimpSalome import MonWidgetSimpSalome
widget=MonWidgetSimpSalome(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.wait_TXM():
- from monWidgetSimpTxt import MonWidgetSimpTxt
+ from .monWidgetSimpTxt import MonWidgetSimpTxt
widget=MonWidgetSimpTxt(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
- from monWidgetSimpBase import MonWidgetSimpBase
+ from .monWidgetSimpBase import MonWidgetSimpBase
widget=MonWidgetSimpBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
# Gestion des listes
#widget=MonWidgetPlusieursTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
# pass
#else :
- from monWidgetPlusieursInto import MonWidgetPlusieursInto
+ from .monWidgetPlusieursInto import MonWidgetPlusieursInto
widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.wait_assd() :
- from monWidgetPlusieursASSDIntoOrdonne import MonWidgetPlusieursASSDIntoOrdonne
+ from .monWidgetPlusieursASSDIntoOrdonne import MonWidgetPlusieursASSDIntoOrdonne
widget=MonWidgetPlusieursASSDIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.wait_tuple() :
if self.item.object.definition.type[0].ntuple == 2:
- from monWidgetPlusieursTuple2 import MonWidgetPlusieursTuple2
+ from .monWidgetPlusieursTuple2 import MonWidgetPlusieursTuple2
widget=MonWidgetPlusieursTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.object.definition.type[0].ntuple == 3 :
- from monWidgetPlusieursTuple3 import MonWidgetPlusieursTuple3
+ from .monWidgetPlusieursTuple3 import MonWidgetPlusieursTuple3
widget=MonWidgetPlusieursTuple3(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
print ("Pas de Tuple de longueur > 3")
if self.item.is_list_SansOrdreNiDoublon():
if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
- from monWidgetPlusieursInto import MonWidgetPlusieursInto
+ from .monWidgetPlusieursInto import MonWidgetPlusieursInto
widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
- from monWidgetPlusieursPlie import MonWidgetPlusieursPlie
+ from .monWidgetPlusieursPlie import MonWidgetPlusieursPlie
widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
# tres vite pour le tag mais devra etre gere dans configuration
if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
- from monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
+ from .monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
widget=MonWidgetPlusieursIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
- from monWidgetPlusieursPlie import MonWidgetPlusieursPlie
+ from .monWidgetPlusieursPlie import MonWidgetPlusieursPlie
widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
#print 8
if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
- from monWidgetPlusieursBase import MonWidgetPlusieursBase
+ from .monWidgetPlusieursBase import MonWidgetPlusieursBase
widget=MonWidgetPlusieursBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
- from monWidgetPlusieursPlie import MonWidgetPlusieursPlie
+ from .monWidgetPlusieursPlie import MonWidgetPlusieursPlie
widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
self.widget=widget
try :
if "R" in self.object.definition.type:
clef=self.object.GetNomConcept()
- if self.appli.dict_reels.has_key(clef):
- if type(valeurs) == types.TupleType:
+ if clef in self.appli.dict_reels:
+ if type(valeurs) == tuple:
valeurs_reelles=[]
for val in valeurs :
- if self.appli.dict_reels[clef].has_key(val) :
+ if val in self.appli.dict_reels[clef]:
valeurs_reelles.append(self.appli.dict_reels[clef][val])
else :
valeurs_reelles.append(val)
else :
- if self.appli.dict_reels[clef].has_key(valeurs):
+ if valeurs in self.appli.dict_reels[clef]:
valeurs_reelles=self.appli.dict_reels[clef][valeurs]
valeurs=valeurs_reelles
except :
#On ne garde que les items valides
listevalideitem=[]
- if type(valeurspossibles) in (types.ListType,types.TupleType) :
+ if type(valeurspossibles) in (list,tuple) :
pass
else :
valeurspossibles=(valeurspossibles,)
return boo
def wait_Salome(self):
- type = self.object.definition.type[0]
- if 'grma' in repr(type) : return True
- if 'grno' in repr(type) : return True
- if (isinstance(type, types.ClassType) and issubclass(type, SalomeEntry)) : return True
+ monType = self.object.definition.type[0]
+ if 'grma' in repr(monType) : return True
+ if 'grno' in repr(monType) : return True
+ try :
+ if issubclass(monType, SalomeEntry) : return True
+ except :
+ pass
return False
def GetType(self):
# traite_reel
def eval_valeur(self,valeur):
- """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur de self :
- - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
- - retourne 'valeur' (chaine de caractéres) sinon
+ """ Lance l'interpretation de 'valeur' (chaine de caracteres) comme valeur de self :
+ - retourne l'objet associe si on a pu interpreter (entier, reel, ASSD,...)
+ - retourne 'valeur' (chaine de caracteres) sinon
"""
newvaleur=self.eval_val(valeur)
return newvaleur,1
def eval_valeur_BAK(self,valeur):
- """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur
+ """ Lance l'interpretation de 'valeur' (chaine 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,...)
- retourne 'valeur' (chaine de caractéres) sinon
- retourne invalide si 1 des objets du tuple l est
"""
validite=1
- if type(valeur) in (types.ListType,types.TupleType) :
+ if type(valeur) in (list,tuple) :
valeurretour=[]
for item in valeur :
newvaleur,validiteitem=self.eval_valeur_item(item)
#print "eval_valeur_item",valeurretour,validite
if validite == 0:
- if type(valeur) == types.StringType and self.object.wait_TXM():
+ if type(valeur) == bytes and self.object.wait_TXM():
essai_valeur="'" + valeur + "'"
valeurretour,validite= self.object.eval_valeur(essai_valeur)
#validite=0
# on est dans le cas ou on a évalué et ou on n'aurait pas du
if self.object.wait_TXM() :
- if type(valeurretour) != types.StringType:
+ if type(valeurretour) != bytes:
valeurretour=str(valeur)
validite=1
return valeurretour,validite
ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
ou un EVAL ...
"""
- valeur = string.strip(valeur)
+ valeur = valeur.strip()
liste_reels = self.get_sd_avant_du_bon_type()
if valeur in liste_reels:
return valeur
if valeur[0:4] == 'EVAL' :
# on a trouvé un EVAL --> on retourne directement la valeur
return valeur
- if string.find(valeur,'.') == -1 :
+ if valeur.find('.') == -1 :
# aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
if (self.is_param(valeur)):
return valeur
else:
- if string.find(valeur,'e') != -1:
+ if valeur.find('e') != -1:
# Notation scientifique ?
try :
r=eval(valeur)
-# -*- coding: utf-8 -*-\r
-# Copyright (C) 2007-2013 EDF R&D\r
-#\r
-# This library is free software; you can redistribute it and/or\r
-# modify it under the terms of the GNU Lesser General Public\r
-# License as published by the Free Software Foundation; either\r
-# version 2.1 of the License.\r
-#\r
-# This library is distributed in the hope that it will be useful,\r
-# but WITHOUT ANY WARRANTY; without even the implied warranty of\r
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
-# Lesser General Public License for more details.\r
-#\r
-# You should have received a copy of the GNU Lesser General Public\r
-# License along with this library; if not, write to the Free Software\r
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
-#\r
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com\r
-#\r
-"""\r
- Ce module sert pour charger les parametres de configuration d'EFICAS\r
-"""\r
-# Modules Python\r
-import os, sys, string, types, re\r
-import traceback\r
-from determine import monEnvQT5\r
-if monEnvQT5 :\r
- from PyQt5.QtWidgets import QMessageBox\r
-else :\r
- from PyQt4.QtGui import QMessageBox\r
-from Editeur.utils import read_file\r
-from Extensions.i18n import tr\r
-\r
-class CONFIG_BASE:\r
-\r
- #-------------------------------\r
- def __init__(self,appli,repIni):\r
- #-------------------------------\r
-\r
- # Classe de base permettant de lire, afficher\r
- # et sauvegarder les fichiers utilisateurs \r
- # On a deux directories : la directory generale (Repertoire d install + Nom du code\r
- # Par exemple : ~/Install_Eficas/EficasV1_14/Openturns_Wrapper\r
- # et la directorie de l utilisateur \r
- # HOME/.Eficas_Openturns\r
- # Le fichier prefs.py va etre lu dans la directory generale \r
- # puis surcharge eventuellement par celui contenu dans ${PREFS_CATA_$CODE} \r
- # par celui de l utilisateur\r
- # le fichier de catalogue va etre lu dans la directory de l utilisateur s il exite\r
- # dans le fichier general sinon\r
- self.appli = appli \r
- self.code = appli.code\r
- self.salome = appli.salome\r
- if self.salome : self.name="editeur_salome.ini"\r
- else : self.name="editeur.ini"\r
- self.rep_mat = None\r
- self.repIni = repIni\r
- if sys.platform[0:5]=="linux" :\r
- self.rep_user = os.path.join(os.environ['HOME'],'.config/Eficas',appli.code)\r
- else :\r
- self.rep_user = os.path.join('C:/','.config/Eficas',appli.code)\r
-\r
- \r
-\r
- self.setValeursParDefaut()\r
- \r
- self.lecture_fichier_ini_standard()\r
- self.lecture_fichier_ini_integrateur()\r
- self.lecture_fichier_ini_utilisateur()\r
-\r
- #Particularite des schemas MAP\r
- if hasattr(self,'make_ssCode'): self.make_ssCode(self.ssCode)\r
-\r
- if self.appli: self.parent=appli.top\r
- else: self.parent=None\r
-\r
- if not os.path.isdir(self.savedir) :\r
- if sys.platform[0:5]=="linux" :\r
- self.savedir=os.environ['HOME']\r
- else:\r
- self.savedir='C:/'\r
- \r
-\r
-\r
- def setValeursParDefaut(self):\r
- #-----------------------------\r
- \r
- # Valeurs par defaut\r
- if not os.path.isdir(self.rep_user) : os.makedirs(self.rep_user)\r
- self.path_doc = os.path.abspath(os.path.join(self.repIni,'..','Doc'))\r
- self.exec_acrobat = 'acroread'\r
- nomDir="Eficas_"+self.code\r
- if sys.platform[0:5]=="linux" :\r
- self.savedir = os.path.abspath(os.path.join(os.environ['HOME'],nomDir))\r
- else:\r
- self.savedir = os.path.abspath('C:/')\r
- self.mode_nouv_commande='initial'\r
- self.affiche="alpha"\r
- self.closeAutreCommande = False\r
- self.closeFrameRechercheCommande = False\r
- self.closeEntete = False\r
- self.closeArbre = False\r
- self.force_langue=False\r
- self.suiteTelemac=False\r
-\r
- \r
- #--------------------------------------\r
- def lecture_fichier_ini_standard(self):\r
- #--------------------------------------\r
-\r
- name='prefs_'+self.appli.code\r
- prefsCode=__import__(name)\r
- for k in dir(prefsCode):\r
- if (k[0:1] != "__" and k[-1:-2] !='__'):\r
- valeur=getattr(prefsCode,k)\r
- setattr(self,k,valeur)\r
- \r
-\r
-\r
- #--------------------------------------\r
- def lecture_fichier_ini_integrateur(self):\r
- #--------------------------------------\r
- # Verifie l'existence du fichier "standard"\r
- # appelle la lecture de ce fichier\r
- clef="PREFS_CATA_"+self.code\r
- try :\r
- repIntegrateur=os.path.abspath(os.environ[clef])\r
- except :\r
- return\r
- \r
- fic_ini_integrateur=os.path.join(repIntegrateur,self.name)\r
- if not os.path.isfile(fic_ini_integrateur): return\r
- txt = read_file(fic_ini_integrateur)\r
- d=locals()\r
- try:\r
- exec txt in d\r
- except :\r
- QMessageBox.critical( None, tr("Import du fichier de Configuration"), \r
- tr("Erreur a la lecture du fichier de configuration %s " , str(fic_ini_integrateur)))\r
- return\r
- self.labels_eficas.append('rep_aide')\r
- for k in self.labels_eficas :\r
- try :\r
- setattr(self,k,d[k])\r
- except :\r
- pass\r
- #Glut pour les repertoires materiaux\r
- #et pour la doc\r
- for k in d.keys() :\r
- if (k[0:8]=="rep_mat_") or (k[0:8]=="rep_doc_"):\r
- setattr(self,k,d[k])\r
-\r
-\r
- #--------------------------------------\r
- def lecture_fichier_ini_utilisateur(self):\r
- #--------------------------------------\r
- # Surcharge les parametres standards par les parametres utilisateur s'ils existent\r
- self.fic_ini_utilisateur = os.path.join(self.rep_user,self.name)\r
- if not os.path.isfile(self.fic_ini_utilisateur): return\r
-\r
- txt = read_file(self.fic_ini_utilisateur)\r
- d=locals()\r
- try:\r
- exec txt in d\r
- except :\r
- l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])\r
- QMessageBox.critical( None, tr("Import du fichier de Configuration"), \r
- tr("Erreur a la lecture du fichier de configuration %s " , str(fic_ini_integrateur)))\r
- for k in self.labels_user :\r
- try :\r
- setattr(self,k,d[k])\r
- except :\r
- pass\r
- for k in d.keys() :\r
- if (k[0:8]=="rep_mat_") or (k[0:8]=="rep_doc_"):\r
- setattr(self,k,d[k])\r
-\r
- #--------------------------------------\r
- def save_params(self):\r
- #--------------------------------------\r
- # sauvegarde\r
- # les nouveaux parametres dans le fichier de configuration utilisateur\r
- #\r
- texte=""\r
- for clef in self.labels_user :\r
- if hasattr(self,clef):\r
- valeur=getattr(self,clef)\r
- texte= texte + clef+" = " + repr(valeur) +"\n"\r
- #Glut pour les repertoires materiaux\r
- #et pour la doc\r
- for k in dir(self):\r
- if (k[0:8]=="rep_mat_") or (k[0:8]=="rep_doc_"):\r
- valeur=getattr(self,k)\r
- texte= texte + k+" = " + repr(valeur) +"\n"\r
-\r
- f=open(self.fic_ini_utilisateur,'w+')\r
- f.write(texte) \r
- f.close()\r
-#\r
-\r
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2013 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# 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 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
+#
+"""
+ Ce module sert pour charger les parametres de configuration d'EFICAS
+"""
+# Modules Python
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import range
+ from builtins import object
+except : pass
+
+import os, sys, types, re
+import traceback
+from PyQt5.QtWidgets import QMessageBox
+from Editeur.utils import read_file
+from Extensions.i18n import tr
+
+class CONFIG_BASE(object):
+
+ #-------------------------------
+ def __init__(self,appli,repIni):
+ #-------------------------------
+
+ # Classe de base permettant de lire, afficher
+ # et sauvegarder les fichiers utilisateurs
+ # On a deux directories : la directory generale (Repertoire d install + Nom du code
+ # Par exemple : ~/Install_Eficas/EficasV1_14/Openturns_Wrapper
+ # et la directorie de l utilisateur
+ # HOME/.Eficas_Openturns
+ # Le fichier prefs.py va etre lu dans la directory generale
+ # puis surcharge eventuellement par celui contenu dans ${PREFS_CATA_$CODE}
+ # par celui de l utilisateur
+ # le fichier de catalogue va etre lu dans la directory de l utilisateur s il exite
+ # dans le fichier general sinon
+ self.appli = appli
+ self.code = appli.code
+ self.salome = appli.salome
+ if self.salome : self.name="editeur_salome.ini"
+ else : self.name="editeur.ini"
+ self.rep_mat = None
+ self.repIni = repIni
+ if sys.platform[0:5]=="linux" :
+ self.rep_user = os.path.join(os.environ['HOME'],'.config/Eficas',appli.code)
+ else :
+ self.rep_user = os.path.join('C:/','.config/Eficas',appli.code)
+
+
+
+ self.setValeursParDefaut()
+
+ self.lecture_fichier_ini_standard()
+ self.lecture_fichier_ini_integrateur()
+ self.lecture_fichier_ini_utilisateur()
+
+ #Particularite des schemas MAP
+ if hasattr(self,'make_ssCode'): self.make_ssCode(self.ssCode)
+
+ if self.appli: self.parent=appli.top
+ else: self.parent=None
+
+ if not os.path.isdir(self.savedir) :
+ if sys.platform[0:5]=="linux" :
+ self.savedir=os.environ['HOME']
+ else:
+ self.savedir='C:/'
+
+
+
+ def setValeursParDefaut(self):
+ #-----------------------------
+
+ # Valeurs par defaut
+ if not os.path.isdir(self.rep_user) : os.makedirs(self.rep_user)
+ self.path_doc = os.path.abspath(os.path.join(self.repIni,'..','Doc'))
+ self.exec_acrobat = 'acroread'
+ nomDir="Eficas_"+self.code
+ if sys.platform[0:5]=="linux" :
+ self.savedir = os.path.abspath(os.path.join(os.environ['HOME'],nomDir))
+ else:
+ self.savedir = os.path.abspath('C:/')
+ self.mode_nouv_commande='initial'
+ self.affiche="alpha"
+ self.closeAutreCommande = False
+ self.closeFrameRechercheCommande = False
+ self.closeEntete = False
+ self.closeArbre = False
+ self.force_langue=False
+ self.suiteTelemac=False
+ self.nombreDeBoutonParLigne=0
+ self.translatorFichier=None
+
+
+ #--------------------------------------
+ def lecture_fichier_ini_standard(self):
+ #--------------------------------------
+
+ name='prefs_'+self.appli.code
+ prefsCode=__import__(name)
+ for k in dir(prefsCode):
+ if (k[0:1] != "__" and k[-1:-2] !='__'):
+ valeur=getattr(prefsCode,k)
+ setattr(self,k,valeur)
+
+
+
+ #--------------------------------------
+ def lecture_fichier_ini_integrateur(self):
+ #--------------------------------------
+ # Verifie l'existence du fichier "standard"
+ # appelle la lecture de ce fichier
+ clef="PREFS_CATA_"+self.code
+ try :
+ repIntegrateur=os.path.abspath(os.environ[clef])
+ except :
+ return
+
+ fic_ini_integrateur=os.path.join(repIntegrateur,self.name)
+ if not os.path.isfile(fic_ini_integrateur): return
+ txt = read_file(fic_ini_integrateur)
+ d=locals()
+ try:
+ exec(txt, d)
+ except :
+ QMessageBox.critical( None, tr("Import du fichier de Configuration"),
+ tr("Erreur a la lecture du fichier de configuration %s " , str(fic_ini_integrateur)))
+ return
+ self.labels_eficas.append('rep_aide')
+ for k in self.labels_eficas :
+ try :
+ setattr(self,k,d[k])
+ except :
+ pass
+ #Glut pour les repertoires materiaux
+ #et pour la doc
+ for k in d :
+ if (k[0:8]=="rep_mat_") or (k[0:8]=="rep_doc_"):
+ setattr(self,k,d[k])
+
+
+ #--------------------------------------
+ def lecture_fichier_ini_utilisateur(self):
+ #--------------------------------------
+ # Surcharge les parametres standards par les parametres utilisateur s'ils existent
+ self.fic_ini_utilisateur = os.path.join(self.rep_user,self.name)
+ if not os.path.isfile(self.fic_ini_utilisateur): return
+
+ txt = read_file(self.fic_ini_utilisateur)
+ d=locals()
+ try:
+ exec(txt, d)
+ except :
+ l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
+ QMessageBox.critical( None, tr("Import du fichier de Configuration"),
+ tr("Erreur a la lecture du fichier de configuration %s " , str(fic_ini_integrateur)))
+ for k in self.labels_user :
+ try :
+ setattr(self,k,d[k])
+ except :
+ pass
+ for k in d :
+ if (k[0:8]=="rep_mat_") or (k[0:8]=="rep_doc_"):
+ setattr(self,k,d[k])
+
+ #--------------------------------------
+ def save_params(self):
+ #--------------------------------------
+ # sauvegarde
+ # les nouveaux parametres dans le fichier de configuration utilisateur
+ #
+ texte=""
+ for clef in self.labels_user :
+ if hasattr(self,clef):
+ valeur=getattr(self,clef)
+ texte= texte + clef+" = " + repr(valeur) +"\n"
+ #Glut pour les repertoires materiaux
+ #et pour la doc
+ for k in dir(self):
+ if (k[0:8]=="rep_mat_") or (k[0:8]=="rep_doc_"):
+ valeur=getattr(self,k)
+ texte= texte + k+" = " + repr(valeur) +"\n"
+
+ f=open(self.fic_ini_utilisateur,'w+')
+ f.write(texte)
+ f.close()
+#
+
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import object
+except : pass
+
import os
class envQT(object):
def __init__(self):
if hasattr(self,'inQt5') : return
- if 'PYQT_ROOT_DIR' in os.environ.keys(): qt=os.environ['PYQT_ROOT_DIR']
+ if 'PYQT_ROOT_DIR' in os.environ: qt=os.environ['PYQT_ROOT_DIR']
else : qt="Pyqt4"
if 'Pyqt-5' in qt : self.inQt5=True
else : self.inQt5=False
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+except : pass
+
import types,sys,os, re
import subprocess
import traceback
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter
- from PyQt5.QtGui import QPalette
- from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+import six
+from six.moves import range
+from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter
+from PyQt5.QtGui import QPalette
+from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
import time
import pdb
from datetime import date
from Extensions.i18n import tr
+import traceback
# Modules Eficas
from Editeur import comploader
from Editeur import Objecttreeitem
from desBaseWidget import Ui_baseWidget
-from monViewTexte import ViewText
+from InterfaceQT4.monViewTexte import ViewText
from monWidgetCreeParam import MonWidgetCreeParam
-import browser
-import readercata
+from . import browser
+from . import readercata
DictExtensions= {"MAP" : ".map", "TELEMAC" : '.comm'}
self.first = True
self.QWParent = QWParent
self.couleur = Qt.black
+ self.nodeEnCours=None
if appli != None :
self.salome = self.appliEficas.salome
# ces attributs sont mis a jour par definitCode appelee par newEditor
self.code = self.appliEficas.CONFIGURATION.code
+ self.initSplitterSizes()
#self.afficheListesPliees=False
self.afficheListesPliees=True
self.closeFrameRechercheCommande=self.appliEficas.CONFIGURATION.closeFrameRechercheCommande
self.closeArbre=self.appliEficas.CONFIGURATION.closeArbre
self.affiche=self.appliEficas.CONFIGURATION.affiche
+ self.nombreDeBoutonParLigne = self.appliEficas.CONFIGURATION.nombreDeBoutonParLigne
#self.taille = self.appliEficas.taille
#if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
if self.code in ['MAP',]:
self.widgetTree.close()
self.widgetTree=None
- if self.closeArbre:
- self.widgetTree.close()
- self.widgetTree=None
-
-
+ if self.closeArbre: self.fermeArbre()
self.version_code = session.d_env.cata
+
if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.multi==True:
self.readercata = readercata.READERCATA( self, self.appliEficas )
self.appliEficas.readercata=self.readercata
self.fileInfo = QFileInfo(self.fichier)
self.fileInfo.setCaching(0)
if jdc==None :
- try :
+ #try :
self.jdc = self.readFile(self.fichier)
- except :
- print ("mauvaise lecture")
+ #except :
+ # print ("mauvaise lecture")
else :
self.jdc=jdc
if self.jdc is not None and units is not None:
#-------------------# Pour execution avec output et error dans le bash
def runPSEN(self):
#-------------------#
+
#if self.modified or self.fichier==None : self.saveFile()
self.saveFile()
if not(self.jdc.isvalid()):
QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
- if generator.plugins.has_key('dicoImbrique'):
+ if 'dicoImbrique' in generator.plugins:
self.generator=generator.plugins['dicoImbrique']()
jdc_formate=self.generator.gener(self.jdc)
dico=self.generator.Dico
###to delete
#fileDico = r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
fileDico = os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
- f = open( str(fileDico), 'wb')
+ f = open( str(fileDico), 'w')
f.write("Dico =" + str(dico) )
f.close()
###
sys.path.append(path1)
- if generator.plugins.has_key('dicoImbrique'):
+ if 'dicoImbrique' in generator.plugins:
self.generator=generator.plugins['dicoImbrique']()
jdc_formate=self.generator.gener(self.jdc)
dico=self.get_Dico() #generator.Dico
- for k in dico['CONTINGENCY_PROCESSING'].keys():
+ for k in dico['CONTINGENCY_PROCESSING']:
#print (k)
if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
newK=k.replace('___',' ')
###to delete
fileDico = os.path.join(path1, 'dicoN1_process.py')
- f = open( str(fileDico), 'wb')
+ f = open( str(fileDico), 'w')
f.write("Dico =" + str(dico) )
f.close()
###
Public slot to read the text from a file.
@param fn filename to read from (string or QString)
"""
- fn = unicode(fn)
+ fn = six.text_type(fn)
# ------------------------------------------------------------------------------------
# charge le JDC
jdcName=os.path.basename(fn)
# Il faut convertir le contenu du fichier en fonction du format
- if convert.plugins.has_key( self.appliEficas.format_fichier_in ):
+ if self.appliEficas.format_fichier_in in convert.plugins:
# Le convertisseur existe on l'utilise
#appli = self
p=convert.plugins[self.appliEficas.format_fichier_in]()
#-----------------------#
# Il faut convertir le contenu du fichier en fonction du format
- if convert.plugins.has_key(self.format):
+ if self.format in convert.plugins :
# Le convertisseur existe on l'utilise
p=convert.plugins[self.format]()
p.readfile(file)
f=open(nomFichier,'w')
f.write(txt)
f.close()
- if monEnvQT5 :
- self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
- self.monExe.readyReadStandardError.connect( self.readFromStdErr)
- else :
- self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOutQT4 )
- self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErrQT4 )
+ self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
+ self.monExe.readyReadStandardError.connect( self.readFromStdErr)
exe='sh ' + nomFichier
self.monExe.start(exe)
self.monExe.closeWriteChannel()
#-----------------------#
def viewJdcSource(self):
#-----------------------#
+ if self.fichier == None : return
f=open(self.fichier,'r')
texteSource=f.read()
f.close()
#-----------------------#
def viewJdcRapport(self):
#-----------------------#
- strRapport = unicode( self.jdc.report() )
+ strRapport = six.text_type( self.jdc.report() )
# on ajoute les regles
self._viewText(strRapport, "JDC_RAPPORT")
#---------------------#
def handleRechercher(self):
#---------------------#
- from monRecherche import DRecherche
+ from .monRecherche import DRecherche
monRechercheDialg=DRecherche(parent=self,fl=0)
monRechercheDialg.show()
#--------------------------------#
def handleRechercherDsCatalogue(self):
#-----------------------------#
- from monRechercheCatalogue import DRechercheCatalogue
+ from .monRechercheCatalogue import DRechercheCatalogue
monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
monRechercheDialg.show()
@return flag indicating success
"""
- fn = unicode(fn)
+ fn = six.text_type(fn)
if txt == None :
txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
txt=txt+checksum
if self.code=="TELEMAC" : return 1
try:
- f = open(fn, 'wb')
+ f = open(fn, 'w')
f.write(txt)
f.close()
return 1
#-----------------------------------------------------------#
def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
#-----------------------------------------------------------#
- if self.code == "MAP" and not(generator.plugins.has_key(format)): format = "MAP"
- if generator.plugins.has_key(format):
+ if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
+ if format in generator.plugins:
# Le generateur existe on l'utilise
self.generator=generator.plugins[format]()
if pourRun : jdc_formate=self.generator.textePourRun
except ValueError as e:
QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
+ return
+
if not self.generator.cr.estvide():
self.affiche_infos(tr("Erreur a la generation"),Qt.red)
QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
#----------------------#
def get_Dico(self):
#---------------------#
- if generator.plugins.has_key('dicoImbrique'):
+ if 'dicoImbrique' in generator.plugins:
self.generator=generator.plugins['dicoImbrique']()
jdc_formate=self.generator.gener(self.jdc)
dico=self.generator.Dico
#------------#
fonction="run"+self.code
#print fonction
- if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
+ if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction],(self,)
#------------#
def saveRun(self):
#------------#
fonction="saveRun"+self.code
- if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
+ if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction],(self,)
#---------------#
def runMAP(self):
#except :
# pass
except Exception as e:
- print (traceback.print_exc())
+ print((traceback.print_exc()))
#-------------------#
def runZCRACKS(self):
textePython=(commande + self.fichierZcracksInput)
self._viewTextExecute( textePython,"run_zcracks",".sh")
except Exception as e:
- print (traceback.print_exc())
+ print((traceback.print_exc()))
#-------------------#
def runCARMELCND(self):
commande="runSession pilotyacsCS.py"
os.system(commande)
except Exception as e:
- print (traceback.print_exc())
+ print((traceback.print_exc()))
#-----------------------------------------------------#
def determineNomFichier(self,path,extension):
#-----------------------------------------------------#
- if DictExtensions.has_key(self.appli.code) :
+ if self.appli.code in DictExtensions:
chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
extensions= tr(chaine1+ "All Files (*)")
else :
extensions,None,
QFileDialog.DontConfirmOverwrite)
if fn == None : return (0, None)
- if monEnvQT5 : fn=fn[0]
+ fn=fn[0]
if fn=='': return (0, None)
ext = QFileInfo(fn).suffix()
if ext == '': fn+=extension
if QFileInfo(fn).exists():
- if monEnvQT5 :
- msgBox = QMessageBox(self)
- msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
- msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", unicode(fn)))
- msgBox.addButton(tr("&Ecraser"),0)
- msgBox.addButton(tr("&Abandonner"),1)
- abort=msgBox.exec_()
- else :
- abort = QMessageBox.warning(self,
- tr("Sauvegarde du Fichier"),
- tr("Le fichier <b>%s</b> existe deja.",str(fn)),
- tr("&Ecraser"),
- tr("&Abandonner"))
+ msgBox = QMessageBox(self)
+ msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
+ msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", six.text_type(fn)))
+ msgBox.addButton(tr("&Ecraser"),0)
+ msgBox.addButton(tr("&Abandonner"),1)
+ abort=msgBox.exec_()
if abort == 1 : return (0, "")
return (1,fn)
for b in c.children():
if isinstance(b,QPushButton):
avant=b.text()
- if (not monEnvQT5) and avant.toLatin1()=="&Open": b.setText("Save")
- if monEnvQT5 and avant=="&Open": b.setText("Save")
- if monEnvQT5 :
- mesFiltres= "input Map (*.input);;All Files (*)"
- else :
- mesFiltres=QStringList()
- mesFiltres << "input Map (*.input)" << "All Files (*)"
+ if avant=="&Open": b.setText("Save")
+ mesFiltres= "input Map (*.input);;All Files (*)"
monDialog.setNameFilters(mesFiltres)
if monNomFichier!="" : monDialog.selectFile(monNomFichier)
BOk=monDialog.exec_()
if BOk==0: return
- if monEnvQT5 : fn=str(monDialog.selectedFiles()[0])
- else : fn=str(monDialog.selectedFiles()[0].toLatin1())
+ fn=str(monDialog.selectedFiles()[0])
if fn == "" or fn == None : return
if not fn.endswith(".input"):
fn += ".input"
#-----------------------------------------#
dicoCourant={}
format = self.appliEficas.format_fichier
- if generator.plugins.has_key(format):
+ if format in generator.plugins:
# Le generateur existe on l'utilise
self.generator=generator.plugins[format]()
jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
if fn == None : return (0, None)
if fn== '' : return (0, None)
- ulfile = os.path.abspath(unicode(fn))
+ ulfile = os.path.abspath(six.text_type(fn))
self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
- fn = unicode(QDir.toNativeSeparators(fn))
+ fn = six.text_type(QDir.toNativeSeparators(fn))
self.fichier = os.path.splitext(fn)[0]+extension
if not self.modified and not saveas:
return (0, None) # do nothing if text wasn't changed
- if DictExtensions.has_key(self.appli.code) :
+ if self.appli.code in DictExtensions :
extension=DictExtensions[self.appli.code]
else :
extension='.comm'
if fn == None : return (0, None)
if fn== '' : return (0, None)
- ulfile = os.path.abspath(unicode(fn))
+ ulfile = os.path.abspath(six.text_type(fn))
self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
- fn = unicode(QDir.toNativeSeparators(fn))
+ fn = six.text_type(QDir.toNativeSeparators(fn))
newName = fn
# ce retour est impose par le get_file d'I_JDC
if fn== '' : return None," "
if not fn : return (0, " ")
- if monEnvQT5 : fn=fn[0]
+ fn=fn[0]
- ulfile = os.path.abspath(unicode(fn))
+ ulfile = os.path.abspath(six.text_type(fn))
self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
# On utilise le convertisseur defini par format_fichier
QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
caption='Fichier Med',
filter=extensions)
- if monEnvQT5 : QSfichier=QSfichier[0]
+ QSfichier=QSfichier[0]
self.fichierMED=QSfichier
from acquiertGroupes import getGroupes
erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
#-----------------------------------------
def initSplitterSizes(self, nbWidget=3):
#-----------------------------------------
- #print "je passe ds initSplitterSizes"
- if nbWidget==3 :
- if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes=[1,1550,150]
- elif self.code in [ 'MAP'] : self.splitterSizes=[700,300]
- else : self.splitterSizes=[150,800,500]
- self.oldSizeWidgetOptionnel = 30
- if nbWidget==2 :
- if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes=[5,1500]
- else : self.splitterSizes=[300,1000]
- self.oldSizeWidgetOptionnel = 30
- self.splitter.setSizes(self.splitterSizes)
+ #print ("je passe ds initSplitterSizes", nbWidget)
+
+ if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
+ elif self.code in [ 'MAP'] : self.splitterSizes3=[700,300]
+ else : self.splitterSizes3=[150,1000,300]
+
+ if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
+ else : self.splitterSizes2=[300,1000]
+
#-----------------------------------------
def restoreSplitterSizes(self,nbWidget=3):
#----------------------------------------
- #self.inhibeSplitter = 1
- #print 'ds restoreSplitterSizes'
- #print self.splitterSizes
+ #traceback.print_stack()
+ #print ("je passe ds restoreSplitterSizes")
if not(hasattr(self,'splitter')) : return
- if nbWidget==2 and len(self.splitterSizes) == 3 :
- self.splitterSizes[1]+=self.splitterSizes[2]
- newSizes=self.splitterSizes[:nbWidget]
+ if nbWidget==2 : newSizes=self.splitterSizes2
+ if nbWidget==3 : newSizes=self.splitterSizes3
+ #self.inhibeSplitter = 1
self.splitter.setSizes(newSizes)
+ #self.inhibeSplitter = 0
QApplication.processEvents()
# seule la fentetre du milieu est necessaire
self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
+ #-----------------------------------------
def saveSplitterSizes(self,event):
- self.splitterSizes= self.splitter.sizes()
+ #-----------------------------------------
+ #print ("je passe ds saveSplitterSizes")
+ if self.inhibeSplitter : return
+ if self.widgetOptionnel == None : self.splitterSizes2 = self.splitter.sizes()[0:2]
+ else : self.splitterSizes3 = self.splitter.sizes()[0:3]
#------------------------
def fermeOptionnel(self):
if self.widgetOptionnel == None : return
self.inhibeSplitter=1
- self.splitterSizes[1] = self.splitterSizes[1] + self.splitterSizes[2]
- if self.splitterSizes[2]!=0 : self.oldSizeWidgetOptionnel = self.splitterSizes[2]
- self.splitterSizes[2]=0
-
self.widgetOptionnel.setParent(None)
self.widgetOptionnel.close()
self.widgetOptionnel.deleteLater()
self.widgetOptionnel=None
self.inhibeSplitter=0
self.restoreSplitterSizes(2)
-
+
#------------------------
def ajoutOptionnel(self):
#------------------------
- if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
- else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
+ #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
+ #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
#self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
self.restoreSplitterSizes(3)
+ #------------------------
+ def fermeArbre(self):
+ #------------------------
+ #print (self.widgetTree)
+ self.oldWidgetTree=self.widgetTree
+ self.widgetTree.hide()
+ #self.widgetTree=None
+
+ #------------------------
+ def ouvreArbre(self):
+ #------------------------
+ #print ('je passe la')
+ #print (self.widgetTree)
+ #self.widgetTree=self.oldWidgetTree
+ self.widgetTree.show()
+ #self.restoreSplitterSizes(3)
+
#-----------------------------
def getTreeIndex(self,noeud):
#----------------------------
#
# Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except : pass
+
+from PyQt5.QtWidgets import QApplication
+
import sys,os
repIni=os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),".."))
-from determine import monEnvQT5
-if monEnvQT5 :
- ihmQTDir=os.path.join(repIni,"UiQT5")
- from PyQt5.QtWidgets import QApplication
-else :
- ihmQTDir=os.path.join(repIni,"UiQT4")
- from PyQt4.QtGui import QApplication
+ihmQTDir=os.path.join(repIni,"UiQT5")
editeurDir=os.path.join(repIni,"Editeur")
ihmDir=os.path.join(repIni,"InterfaceQT4")
+
if ihmDir not in sys.path : sys.path.append(ihmDir)
if ihmQTDir not in sys.path : sys.path.append(ihmQTDir)
if editeurDir not in sys.path :sys.path.append(editeurDir)
if options.code!= None : code=options.code
if options.ssCode!= None : ssCode=options.ssCode
- from qtEficas import Appli
+ from .qtEficas import Appli
app = QApplication(sys.argv)
Eficas=Appli(code=code,ssCode=ssCode,multi=multi,langue=langue)
Eficas.show()
if fichier==None : fichier=options.comm[0]
if code == None : code=options.code
- from qtEficas import Appli
+ from .qtEficas import Appli
Eficas=Appli(code=code,ssCode=ssCode,ssIhm=True)
- from ssIhm import QWParentSSIhm
+ from .ssIhm import QWParentSSIhm
parent=QWParentSSIhm(code,Eficas,version)
- import readercata
+ from . import readercata
if not hasattr ( Eficas, 'readercata'):
monreadercata = readercata.READERCATA( parent, Eficas )
Eficas.readercata=monreadercata
- from editor import JDCEditor
+ from .editor import JDCEditor
monEditeur=JDCEditor(Eficas,fichier)
return monEditeur
def lance_eficas_ssIhm_cherche_Groupes(code=None,fichier=None,ssCode=None,version=None):
monEditeur=lance_eficas_ssIhm(code,fichier,ssCode,version)
- print (monEditeur.cherche_Groupes())
+ print((monEditeur.cherche_Groupes()))
def lance_eficas_ssIhm_cherche_cr(code=None,fichier=None,ssCode=None,version=None):
monEditeur=lance_eficas_ssIhm(code,fichier,ssCode,version)
- print (monEditeur.jdc.cr)
+ print((monEditeur.jdc.cr))
def lance_eficas_ssIhm_reecrit(code=None,fichier=None,ssCode=None,version=None,ou=None,cr=False):
#print 'lance_eficas_ssIhm_reecrit', fichier
fileCr=os.path.join(ou,f2)
monEditeur.saveFileAs(fileName=fileName)
if cr:
- f = open(fileCr, 'wb')
+ f = open(fileCr, 'w')
f.write(str(monEditeur.jdc.report()))
f.close()
from Editeur import session
options=session.parse(sys.argv)
- from qtEficas import Appli
+ from .qtEficas import Appli
app = QApplication(sys.argv)
Eficas=Appli(code=code,ssCode=None)
- from ssIhm import QWParentSSIhm
+ from .ssIhm import QWParentSSIhm
parent=QWParentSSIhm(code,Eficas,version)
- import readercata
+ from . import readercata
if not hasattr ( Eficas, 'readercata'):
monreadercata = readercata.READERCATA( parent, Eficas )
Eficas.readercata=monreadercata
- from editor import JDCEditor
+ from .editor import JDCEditor
monEditeur=JDCEditor(Eficas,fichier)
texte=loadJDC(fichier)
parameters=getJdcParameters(texte,macro)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+try :
+ from builtins import str
+except :
+ pass
+import types,os
import traceback
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QToolButton ,QWidget
- from PyQt5.QtGui import QFont, QFontMetrics
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
-from Extensions.i18n import tr
+from PyQt5.QtWidgets import QToolButton ,QWidget
+from PyQt5.QtGui import QFont, QFontMetrics
+from PyQt5.QtCore import Qt
+from Extensions.i18n import tr
-from gereIcones import ContientIcones
-from gereIcones import FacultatifOuOptionnel
-from qtSaisie import SaisieValeur
+from .gereIcones import ContientIcones
+from .gereIcones import FacultatifOuOptionnel
+from .qtSaisie import SaisieValeur
nomMax=250
# ---------------------------------------------------------------------- #
self.setIconesGenerales()
self.setCommentaire()
self.setZoneInfo()
-
+
def setNom(self):
self.debutToolTip=""
self.setMinimumHeight(50)
self.resize(self.width(),200)
+ #def mousePressEvent(self, event):
+ #print 'mousePressEvent'
+ #import inspect
+ #print (inspect.getmro(self.__class__))
+ #self.__class__.mousePressEvent(self, event)
+
+
def setValeurs(self):
# print "passe dans setValeurs pour ", self.objSimp.nom
'I' : 'entiers',
'C' : 'complexes'}
type = mc.type[0]
- if not d_aides.has_key(type) :
+ if not type in d_aides :
if mc.min == mc.max:
commentaire=tr("Entrez ")+str(mc.min)+tr(" valeurs ")+'\n'
else :
#if self.node.item.definition.validators : c+=self.node.item.definition.validators.aide()
self.aide=c
if self.objSimp.get_fr() != None and self.objSimp.get_fr() != "":
- c2 = '<html><head/><body><p>'+c+unicode(self.objSimp.get_fr())+"</p></body></html>"
+ c2 = '<html><head/><body><p>'+c+self.objSimp.get_fr().decode('latin-1','replace')+"</p></body></html>"
self.label.setToolTip(c2)
- self.aide=unicode(self.objSimp.get_fr())+" "+c
+ self.aide=self.objSimp.get_fr().decode('latin-1','ignore')+" "+c
else :
c+=self.finCommentaire()
if c != "" and c != None :
if mc.min == mc.max: commentaire=tr("Entrez ")+" "+str(mc.min)+" "
else : commentaire=tr("Entrez entre ")+str(mc.min)+tr(" et ")+str(mc.max)
- if type(mctype) == types.ClassType: ctype = getattr(mctype, 'help_message', tr("Type de base inconnu"))
- else: ctype = d_aides.get(mctype, tr("Type de base inconnu"))
+ try :
+ if issubclass(mctype,object) : ctype = getattr(mctype, 'help_message', tr("Type de base inconnu"))
+ else : ctype = d_aides.get(mctype, tr("Type de base inconnu"))
+ except:
+ ctype = d_aides.get(mctype, tr("Type de base inconnu"))
if ctype == tr("Type de base inconnu") and "Tuple" in str(mctype): ctype=str(mctype)
commentaire+=ctype
pass
def reaffiche(self):
- #print "dans reaffiche de feuille", self.nom
+
if self.editor.jdc.aReafficher==True :
self.parentQt.reaffiche()
try :
self.setValeursApresBouton()
except :
- self.editor.fenetreCentraleAffichee.afficheSuivant(self.AAfficher)
+ pass
+ self.editor.fenetreCentraleAffichee.afficheSuivant(self.AAfficher)
else :
if hasattr(self, 'AAfficher'): self.AAfficher.setFocus(7)
self.parentQt.reaffiche()
def rendVisible(self):
- #print "jjjjjjjjjjjjjjjjjjjjj"
pass
#def enterEvent(self,event):
# QWidget.enterEvent(self,event)
def traiteClicSurLabel(self,texte):
- #print self.aide
- aide=self.aide+"\n"+self.aideALaSaisie()
+ aide=self.aide.encode('latin-1', 'ignore').decode('latin-1')+"\n"+self.aideALaSaisie().encode('latin-1', 'ignore').decode('latin-1')
self.editor.affiche_commentaire(aide)
def formate(self,t):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os,re,sys
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
+import types,os,re,sys
import traceback
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QMessageBox, QFileDialog , QMenu, QPushButton
- from PyQt5.QtGui import QIcon
- from PyQt5.QtCore import QFileInfo, Qt, QSize, QVariant
+import six
-else:
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QMessageBox, QFileDialog , QMenu, QPushButton
+from PyQt5.QtGui import QIcon
+from PyQt5.QtCore import QFileInfo, Qt, QSize, QVariant
from Extensions.i18n import tr
listeSuffixe=('bmp','png','jpg' ,'txt','med')
-class FacultatifOuOptionnel:
+class FacultatifOuOptionnel(object):
def setReglesEtAide(self):
listeRegles=()
else :
icon3=QIcon(self.repIcon+"/lettreRblanc30.png")
self.RBRegle.setIcon(icon3)
- if monEnvQT5 :self.RBRegle.clicked.connect(self.viewRegles)
- else : self.connect( self.RBRegle,SIGNAL("clicked()"),self.viewRegles)
+ self.RBRegle.clicked.connect(self.viewRegles)
cle_doc=None
if not hasattr(self,"RBInfo"):return
icon=QIcon(self.repIcon+"/point-interrogation30.png")
self.RBInfo.setIcon(icon)
- from monWidgetCommande import MonWidgetCommande
+ from .monWidgetCommande import MonWidgetCommande
if isinstance(self,MonWidgetCommande) and self.editor.code =="MAP":
self.cle_doc = self.chercheDocMAP()
else :
self.cle_doc = self.node.item.get_docu()
if self.cle_doc == None : self.RBInfo.close()
- elif monEnvQT5 : self.RBInfo.clicked.connect (self.viewDoc)
- else : self.connect (self.RBInfo,SIGNAL("clicked()"),self.viewDoc)
+ else : self.RBInfo.clicked.connect (self.viewDoc)
def chercheDocMAP(self):
clef=self.editor.CONFIGURATION.adresse+"/"
except :
return None
- for k in self.editor.readercata.cata[0].JdC.dict_groupes.keys():
+ for k in self.editor.readercata.cata[0].JdC.dict_groupes:
if self.obj.nom in self.editor.readercata.cata[0].JdC.dict_groupes[k]:
clef+=k
break
return
icon=QIcon(self.repIcon+"/deleteRond.png")
self.RBPoubelle.setIcon(icon)
- if monEnvQT5 : self.RBPoubelle.clicked.connect(self.aDetruire)
- else : self.connect(self.RBPoubelle,SIGNAL("clicked()"),self.aDetruire)
+ self.RBPoubelle.clicked.connect(self.aDetruire)
def setIconesSalome(self):
if not (hasattr(self,"RBSalome")): return
if enable_salome_selection:
icon=QIcon(self.repIcon+"/flecheSalome.png")
self.RBSalome.setIcon(icon)
- if monEnvQT5 : self.RBSalome.pressed.connect(self.BSalomePressed)
- else : self.connect(self.RBSalome,SIGNAL("pressed()"),self.BSalomePressed)
+ self.RBSalome.pressed.connect(self.BSalomePressed)
#PNPN --> Telemac A revoir surement
# cela ou le catalogue grpma ou salomeEntry
else :
icon1=QIcon(self.repIcon+"/eye.png")
self.RBSalomeVue.setIcon(icon1)
- if monEnvQT5 : self.RBSalomeVue.clicked.connect(self.BView2DPressed)
- else : self.connect(self.RBSalomeVue,SIGNAL("clicked()"),self.BView2DPressed)
+ self.RBSalomeVue.clicked.connect(self.BView2DPressed)
else:
self.RBSalome.close()
self.RBSalomeVue.close()
mctype = mc.type[0]
if mctype == "Repertoire":
self.BRepertoire=self.BFichier
- if monEnvQT5 : self.BRepertoire.clicked.connect(self.BRepertoirePressed)
- else : self.connect(self.BRepertoire,SIGNAL("clicked()"),self.BRepertoirePressed)
+ self.BRepertoire.clicked.connect(self.BRepertoirePressed)
self.BVisuFichier.close()
else :
- if monEnvQT5 : self.BFichier.clicked.connect(self.BFichierPressed)
- else : self.connect(self.BFichier,SIGNAL("clicked()"),self.BFichierPressed)
- if monEnvQT5 : self.BVisuFichier.clicked.connect(self.BFichierVisu)
- else : self.connect(self.BVisuFichier,SIGNAL("clicked()"),self.BFichierVisu)
+ self.BFichier.clicked.connect(self.BFichierPressed)
+ self.BVisuFichier.clicked.connect(self.BFichierVisu)
def setRun(self):
if hasattr(self.editor.appliEficas, 'mesScripts') :
- if self.editor.code in self.editor.appliEficas.mesScripts.keys() :
+ if self.editor.code in self.editor.appliEficas.mesScripts :
self.dict_commandes_mesScripts=self.appliEficas.mesScripts[self.editor.code].dict_commandes
- if self.obj.nom in self.dict_commandes_mesScripts.keys() :
+ if self.obj.nom in self.dict_commandes_mesScripts :
self.ajoutScript()
icon=QIcon(self.repIcon+"/roue.png")
if hasattr(self,"RBRun"):self.RBRun.setIcon(icon)
if not hasattr(self,'CBScripts') : return # Cas des Widgets Plies
self.dictCommandes={}
listeCommandes=self.dict_commandes_mesScripts[self.obj.nom]
- if type(listeCommandes) != types.TupleType: listeCommandes=(listeCommandes,)
+ if type(listeCommandes) != tuple: listeCommandes=(listeCommandes,)
i=0
for commande in listeCommandes :
conditionSalome=commande[3]
self.CBScripts.addItem(commande[1])
self.dictCommandes[commande[1]]=i
i=i+1
- if monEnvQT5:
- #self.CBScripts.currentIndexChanged.connect(self.choixSaisi)
- self.CBScripts.activated.connect(self.choixSaisi)
- else :
- #self.connect(self.CBScripts,SIGNAL("currentIndexChanged(int)"),self.choixSaisi)
- self.connect(self.CBScripts,SIGNAL("activated(int)"),self.choixSaisi)
+ self.CBScripts.activated.connect(self.choixSaisi)
def choixSaisi(self):
fction=str(self.CBScripts.currentText())
self.node.AppelleFonction(numero,nodeTraite=self.node)
#self.reaffiche()
-class ContientIcones:
+class ContientIcones(object):
def BFichierVisu(self):
fichier=self.lineEditVal.text()
if fichier == None or str(fichier)=="" : return
- from monViewTexte import ViewText
+ from .monViewTexte import ViewText
try :
if sys.platform[0:5]=="linux" :
cmd="xdg-open "+ str(fichier)
self.appliEficas.CONFIGURATION.savedir,
filters)
else:
- print filters
+ print(filters)
fichier = QFileDialog.getOpenFileName(self.appliEficas,
tr('Ouvrir Fichier'),
self.appliEficas.CONFIGURATION.savedir,
filters)
- if monEnvQT5 : fichier=fichier[0]
+ fichier=fichier[0]
if not(fichier == ""):
- ulfile = os.path.abspath(unicode(fichier))
+ ulfile = os.path.abspath(six.text_type(fichier))
self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
self.lineEditVal.setText(fichier)
self.editor.affiche_commentaire(tr("Fichier selectionne"))
self.BSelectInFile.setObjectName("BSelectInFile")
self.gridLayout.addWidget(self.BSelectInFile,1,1,1,1)
self.BSelectInFile.setText(tr("Selection"))
- if monEnvQT5 : self.BSelectInFile.clicked.connect(self.BSelectInFilePressed)
- else : self.connect(self.BSelectInFile,SIGNAL("clicked()"),self.BSelectInFilePressed)
+ self.BSelectInFile.clicked.connect(self.BSelectInFilePressed)
except :
pass
else :
directory = self.appliEficas.CONFIGURATION.savedir,
options = QFileDialog.ShowDirsOnly)
- #if monEnvQT5 : directory=directory[0]
if not (directory == "") :
- absdir = os.path.abspath(unicode(directory))
+ absdir = os.path.abspath(six.text_type(directory))
self.appliEficas.CONFIGURATION.savedir = os.path.dirname(absdir)
self.lineEditVal.setText(directory)
self.LEValeurPressed()
mc = self.node.item.get_definition()
- if (isinstance(mc.type,types.TupleType) and len(mc.type) > 1 and "(*.med)" in mc.type[1] ):
+ if (isinstance(mc.type,tuple) and len(mc.type) > 1 and "(*.med)" in mc.type[1] ):
selection, commentaire = self.appliEficas.selectMeshFile(editor=self.editor)
#print selection, commentaire
if commentaire != "" :
return
from Accas import SalomeEntry
- if isinstance(kwType, types.ClassType) and issubclass(kwType, SalomeEntry):
+ if isinstance(kwType, type) and issubclass(kwType, SalomeEntry):
selection, commentaire = self.appliEficas.selectEntryFromSalome(kwType,editor=self.editor)
if commentaire !="" :
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import range
+ from builtins import object
+except : pass
+
+import types,os
import traceback
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QLineEdit, QLabel, QFileDialog
- from PyQt5.QtCore import QEvent, Qt
- from PyQt5.QtGui import QIcon, QPalette
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+
+import six
+from six.moves import range
+from PyQt5.QtWidgets import QLineEdit, QLabel, QFileDialog
+from PyQt5.QtCore import QEvent, Qt
+from PyQt5.QtGui import QIcon, QPalette
from Extensions.i18n import tr
-from monViewTexte import ViewText
+from InterfaceQT4.monViewTexte import ViewText
# ---------------------- #
# ------------- #
-class GereListe:
+class GereListe(object):
# ------------- #
def __init__(self):
- if monEnvQT5 :self.connecterSignaux()
- else : self.connecterSignauxQT4()
+ self.connecterSignaux()
def connecterSignauxQT4(self):
if hasattr(self,'RBHaut'):
tr("Fichier de donnees"),
init,
tr('Tous les Fichiers (*)',))
- if monEnvQT5 : fn=fn[0]
+ fn=fn[0]
if fn == None : return
if fn == "" : return
- ulfile = os.path.abspath(unicode(fn))
+ ulfile = os.path.abspath(six.text_type(fn))
self.editor.CONFIGURATION.savedir=os.path.split(ulfile)[0]
- from monSelectVal import MonSelectVal
+ from .monSelectVal import MonSelectVal
MonSelectVal(file=fn,parent=self).show()
def noircirResultatFiltre(self):
# ----------- #
-class GerePlie:
+class GerePlie(object):
# ----------- #
def gereIconePlier(self):
fichier=os.path.join(repIcon, 'minusnode.png')
icon = QIcon(fichier)
self.BFermeListe.setIcon(icon)
- if monEnvQT5 : self.BFermeListe.clicked.connect( self.selectWidgetPlie)
- else : self.connect(self.BFermeListe,SIGNAL("clicked()"), self.selectWidgetPlie)
+ self.BFermeListe.clicked.connect( self.selectWidgetPlie)
def selectWidgetPlie(self):
self.editor.listeDesListesOuvertes.remove(self.node.item)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtCore import Qt
-else:
- from PyQt4.QtCore import *
-from monViewRegles import ViewRegles
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
-class GereRegles :
+from PyQt5.QtCore import Qt
+from .monViewRegles import ViewRegles
+
+class GereRegles(object) :
def AppelleBuildLBRegles(self):
- from browser import JDCTree
+ from .browser import JDCTree
if isinstance(self,JDCTree):
self.AppelleBuildLBReglesForJdC()
else :
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QFileDialog, QApplication
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+from PyQt5.QtWidgets import QFileDialog, QApplication
import os
from Extensions.i18n import tr
tr('Fichiers JDC (*.comm);;''Tous les Fichiers (*)'))
- if monEnvQT5 : fn=fn[0]
+ fn=fn[0]
FichieraTraduire=str(fn)
if (FichieraTraduire == "" or FichieraTraduire == () ) : return
i=FichieraTraduire.rfind(".")
QApplication.setOverrideCursor(QCursor(Qt.ArrowCursor))
Entete=tr("Fichier Traduit : %s\n\n",str(FichierTraduit))
- if os.stat(log)[6] != 0L :
+ if os.stat(log)[6] != 0 :
f=open(log)
texte= f.read()
f.close()
except :
pass
- from monVisu import DVisu
+ from .monVisu import DVisu
titre = "conversion de "+ FichieraTraduire
monVisuDialg=DVisu(parent=editor.appliEficas,fl=0)
monVisuDialg.setWindowTitle(titre)
# Modules Python
# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QWidget
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
-from Extensions.i18n import tr
+from __future__ import absolute_import
+from __future__ import print_function
+from PyQt5.QtWidgets import QWidget
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
-from gereIcones import FacultatifOuOptionnel
+
+from .gereIcones import FacultatifOuOptionnel
import Accas
self.afficheMots()
self.listeMCAAjouter=[]
self.dictMCVenantDesBlocs={}
- if hasattr(self,'RBDeplie') and not monEnvQT5 : self.connect(self.RBDeplie,SIGNAL("clicked()"), self.Deplie)
- if hasattr(self,'RBPlie') and not monEnvQT5: self.connect(self.RBPlie,SIGNAL("clicked()"), self.Plie)
- if hasattr(self,'RBDeplie') and monEnvQT5: self.RBDeplie.clicked.connect(self.Deplie)
- if hasattr(self,'RBPlie') and monEnvQT5: self.RBPlie.clicked.connect( self.Plie)
+ if hasattr(self,'RBDeplie') : self.RBDeplie.clicked.connect(self.Deplie)
+ if hasattr(self,'RBPlie') : self.RBPlie.clicked.connect( self.Plie)
self.setAcceptDrops(True)
- #self.donneFocus()
def donneFocus(self):
for fenetre in self.listeFocus:
liste=self.liste_mc
for MC in self.liste_mc : self.dictMCVenantDesBlocs[MC]=self
while i < self.commandesLayout.count():
- from monWidgetBloc import MonWidgetBloc
+ from .monWidgetBloc import MonWidgetBloc
widget=self.commandesLayout.itemAt(i).widget()
i=i+1
if not(isinstance(widget,MonWidgetBloc)) : continue
widget.calculOptionnel()
listeW=widget.ajouteMCOptionnelDesBlocs()
- for MC in widget.dictMCVenantDesBlocs.keys():
- if MC in self.dictMCVenantDesBlocs.keys(): print "Pb Sur les MC"
+ for MC in widget.dictMCVenantDesBlocs:
+ if MC in self.dictMCVenantDesBlocs: print ("Pb Sur les MC" )
else : self.dictMCVenantDesBlocs[MC]=widget.dictMCVenantDesBlocs[MC]
liste=liste+listeW
return liste
listeNom=texteListeNom.split("+")[1:]
firstNode=None
for nom in listeNom:
- if nom not in self.dictMCVenantDesBlocs.keys():
+ if nom not in self.dictMCVenantDesBlocs:
#print "bizarre, bizarre"
self.editor.init_modif()
nouveau=self.node.append_child(nom)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
import re
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QToolButton, QToolTip
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+import six
+
+import os
+
+
+from PyQt5.QtWidgets import QToolButton, QToolTip
from Extensions.i18n import tr
class MonBoutonValide(QToolButton) :
def mouseDoubleClickEvent(self, event):
#print "dans mouseDoubleClickEvent"
- strRapport=unicode(self.parent.node.item.object.report())
+ strRapport=six.text_type(self.parent.node.item.object.report())
self.parent.editor._viewText(strRapport, "JDC_RAPPORT")
def mousePressEvent(self, event):
QToolTip.showText(event.globalPos(),myToolTip )
else :
t=""
- texte=unicode(self.parent.node.item.object.report())
+ texte=six.text_type(self.parent.node.item.object.report())
deb=1
for l in texte.split('\n')[2:-2]:
if re.match('^[\t !]*$',l) : continue
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
from desChoixCata import Ui_DChoixCata
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QDialog
-else:
- from PyQt4.QtGui import *
+from PyQt5.QtWidgets import QDialog
from Extensions.i18n import tr
# Import des panels
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
import os,sys,re
from desChoixCode import Ui_ChoixCode
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QDialog, QRadioButton, QGroupBox, QButtonGroup
- from PyQt5.QtGui import QPalette
- from PyQt5.QtCore import QProcess, QFileInfo, Qt, QSize
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QDialog, QRadioButton, QGroupBox, QButtonGroup
+from PyQt5.QtGui import QPalette
+from PyQt5.QtCore import QProcess, QFileInfo, Qt, QSize
# Import des panels
class MonChoixCode(Ui_ChoixCode,QDialog):
"""
- Classe définissant le panel associé aux mots-clés qui demandent
- à l'utilisateur de choisir une seule valeur parmi une liste de valeurs
- discrètes
+ Classe definissant le panel associe aux mots-cles qui demandent
+ a l'utilisateur de choisir une seule valeur parmi une liste de valeurs
+ discretes
"""
def __init__(self, parentAppli=None):
QDialog.__init__(self,parentAppli)
self.parentAppli=parentAppli
self.verifieInstall()
self.code=None
- if monEnvQT5:
- self.pB_OK.clicked.connect(self.choisitCode)
- self.pB_cancel.clicked.connect(self.sortie)
- else :
- self.connect(self.pB_OK,SIGNAL("clicked()"),self.choisitCode)
- self.connect(self.pB_cancel,SIGNAL("clicked()"),self.sortie)
+ self.pB_OK.clicked.connect(self.choisitCode)
+ self.pB_cancel.clicked.connect(self.sortie)
def sortie(self):
QDialog.reject(self)
def verifieInstall(self):
self.groupCodes=QButtonGroup(self.groupBox)
- vars=os.environ.items()
+ vars=list(os.environ.items())
listeCode=('Aster','Adao','Carmel3D','CarmelCND','CF','MAP','MT','PSEN','PSEN_N1','Telemac','ZCracks',)
for code in listeCode:
dirCode=os.path.abspath(os.path.join(os.path.abspath(__file__),'../..',code))
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
from desChoixCommandes import Ui_ChoixCommandes
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QWidget, QAction ,QButtonGroup, QRadioButton, QLabel
- from PyQt5.QtGui import QIcon
- from PyQt5.QtCore import QSize
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QWidget, QAction ,QButtonGroup, QRadioButton, QLabel , QPushButton, QSpacerItem, QSizePolicy, QGridLayout
+from PyQt5.QtGui import QIcon, QPixmap
+from PyQt5.QtCore import QSize, QRect
from Extensions.i18n import tr
import os
self.editor.appliEficas.setWindowTitle(nouveauTitre)
- if monEnvQT5 :
- self.RBalpha.clicked.connect(self.afficheAlpha)
- self.RBGroupe.clicked.connect(self.afficheGroupe)
- self.RBOrdre.clicked.connect(self.afficheOrdre)
- self.RBClear.clicked.connect(self.clearFiltre)
- self.RBCasse.toggled.connect(self.ajouteRadioButtons)
- self.LEFiltre.returnPressed.connect(self.ajouteRadioButtons)
- self.LEFiltre.textChanged.connect(self.ajouteRadioButtons)
- else :
- self.connect(self.RBalpha,SIGNAL("clicked()"),self.afficheAlpha)
- self.connect(self.RBGroupe,SIGNAL("clicked()"),self.afficheGroupe)
- self.connect(self.RBOrdre,SIGNAL("clicked()"),self.afficheOrdre)
- self.connect(self.RBClear,SIGNAL("clicked()"),self.clearFiltre)
- self.connect(self.RBCasse,SIGNAL("toggled(bool)"),self.ajouteRadioButtons)
- self.connect(self.LEFiltre,SIGNAL("returnPressed()"),self.ajouteRadioButtons)
+ self.RBalpha.clicked.connect(self.afficheAlpha)
+ self.RBGroupe.clicked.connect(self.afficheGroupe)
+ self.RBOrdre.clicked.connect(self.afficheOrdre)
+ self.RBClear.clicked.connect(self.clearFiltre)
+ self.RBCasse.toggled.connect(self.ajouteRadioButtons)
+ self.LEFiltre.returnPressed.connect(self.ajouteRadioButtons)
+ self.LEFiltre.textChanged.connect(self.ajouteRadioButtons)
+
if self.node.tree.item.get_regles() == () :
self.RBRegle.close()
self.labelRegle.close()
else :
- if monEnvQT5 : self.RBRegle.clicked.connect(self.afficheRegle)
- else : self.connect(self.RBRegle,SIGNAL("clicked()"),self.afficheRegle)
+ self.RBRegle.clicked.connect(self.afficheRegle)
if self.editor.Ordre_Des_Commandes == None : self.RBOrdre.close()
self.RBOrdre.setChecked(True);
self.afficheOrdre()
if self.editor.closeFrameRechercheCommande == True : self.frameAffichage.close()
- self.editor.restoreSplitterSizes(2)
+
+ if self.editor.widgetTree != None : self.editor.restoreSplitterSizes(2)
+ else: self.editor.restoreSplitterSizes(3)
def afficheRegle(self):
self.node.tree.AppelleBuildLBRegles()
self.affiche_ordre=1
self.ajouteRadioButtons()
- def mouseDoubleClickEvent(self,event):
+ def insereNoeudApresClick(self,event):
#print self.editor.Classement_Commandes_Ds_Arbre
#if self.editor.Classement_Commandes_Ds_Arbre!= () : self.chercheOu()
+ #print ('dans insereNoeudApresClick')
nodeCourrant=self.node.tree.currentItem()
if nodeCourrant==None: nodeCourrant=self.node.tree.racine
if self.name != None :
self.node.setSelected(False)
nouveau.setSelected(True)
self.node.tree.setCurrentItem(nouveau)
- event.accept()
+ if event != None : event.accept()
def creeListeCommande(self,filtre):
listeGroupes,dictGroupes=self.jdc.get_groups()
sensibleALaCasse=self.RBCasse.isChecked()
- if "CACHE" in dictGroupes.keys():
+ if "CACHE" in dictGroupes:
aExclure=dictGroupes["CACHE"]
else:
aExclure=()
return listeACreer
def ajouteRadioButtons(self):
+ if self.editor.nombreDeBoutonParLigne != 0 :
+ self.ajoutePushButtons()
+ return
#print 'ds ajouteRadioButtons'
filtre=str(self.LEFiltre.text())
if filtre==str("") : filtre=None
self.dicoCmd[tr(cmd)]=cmd
rbcmd=(QRadioButton(tr(cmd)))
self.buttonGroup.addButton(rbcmd)
+ rbcmd.mouseDoubleClickEvent=self.insereNoeudApresClick
self.commandesLayout.addWidget(rbcmd)
- rbcmd.mouseDoubleClickEvent=self.mouseDoubleClickEvent
- if monEnvQT5:
- self.buttonGroup.buttonClicked.connect(self.rbClique)
- else :
- self.connect(self.buttonGroup, SIGNAL("buttonClicked(QAbstractButton*)"),self.rbClique)
+ self.buttonGroup.buttonClicked.connect(self.rbClique)
elif self.affiche_groupe==1 :
listeGroupes,dictGroupes=self.jdc.get_groups()
for grp in listeGroupes:
if grp == "CACHE" : continue
label=QLabel(self)
- if monEnvQT5 :
- text=tr('<html><head/><body><p><span style=\" font-weight:600;\">Groupe : '+tr(grp)+'</span></p></body></html>')
- else :
- text=QString.fromUtf8('<html><head/><body><p><span style=\" font-weight:600;\">Groupe : '+tr(grp)+'</span></p></body></html>')
+ text=tr('<html><head/><body><p><span style=\" font-weight:600;\">Groupe : '+tr(grp)+'</span></p></body></html>')
label.setText(text)
self.listeWidget.append(label)
aAjouter=1
rbcmd=(QRadioButton(tr(cmd)))
self.buttonGroup.addButton(rbcmd)
self.commandesLayout.addWidget(rbcmd)
- rbcmd.mouseDoubleClickEvent=self.mouseDoubleClickEvent
- if monEnvQT5:
- self.buttonGroup.buttonClicked.connect(self.rbClique)
- else :
- self.connect(self.buttonGroup, SIGNAL("buttonClicked(QAbstractButton*)"),self.rbClique)
+ rbcmd.mouseDoubleClickEvent=self.insereNoeudApresClick
+ self.buttonGroup.buttonClicked.connect(self.rbClique)
label2=QLabel(self)
label2.setText(" ")
self.listeWidget.append(label2)
rbcmd=(QRadioButton(tr(cmd)))
self.buttonGroup.addButton(rbcmd)
self.commandesLayout.addWidget(rbcmd)
- rbcmd.mouseDoubleClickEvent=self.mouseDoubleClickEvent
- if monEnvQT5:
- self.buttonGroup.buttonClicked.connect(self.rbClique)
- else :
- self.connect(self.buttonGroup, SIGNAL("buttonClicked(QAbstractButton*)"),self.rbClique)
+ rbcmd.mouseDoubleClickEvent=self.insereNoeudApresClick
+ self.buttonGroup.buttonClicked.connect(self.rbClique)
+ def ajoutePushButtons(self):
+ if hasattr(self,'buttonGroup') :
+ for b in self.buttonGroup.buttons():
+ self.buttonGroup.removeButton(b)
+ b.setParent(None)
+ b.close()
+ else :
+ self.buttonGroup = QButtonGroup()
+ self.buttonGroup.buttonClicked.connect(self.rbCliqueEtInsere)
+ for w in self.listeWidget :
+ w.setParent(None)
+ w.close()
+ self.listeWidget=[]
+
+ if not hasattr(self,'maGrilleBouton') :
+ #self.commandesLayout.close()
+ self.maGrilleBouton=QGridLayout()
+ self.maGrilleBouton.setSpacing(20)
+ self.verticalLayout.addLayout(self.maGrilleBouton)
+ col=-1
+ ligne = 0
+ if self.affiche_alpha==1 :
+ liste=self.creeListeCommande(None)
+ for cmd in liste :
+ col=col+1
+ if col == self.editor.nombreDeBoutonParLigne :
+ col=0
+ ligne=ligne+1
+ self.dicoCmd[tr(cmd)]=cmd
+ rbcmd=QPushButton(tr(cmd))
+ rbcmd.setGeometry(QRect(40, 20, 211, 71))
+ rbcmd.setMaximumSize(QSize(250, 81))
+ rbcmd.setStyleSheet("background-color : rgb(168, 227, 142);\n"
+"/*border-style : outset;*/\n"
+"border-radius : 20px;\n"
+"border-width : 30 px;\n"
+"border-color : beige;\n"
+"text-align : left")
+ icon = QIcon()
+ icon.addPixmap(QPixmap("../monCode/images/essaiAster.png"), QIcon.Normal, QIcon.Off)
+ rbcmd.setIcon(icon)
+ rbcmd.setIconSize(QSize(48, 48))
+
+ self.buttonGroup.addButton(rbcmd)
+ self.maGrilleBouton.addWidget(rbcmd,ligne,col)
def clearFiltre(self):
self.LEFiltre.setText("")
self.ajouteRadioButtons()
+ def rbCliqueEtInsere(self,id):
+ self.rbClique(id)
+ self.insereNoeudApresClick(None)
+
def rbClique(self,id):
+ #print ('ds rbClique')
self.name=self.dicoCmd[str(id.text())]
definitionEtape=getattr(self.jdc.cata[0],self.name)
commentaire=getattr(definitionEtape,self.jdc.lang)
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
import os,sys,re
from desChoixLangue import Ui_ChoixLangue
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QDialog, QRadioButton, QGroupBox, QButtonGroup
- from PyQt5.QtGui import QPalette
- from PyQt5.QtCore import QProcess, QFileInfo, Qt, QSize
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+
+from PyQt5.QtWidgets import QDialog, QRadioButton, QGroupBox, QButtonGroup
+from PyQt5.QtGui import QPalette
+from PyQt5.QtCore import QProcess, QFileInfo, Qt, QSize
# Import des panels
class MonChoixLangue(Ui_ChoixLangue,QDialog):
"""
- Classe définissant le panel associé aux mots-clés qui demandent
- à l'utilisateur de choisir une seule valeur parmi une liste de valeurs
- discrètes
+ Classe definissant le panel associe aux mots-cles qui demandent
+ a l'utilisateur de choisir une seule valeur parmi une liste de valeurs
+ discretes
"""
def __init__(self, parentAppli=None):
QDialog.__init__(self,parentAppli)
self.parentAppli=parentAppli
self.installLangue()
self.code=None
- if monEnvQT5: self.pB_OK.clicked.connect(self.choisitLangue)
- else : self.connect(self.pB_OK,SIGNAL("clicked()"),self.choisitLangue)
+ self.pB_OK.clicked.connect(self.choisitLangue)
def installLangue(self):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
-if monEnvQT5:
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import range
+except : pass
+
+import types,os
+from six.moves import range
+from PyQt5.QtCore import Qt
# Modules Eficas
-from qtSaisie import SaisieValeur
+from .qtSaisie import SaisieValeur
from monPlusieursBasePanel import MonPlusieursBasePanel
from Extensions.i18n import tr
# Import des panels
class MonFonctionPanel(MonPlusieursBasePanel):
-# Classe definissant le panel associe© aux mots-cles qui demandent
+# Classe definissant le panel associee aux mots-cles qui demandent
# a l'utilisateur de choisir une seule valeur parmi une liste de valeurs
# discretes
def __init__(self,node, parent = None,name = None,fl = 0):
self.LBValeurs.addItem(str_valeur)
else :
for valeur in self.DecoupeListeValeurs(listeValeurs):
- if type(valeur) == types.TupleType:
+ if type(valeur) == tuple:
TupleEnTexte="("
for val in valeur :
TupleEnTexte = TupleEnTexte + str(self.politique.GetValeurTexte(val)) +", "
else :
listeATraiter=self.DecoupeListeValeurs(listeRetour)
for valeur in listeATraiter :
- if type(valeur) == types.TupleType:
+ if type(valeur) == tuple:
TupleEnTexte="("
for val in valeur :
TupleEnTexte = TupleEnTexte + str(self.politique.GetValeurTexte(val)) +", "
# Modules Python
# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QCheckBox, QWidget, QLabel
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from __future__ import absolute_import
+from PyQt5.QtWidgets import QCheckBox, QWidget, QLabel
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
from desGroupeOptionnel import Ui_groupeOptionnel
def mouseDoubleClickEvent(self, event):
#print "dans mouseDoubleClickEvent", self
- if self not in self.monOptionnel.dicoCb.keys() :
+ if self not in self.monOptionnel.dicoCb:
event.accept()
return
listeCheckedMC="+"+self.monOptionnel.dicoCb[self]
def afficheTitre(self):
labeltext,fonte,couleur = self.parentMC.node.item.GetLabelText()
+ print (labeltext)
l=tr(labeltext)
li=[]
while len(l) > 25:
li.append(l)
texte=""
for l in li : texte+=l+"\n"
- texte=texte[0:-2]
+ texte=texte[0:-1]
self.MCLabel.setText(texte)
def affiche(self,liste):
liste.reverse()
for mot in liste :
cb = monButtonCustom(mot,self)
- if monEnvQT5:
- cb.clicked.connect(cb.ajoutAideMC)
- else :
- self.connect(cb,SIGNAL("clicked()"), cb.ajoutAideMC)
+ cb.clicked.connect(cb.ajoutAideMC)
self.MCOptionnelLayout.insertWidget(0,cb)
self.dicoCb[cb]=mot
self.scrollAreaCommandesOptionnelles.horizontalScrollBar().setSliderPosition(0)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QLabel, QFrame
- from PyQt5.QtCore import QEvent
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from __future__ import print_function
+from __future__ import absolute_import
+
+import os
+
+
+from PyQt5.QtWidgets import QLabel, QFrame
+from PyQt5.QtCore import QEvent
from Extensions.i18n import tr
#from Extensions.i18n import tr
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
from desRecherche import Ui_desRecherche
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QDialog
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QDialog
+from PyQt5.QtCore import Qt
# Import des panels
class DRecherche(Ui_desRecherche ,QDialog):
"""
- Classe définissant le panel associé aux mots-clés qui demandent
- à l'utilisateur de choisir une seule valeur parmi une liste de valeurs
- discrètes
"""
def __init__(self,parent = None , name = None,fl = 0):
QDialog.__init__(self,parent)
self.setupUi(self)
self.PBSuivant.setDefault(True)
self.PBSuivant.setAutoDefault(False)
- if monEnvQT5 :
- self.PBSuivant.clicked.connect( self.suivantClicked)
- self.LERecherche.returnPressed.connect(self.recherche)
- else :
- self.connect(self.PBSuivant,SIGNAL("clicked()"), self.suivantClicked)
- self.connect(self.LERecherche,SIGNAL("returnPressed()"),self.recherche)
+ self.PBSuivant.clicked.connect( self.suivantClicked)
+ self.LERecherche.returnPressed.connect(self.recherche)
self.surLigne=0
self.listeTrouvee=()
self.nodeSurligne=None
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
from desRechercheCatalogue import Ui_desRechercheCatalogue
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QDialog, QCompleter
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QDialog, QCompleter
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
class DRechercheCatalogue (Ui_desRechercheCatalogue ,QDialog):
"""
- Classe définissant le panel associé aux mots-clés qui demandent
- à l'utilisateur de choisir une seule valeur parmi une liste de valeurs
- discrètes
"""
def __init__(self,parent,editor ):
QDialog.__init__(self,parent)
self.setupUi(self)
self.editor=editor
self.CBRecherche.setEditable(True)
- if monEnvQT5 :
- self.CBRecherche.lineEdit().returnPressed.connect(self.rechercheCB)
- self.CBRecherche.currentIndexChanged.connect(self.rechercheCB)
- else :
- self.connect(self.CBRecherche.lineEdit(),SIGNAL("returnPressed()"),self.rechercheCB)
- self.connect(self.CBRecherche,SIGNAL("currentIndexChanged(int)"),self.rechercheCB)
+ self.CBRecherche.lineEdit().returnPressed.connect(self.rechercheCB)
+ self.CBRecherche.currentIndexChanged.connect(self.rechercheCB)
self.initRecherche()
def initRecherche(self):
- listeChoix=self.editor.readercata.dicoInverse.keys()
+ listeChoix=list(self.editor.readercata.dicoInverse.keys())
self.CBRecherche.addItem("")
for choix in listeChoix:
self.CBRecherche.addItem(choix)
def recherche(self,motAChercher):
if str(motAChercher)=="" or str(motAChercher) == None : return
- if str(motAChercher) not in self.editor.readercata.dicoInverse.keys():return
+ if str(motAChercher) not in self.editor.readercata.dicoInverse:return
try :
#if 1 :
genea= self.editor.readercata.dicoInverse[str(motAChercher)]
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
from desSelectVal import Ui_DSelVal
from Extensions.i18n import tr
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QDialog, QFileDialog
- from PyQt5.QtCore import QTimer, Qt
- from PyQt5.QtGui import QPalette
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
- from PyQt4.QtGui import QPalette
+from PyQt5.QtWidgets import QDialog, QFileDialog
+from PyQt5.QtCore import QTimer, Qt
+from PyQt5.QtGui import QPalette
class DSelVal(Ui_DSelVal,QDialog):
def __init__(self,parent ,modal ) :
self.file=str(file)
self.readVal()
self.initVal()
- if monEnvQT5: self.connecterSignaux()
- else : self.connecterSignauxQT4()
+ self.connecterSignaux()
def connecterSignaux(self) :
self.Bespace.clicked.connect(self.SelectEsp)
def readVal(self):
if self.file == "" : return
- f = open(self.file, "rb")
+ f = open(self.file, "r")
self.texte = f.read()
f.close()
self.Traitement()
def Traitement(self):
- import string
if self.textTraite == "" : return
if self.textTraite[-1]=="\n" : self.textTraite=self.textTraite[0:-1]
- self.textTraite=string.replace(self.textTraite,"\n",self.separateur)
+ self.textTraite=self.textTraite.replace("\n",self.separateur)
liste1=self.textTraite.split(self.separateur)
liste=[]
for val in liste1 :
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
import traceback
from Extensions.i18n import tr
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtCore import Qt
- from PyQt5.QtWidgets import QDialog, QListWidgetItem
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QDialog, QListWidgetItem
from desViewRegles import Ui_viewRegles
# ------------------------------------ #
QDialog.__init__(self,parent)
self.setupUi(self)
self.setModal(False)
- if monEnvQT5 : self.bclose.clicked.connect(self.close)
- else : self.connect( self.bclose,SIGNAL("clicked()"), self, SLOT("close()") )
+ self.bclose.clicked.connect(self.close)
if entete != None : self.setWindowTitle (entete)
for ligne in liste :
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+import types,os
import traceback
from Extensions.i18n import tr
+import six
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QDialog, QMessageBox, QFileDialog
- from PyQt5.QtCore import QSize
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QDialog, QMessageBox, QFileDialog
+from PyQt5.QtCore import QSize
from desViewTexte import Ui_dView
# ------------------------------- #
self.setupUi(self)
self.resize( QSize(largeur,hauteur).expandedTo(self.minimumSizeHint()) )
- if monEnvQT5 :
- self.bclose.clicked.connect(self.close)
- self.bsave.clicked.connect(self.saveFile )
- else :
- self.connect( self.bclose,SIGNAL("clicked()"), self, SLOT("close()") )
- self.connect( self.bsave,SIGNAL("clicked()"), self.saveFile )
+ self.bclose.clicked.connect(self.close)
+ self.bsave.clicked.connect(self.saveFile )
+
if entete != None : self.setWindowTitle (entete)
if entete != None : self.setText (texte)
fn = QFileDialog.getSaveFileName(None,
tr("Sauvegarder le fichier"),
dir)
- if monEnvQT5 : fn=fn[0]
+ fn=fn[0]
if fn == "" : return
if fn == None : return (0, None)
- ulfile = os.path.abspath(unicode(fn))
+ ulfile = os.path.abspath(six.text_type(fn))
if self.editor != None :
self.editor.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
try:
- f = open(fn, 'wb')
+ f = open(fn, 'w')
f.write(str(self.view.toPlainText()))
f.close()
return 1
return
-
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
from desVisu import Ui_DVisu
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QDialog
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QDialog
# Import des panels
class DVisu(Ui_DVisu ,QtGui.QDialog):
"""
- Classe définissant le panel associé aux mots-clés qui demandent
- à l'utilisateur de choisir une seule valeur parmi une liste de valeurs
- discrètes
"""
def __init__(self,parent = None , name = None,fl = 0):
QtGui.QDialog.__init__(self,parent)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
# Modules Eficas
from Extensions.i18n import tr
-from monWidgetRadioButton import MonWidgetRadioButtonCommun
+from .monWidgetRadioButton import MonWidgetRadioButtonCommun
from desWidget4a6RadioButton import Ui_Widget4a6RadioButton
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
# Modules Eficas
from Extensions.i18n import tr
-from monWidgetRadioButton import MonWidgetRadioButtonCommun
+from .monWidgetRadioButton import MonWidgetRadioButtonCommun
from desWidget4a6RadioButton import Ui_Widget4a6RadioButton
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
from desWidgetBloc import Ui_WidgetBloc
-from groupe import Groupe
+from .groupe import Groupe
from Extensions.i18n import tr
# Import des panels
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+import types,os
# Modules Eficas
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetCB import Ui_WidgetCB
-from politiquesValidation import PolitiqueUnique
-from qtSaisie import SaisieValeur
+from .politiquesValidation import PolitiqueUnique
+from .qtSaisie import SaisieValeur
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QComboBox, QCompleter
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QComboBox, QCompleter
+from PyQt5.QtCore import Qt
class MonWidgetCBCommun (Ui_WidgetCB,Feuille):
self.politique=PolitiqueUnique(self.node,self.editor)
self.determineChoix()
self.setValeursApresBouton()
- if monEnvQT5:
- self.CBChoix.currentIndexChanged.connect(self.ChoixSaisi)
- else :
- self.connect(self.CBChoix,SIGNAL("currentIndexChanged(int)"),self.ChoixSaisi)
+ self.CBChoix.currentIndexChanged.connect(self.ChoixSaisi)
#self.CBChoix.lineEdit().setText(tr("Select"))
self.parentQt.commandesLayout.insertWidget(-1,self)
self.maCommande.listeAffichageWidget.append(self.CBChoix)
+ self.AAfficher=self.CBChoix
def setValeursApresBouton(self):
self.CBChoix.lineEdit().setText(tr("Select"))
return
valeur=self.objSimp.get_valeur()
- if not(type(valeur) in types.StringTypes) : valeur=str(valeur)
+ if not(type(valeur) == str) : valeur=str(valeur)
self.CBChoix.setCurrentIndex(self.CBChoix.findText(valeur))
def determineChoix(self):
- if monEnvQT5: listeChoix=[]
- else : listeChoix=QStringList()
+ listeChoix=[]
for choix in self.maListeDeValeur:
- if not(type(choix) in types.StringTypes) : choix=str(choix)
- if monEnvQT5: listeChoix.append(choix)
- else : listeChoix<<choix
+ if not(type(choix) == str) : choix=str(choix)
+ listeChoix.append(choix)
self.CBChoix.addItem(choix)
self.CBChoix.setEditable(True)
monCompleteur=QCompleter(listeChoix,self)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+import types,os
# Modules Eficas
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetCB import Ui_WidgetCB
-from politiquesValidation import PolitiqueUnique
-from qtSaisie import SaisieValeur
+from .politiquesValidation import PolitiqueUnique
+from .qtSaisie import SaisieValeur
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QComboBox, QCompleter
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QComboBox, QCompleter
class MonWidgetCB (Ui_WidgetCB,Feuille):
self.politique=PolitiqueUnique(self.node,self.editor)
self.determineChoix()
self.setValeursApresBouton()
- if monEnvQT5:
- self.CBChoix.currentIndexChanged.connect(self.ChoixSaisi)
- else :
- self.connect(self.CBChoix,SIGNAL("currentIndexChanged(int)"),self.ChoixSaisi)
+ self.CBChoix.currentIndexChanged.connect(self.ChoixSaisi)
self.parentQt.commandesLayout.insertWidget(-1,self)
self.maCommande.listeAffichageWidget.append(self.CBChoix)
self.CBChoix.setCurrentIndex(-1)
return
valeur=self.objSimp.get_valeur()
- if not(type(valeur) in types.StringTypes) : valeur=str(valeur)
+ if not(type(valeur) == str) : valeur=str(valeur)
self.CBChoix.setCurrentIndex(self.CBChoix.findText(valeur))
def determineChoix(self):
- if monEnvQT5:
- self.CBChoix.currentIndexChanged.connect(self.ChoixSaisi)
- else :
- self.connect(self.CBChoix,SIGNAL("currentIndexChanged(int)"),self.ChoixSaisi
+ self.CBChoix.currentIndexChanged.connect(self.ChoixSaisi)
for choix in self.monSimpDef.into:
- if not(type(choix) in types.StringTypes) : choix=str(choix)
- if monEnvQT5: self.CBChoix.currentIndexChanged.connect(self.ChoixSaisi)
- else : self.connect(self.CBChoix,SIGNAL("currentIndexChanged(int)"),self.ChoixSaisi)
+ if not(type(choix) == str) : choix=str(choix)
+ self.CBChoix.currentIndexChanged.connect(self.ChoixSaisi)
self.CBChoix.addItem(choix)
self.CBChoix.setEditable(True)
monCompleteur=QCompleter(listeChoix,self)
#
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
import types
from desWidgetCommande import Ui_WidgetCommande
-from groupe import Groupe
-from gereIcones import FacultatifOuOptionnel
-from determine import monEnvQT5
+from .groupe import Groupe
+from .gereIcones import FacultatifOuOptionnel
-if monEnvQT5:
- from PyQt5.QtWidgets import QApplication, QWidget, QSpacerItem, QSizePolicy
- from PyQt5.QtGui import QFont, QIcon
- from PyQt5.QtCore import QTimer
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QApplication, QWidget, QSpacerItem, QSizePolicy
+from PyQt5.QtGui import QFont, QIcon
+from PyQt5.QtCore import QTimer
from Extensions.i18n import tr
import Accas
import os
-import string
# Import des panels
self.frameAffichage.resize(self.frameAffichage.width(),50)
#if (etape.get_type_produit()==None): self.LENom.close()
- test,mess = self.node.item.nomme_sd('ee')
+ #test,mess = self.node.item.nomme_sd('ee')
if not(hasattr(etape.definition,'sd_prod')) or (etape.definition.sd_prod==None): self.LENom.close()
elif (hasattr(etape.definition,'sd_prod') and type(etape.definition.sd_prod)== types.FunctionType):self.LENom.close()
elif (hasattr(etape, 'sdnom')) and etape.sdnom != "sansnom" and etape.sdnom != None: self.LENom.setText(etape.sdnom)
if self.editor.closeFrameRechercheCommande==True : self.closeAutreCommande()
else :
- if monEnvQT5 :
- try :
+ try :
self.bCatalogue.clicked.connect(self.afficheCatalogue)
self.bAvant.clicked.connect(self.afficheAvant)
self.bApres.clicked.connect(self.afficheApres)
- except :
+ except :
pass
- self.LENom.returnPressed.connect(self.nomChange)
- else :
- try :
- self.connect(self.bCatalogue,SIGNAL("clicked()"), self.afficheCatalogue)
- self.connect(self.bAvant,SIGNAL("clicked()"), self.afficheAvant)
- self.connect(self.bApres,SIGNAL("clicked()"), self.afficheApres)
- except :
- pass
- self.connect(self.LENom,SIGNAL("returnPressed()"),self.nomChange)
+ self.LENom.returnPressed.connect(self.nomChange)
if self.editor.code in ['Adao','ADAO'] and self.editor.closeFrameRechercheCommande==True :
self.frameAffichage.close()
self.RBPoubelle.close() # JDC Fige
return # Pas de MC Optionnels pour Carmel
- from monWidgetOptionnel import MonWidgetOptionnel
+ from .monWidgetOptionnel import MonWidgetOptionnel
if self.editor.widgetOptionnel!= None :
self.monOptionnel=self.editor.widgetOptionnel
else :
+ self.editor.inhibeSplitter=1
self.monOptionnel=MonWidgetOptionnel(self.editor)
self.editor.widgetOptionnel=self.monOptionnel
self.editor.splitter.addWidget(self.monOptionnel)
self.editor.ajoutOptionnel()
+ self.editor.inhibeSplitter=0
self.afficheOptionnel()
#self.editor.restoreSplitterSizes()
i=i+1
# si on boucle on perd l'ordre
+ def afficheNieme(self,n):
+ #print ('ds afficheNieme')
+ self.listeAffichageWidget[n].setFocus(7)
+
def afficheSuivant(self,f):
+ #print ('ds afficheSuivant')
try :
i=self.listeAffichageWidget.index(f)
next=i+1
def nomChange(self):
nom = str(self.LENom.text())
- nom = string.strip(nom)
+ nom = nom.strip()
if nom == '' : return # si pas de nom, on ressort sans rien faire
test,mess = self.node.item.nomme_sd(nom)
self.editor.affiche_commentaire(mess)
#Notation scientifique
if test :
- from politiquesValidation import Validation
+ from .politiquesValidation import Validation
validation=Validation(self.node,self.editor)
validation.AjoutDsDictReelEtape()
# Modules Python
# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QWidget
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+from PyQt5.QtWidgets import QWidget
+from PyQt5.QtCore import Qt
from desWidgetCommentaire import Ui_WidgetCommentaire
-from gereIcones import FacultatifOuOptionnel
+from .gereIcones import FacultatifOuOptionnel
from Extensions.i18n import tr
import Accas
import os
-import string
# Import des panels
self.remplitTexte()
self.monOptionnel=None
- if monEnvQT5 :
- self.commentaireTE.textChanged.connect(self.TexteCommentaireEntre)
- #if self.editor.code in ['MAP','CARMELCND','CF'] : self.bCatalogue.close()
- if self.editor.code in ['MAP','CARMELCND'] : self.bCatalogue.close()
- else : self.bCatalogue.clicked.connect(self.afficheCatalogue)
- #if self.editor.code in ['Adao','MAP','CF'] :
- if self.editor.code in ['Adao','MAP','ADAO'] :
- self.bAvant.close()
- self.bApres.close()
- else :
- self.bAvant.clicked.connect(self.afficheAvant)
- self.bApres.clicked.connect(self.afficheApres)
+ self.commentaireTE.textChanged.connect(self.TexteCommentaireEntre)
+ if self.editor.code in ['MAP','CARMELCND'] : self.bCatalogue.close()
+ else : self.bCatalogue.clicked.connect(self.afficheCatalogue)
+ if self.editor.code in ['Adao','MAP','ADAO'] :
+ self.bAvant.close()
+ self.bApres.close()
else :
- if self.editor.code in ['MAP','CARMELCND'] : self.bCatalogue.close()
- else : self.connect(self.bCatalogue,SIGNAL("clicked()"), self.afficheCatalogue)
- if self.editor.code in ['Adao','MAP','ADAO'] :
- self.bAvant.close()
- self.bApres.close()
- else :
- self.connect(self.bAvant,SIGNAL("clicked()"), self.afficheAvant)
- self.connect(self.bApres,SIGNAL("clicked()"), self.afficheApres)
+ self.bAvant.clicked.connect(self.afficheAvant)
+ self.bApres.clicked.connect(self.afficheApres)
self.editor.fermeOptionnel()
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os,re
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
+
+import types,os,re
+from six.moves import range
pattern_name = re.compile(r'^[^\d\W]\w*\Z')
# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QDialog
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QDialog, QMessageBox
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
from desWidgetCreeParam import Ui_desWidgetCreeParam
self.editor.affiche_infos("")
QDialog.__init__(self,editor)
self.setupUi(self)
- if monEnvQT5 : self.connecterSignaux()
- else : self.connecterSignauxQT4()
+ self.connecterSignaux()
self.dejaExistant=0
self.listeTousParam=self.editor.jdc.params
self.dictListe={}
def connecterSignaux(self) :
self.lineEditVal.returnPressed.connect(self.lineEditValReturnPressed)
self.lineEditNom.returnPressed.connect(self.lineEditNomReturnPressed)
+ self.LBParam.itemDoubleClicked.connect(self.paramClicked)
+
+ def paramClicked(self,item):
+ if self.editor.nodeEnCours == None :
+ QMessageBox.warning( self, tr("Pas de Mot-Clef"),tr("Attention! selectionnez un mot-clef"))
+ return
+ param= self.dictListe[item.text()]
+ self.editor.nodeEnCours.lineEditVal.setText(param)
+ self.editor.nodeEnCours.LEValeurPressed()
+
def CreeParametre(self):
nom=str(self.lineEditNom.text())
param.item.set_valeur(self.val)
param.update_node_texte()
param.update_node_valid()
- self.LBParam.addItem((repr(param.item)))
- param.select()
+ self.LBParam.addItem((repr(param.item.object)))
+ self.dictListe[repr(param.item.object)] = param.item.object.nom
self.lineEditVal.setText("")
self.lineEditNom.setText("")
self.lineEditNom.setFocus(True)
valString=str(self.lineEditVal.text())
self.val=""
contexte={}
- exec "from math import *" in contexte
+ exec("from math import *", contexte)
jdc=self.editor.jdc
if jdc == None :
self.editor.affiche_infos(tr(u"La Creation de parametre n est possible que dans un jeu de donnees"),Qt.red)
for p in jdc.params :
try:
tp=p.nom+'='+str(repr(p.valeur))
- exec tp in contexte
+ exec(tp, contexte)
except :
pass
monTexte="monParam="+valString
try :
- exec monTexte in contexte
+ exec(monTexte, contexte)
self.val=valString
except :
try :
self.LBParam.clear()
for param in self.listeTousParam :
self.LBParam.addItem((repr(param)))
- self.dictListe[repr(param)] = param
-
+ self.dictListe[repr(param)] = param.nom
+
+
+
def valideParam(self):
if self.LBParam.selectedItems()== None : return
lParam=[]
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
# Modules Eficas
from Extensions.i18n import tr
-from feuille import Feuille
-from monWidgetSimpTuple import MonWidgetSimpTuple
+from .feuille import Feuille
+from .monWidgetSimpTuple import MonWidgetSimpTuple
from desWidgetDate import Ui_WidgetDate
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtCore import Qt, QTimer
- from PyQt5.QtWidgets import QWidget
-else :
- from PyQt4.QtCore import *
- from PyQt4.QtGui import *
+from __future__ import absolute_import
+from PyQt5.QtCore import Qt, QTimer
+from PyQt5.QtWidgets import QWidget
# Modules Eficas
-from groupe import Groupe
+from .groupe import Groupe
from desWidgetFact import Ui_WidgetFact
from Extensions.i18n import tr
# Import des panels
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
from desWidgetFactPlie import Ui_WidgetFactPlie
-from groupe import Groupe
+from .groupe import Groupe
from Extensions.i18n import tr
# Import des panels
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
from desWidgetFormule import Ui_WidgetFormule
-from gereIcones import FacultatifOuOptionnel
-from determine import monEnvQT5
+from .gereIcones import FacultatifOuOptionnel
-if monEnvQT5:
- from PyQt5.QtWidgets import QWidget
- from PyQt5.QtGui import QIcon
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QWidget
+from PyQt5.QtGui import QIcon
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
import Accas
import os
-import string
# Import des panels
self.setValide()
- if monEnvQT5 :
- #if self.editor.code in ['MAP','CARMELCND','CF'] : self.bCatalogue.close()
- if self.editor.code in ['MAP','CARMELCND'] : self.bCatalogue.close()
- else : self.bCatalogue.clicked.connect(self.afficheCatalogue)
- #if self.editor.code in ['Adao','MAP','CF'] :
- if self.editor.code in ['Adao','MAP','ADAO'] :
- self.bAvant.close()
- self.bApres.close()
- else :
- self.bAvant.clicked.connect(self.afficheAvant)
- self.bApres.clicked.connect(self.afficheApres)
- self.LENom.returnPressed.connect(self.nomChange)
- self.LENomFormule.returnPressed.connect(self.NomFormuleSaisi)
- self.LENomsArgs.returnPressed.connect(self.argsSaisis)
- self.LECorpsFormule.returnPressed.connect(self.FormuleSaisie)
+ if self.editor.code in ['MAP','CARMELCND'] : self.bCatalogue.close()
+ else : self.bCatalogue.clicked.connect(self.afficheCatalogue)
+ if self.editor.code in ['Adao','MAP','ADAO'] :
+ self.bAvant.close()
+ self.bApres.close()
else :
- if self.editor.code in ['MAP','CARMELCND'] : self.bCatalogue.close()
- else : self.connect(self.bCatalogue,SIGNAL("clicked()"), self.afficheCatalogue)
- if self.editor.code in ['Adao','MAP'] :
- self.bAvant.close()
- self.bApres.close()
- else :
- self.connect(self.bAvant,SIGNAL("clicked()"), self.afficheAvant)
- self.connect(self.bApres,SIGNAL("clicked()"), self.afficheApres)
- self.connect(self.LENom,SIGNAL("returnPressed()"),self.nomChange)
- self.connect(self.LENomFormule,SIGNAL("returnPressed()"),self.NomFormuleSaisi)
- self.connect(self.LENomsArgs,SIGNAL("returnPressed()"),self.argsSaisis)
- self.connect(self.LECorpsFormule,SIGNAL("returnPressed()"),self.FormuleSaisie)
+ self.bAvant.clicked.connect(self.afficheAvant)
+ self.bApres.clicked.connect(self.afficheApres)
+ self.LENom.returnPressed.connect(self.nomChange)
+ self.LENomFormule.returnPressed.connect(self.NomFormuleSaisi)
+ self.LENomsArgs.returnPressed.connect(self.argsSaisis)
+ self.LECorpsFormule.returnPressed.connect(self.FormuleSaisie)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
# Modules Eficas
from Extensions.i18n import tr
-from feuille import Feuille
-from monWidgetSimpBase import MonWidgetSimpBase
+from .feuille import Feuille
+from .monWidgetSimpBase import MonWidgetSimpBase
from desWidgetHeure import Ui_WidgetHeure
# Modules Python
# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QWidget
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from __future__ import absolute_import
+from PyQt5.QtWidgets import QWidget
from Extensions.i18n import tr
from desWidgetInactif import Ui_WidgetInactif
import Accas
import os
-import string
# Import des panels
self.node=node
self.editor=editor
self.setupUi(self)
- from monWidgetOptionnel import MonWidgetOptionnel
+ from .monWidgetOptionnel import MonWidgetOptionnel
if self.editor.widgetOptionnel!= None :
self.monOptionnel=self.editor.widgetOptionnel
else :
self.editor.splitter.addWidget(self.monOptionnel)
self.editor.restoreSplitterSizes()
self.afficheOptionnel()
- if monEnvQT5 :
- self.bAvant.clicked.connect(self.afficheAvant)
- self.bApres.clicked.connect(self.afficheApres)
- self.bCatalogue.clicked.connect(self.afficheCatalogue)
- else :
- self.connect(self.bAvant,SIGNAL("clicked()"), self.afficheAvant)
- self.connect(self.bApres,SIGNAL("clicked()"), self.afficheApres)
- self.connect(self.bCatalogue,SIGNAL("clicked()"), self.afficheCatalogue)
+ self.bAvant.clicked.connect(self.afficheAvant)
+ self.bApres.clicked.connect(self.afficheApres)
+ self.bCatalogue.clicked.connect(self.afficheCatalogue)
self.labelNomCommande.setText(tr(self.node.item.nom))
self.labelNomCommande.setEnabled(False)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+import types,os
# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QWidget
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QWidget
from Extensions.i18n import tr
from desWidgetInformation import Ui_WidgetInformative
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os,sys
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+except : pass
+
+import types,os,sys
# Modules Eficas
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetMatrice import Ui_desWidgetMatrice
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtCore import QSize
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from six.moves import range
+from PyQt5.QtCore import QSize
class MonWidgetMatrice (Ui_desWidgetMatrice,Feuille):
self.nbCols=0
self.nomVariables={}
self.creeColonnes()
- if monEnvQT5 : self.connecterSignaux()
- else : self.connecterSignauxQT4()
+ self.connecterSignaux()
if self.node.item.get_valeur()== None: self.initialSsValeur()
else :
try : self.initialValeur()
monItem.setText("")
return
self.editor.affiche_infos("")
- if self.monType.structure != None: apply (MonWidgetMatrice.__dict__[self.monType.structure],(self,))
+ if self.monType.structure != None: MonWidgetMatrice.__dict__[self.monType.structure](*(self,))
self.acceptVal()
monItem=self.TBMatrice.currentItem()
texte=monItem.text()
if monItem.row() != monItem.column():
- print monItem.row(), monItem.column()
+ print(monItem.row(), monItem.column())
monItemSym=self.TBMatrice.item(monItem.column(), monItem.row())
monItemSym.setText(texte)
if self.monType.methodeCalculTaille != None :
#try:
if 1 :
- apply (MonWidgetMatrice.__dict__[self.monType.methodeCalculTaille],(self,))
+ MonWidgetMatrice.__dict__[self.monType.methodeCalculTaille](*(self,))
else :
#except :
QMessageBox.critical( self, tr("Mauvaise execution "),tr( "impossible d executer la methode ") + monType.methodeCalculTaille )
# Modules Python
# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QCheckBox, QWidget
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from __future__ import absolute_import
+from PyQt5.QtWidgets import QCheckBox, QWidget
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
from desWidgetOptionnel import Ui_WidgetOptionnel
-from monGroupeOptionnel import MonGroupeOptionnel
+from .monGroupeOptionnel import MonGroupeOptionnel
# Import des panels
def afficheOptionnel(self,liste,MC):
#print "dans Optionnel ____ affiche", liste
self.vireLesAutres(MC)
- if self.dicoMCWidgetOptionnel.has_key(MC.node.item.nom) :
+ if MC.node.item.nom in self.dicoMCWidgetOptionnel :
self.dicoMCWidgetOptionnel[MC.node.item.nom].setParent(None)
self.dicoMCWidgetOptionnel[MC.node.item.nom].close()
groupe = MonGroupeOptionnel(liste,self,MC)
#print "je passe dans vireLesAutres"
genea =MC.obj.get_genealogie()
#print genea
- for k in self.dicoMCWidgetOptionnel.keys():
+ for k in list(self.dicoMCWidgetOptionnel.keys()):
if k not in genea :
self.dicoMCWidgetOptionnel[k].close()
del self.dicoMCWidgetOptionnel[k]
def afficheOptionnelVide(self):
self.GeneaLabel.setText("")
- for k in self.dicoMCWidgetOptionnel.keys():
+ for k in list(self.dicoMCWidgetOptionnel.keys()):
self.dicoMCWidgetOptionnel[k].close()
del self.dicoMCWidgetOptionnel[k]
# Modules Python
# Modules Eficas
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
from desWidgetParam import Ui_WidgetParam
-from gereIcones import FacultatifOuOptionnel
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QWidget, QMessageBox
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from InterfaceQT4.gereIcones import FacultatifOuOptionnel
+import six
+from PyQt5.QtWidgets import QWidget, QMessageBox
+from PyQt5.QtGui import QIcon
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
import Accas
import os, re
-import string
import types
pattern_name = re.compile(r'^[^\d\W]\w*\Z')
self.repIcon=self.appliEficas.repIcon
self.setIconePoubelle()
+ if not(self.node.item.object.isvalid()) :
+ icon=QIcon(self.repIcon+"/ast-red-ball.png")
+ self.RBValide.setIcon(icon)
+
self.remplit()
#if self.editor.code in ['MAP','CARMELCND','CF'] : self.bCatalogue.close()
if self.editor.code in ['MAP','CARMELCND'] : self.bCatalogue.close()
- elif monEnvQT5 : self.bCatalogue.clicked.connect(self.afficheCatalogue)
- else : self.connect(self.bCatalogue,SIGNAL("clicked()"), self.afficheCatalogue)
-
- if monEnvQT5 :
- self.lineEditVal.returnPressed.connect(self.LEValeurPressed)
- self.lineEditNom.returnPressed.connect(self.LENomPressed)
- self.bAvant.clicked.connect(self.afficheAvant)
- self.bApres.clicked.connect(self.afficheApres)
- self.bVerifie.clicked.connect(self.verifiePressed)
- else :
- self.connect(self.lineEditVal,SIGNAL("returnPressed()"),self.LEValeurPressed)
- self.connect(self.lineEditNom,SIGNAL("returnPressed()"),self.LENomPressed)
- self.connect(self.bAvant,SIGNAL("clicked()"), self.afficheAvant)
- self.connect(self.bApres,SIGNAL("clicked()"), self.afficheApres)
- self.connect(self.bVerifie,SIGNAL("clicked()"), self.verifiePressed)
- self.editor.affiche_infos("")
+ else : self.bCatalogue.clicked.connect(self.afficheCatalogue)
+
+ self.lineEditVal.returnPressed.connect(self.LEValeurPressed)
+ self.lineEditNom.returnPressed.connect(self.LENomPressed)
+ self.bAvant.clicked.connect(self.afficheAvant)
+ self.bApres.clicked.connect(self.afficheApres)
+ self.bVerifie.clicked.connect(self.verifiePressed)
self.editor.fermeOptionnel()
valeur=self.node.item.get_valeur()
if valeur == None :
self.lineEditVal.clear()
- elif type(valeur) == types.ListType :
+ elif type(valeur) == list :
texte="["
for l in valeur :
texte=texte+str(l) +","
self.node.item.set_nom(nom)
self.node.item.set_valeur(val)
self.node.update_texte()
- self.node.update_node_valid()
def LENomPressed(self):
self.LEValeurPressed()
valString=str(self.lineEditVal.text())
contexte={}
- exec "from math import *" in contexte
+ exec("from math import *", contexte)
jdc=self.node.item.get_jdc()
for p in jdc.params :
try:
tp=p.nom+'='+str(repr(p.valeur))
- exec tp in contexte
+ exec(tp, contexte)
except exc :
pass
monTexte=nomString+"="+valString
try :
- exec monTexte in contexte
+ exec(monTexte, contexte)
except (ValueError,TypeError, NameError,RuntimeError,ZeroDivisionError) as exc:
- self.LECommentaire.setText(tr("Valeur incorrecte: ")+unicode (exc))
+ self.LECommentaire.setText(tr("Valeur incorrecte: ")+six.text_type (exc))
return False
except :
self.LECommentaire.setText(tr("Valeur incorrecte "))
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os,sys
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import range
+except : pass
+
+import types,os,sys
# Modules Eficas
from Extensions.i18n import tr
-from monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
-from politiquesValidation import PolitiquePlusieurs
+from .monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
+from .politiquesValidation import PolitiquePlusieurs
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QScrollBar
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from six.moves import range
+from PyQt5.QtWidgets import QScrollBar
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os,sys
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import range
+ from builtins import object
+except : pass
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtGui import QIcon
- from PyQt5.QtWidgets import QApplication
- from PyQt5.QtCore import QTimer, QSize, Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+import types,os,sys
+
+from six.moves import range
+from PyQt5.QtGui import QIcon
+from PyQt5.QtWidgets import QApplication
+from PyQt5.QtCore import QTimer, QSize, Qt
# Modules Eficas
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetPlusieursBase import Ui_WidgetPlusieursBase
-from politiquesValidation import PolitiquePlusieurs
-from qtSaisie import SaisieValeur
-from gereListe import GereListe
-from gereListe import GerePlie
-from gereListe import LECustom
+from .politiquesValidation import PolitiquePlusieurs
+from .qtSaisie import SaisieValeur
+from .gereListe import GereListe
+from .gereListe import GerePlie
+from .gereListe import LECustom
dicoLongueur={2:95,3:125,4:154,5:183,6:210}
hauteurMax=253
Feuille.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
GereListe.__init__(self)
self.gereIconePlier()
- if monEnvQT5:
- self.BSelectFichier.clicked.connect(self.selectInFile)
- else :
- self.connect(self.BSelectFichier,SIGNAL("clicked()"), self.selectInFile)
+ self.BSelectFichier.clicked.connect(self.selectInFile)
if sys.platform[0:5]!="linux":
repIcon=self.node.editor.appliEficas.repIcon
# construction du min de valeur a entrer
if self.monSimpDef.max == "**" : aConstruire=7
else : aConstruire=self.monSimpDef.max
- for i in range(1,aConstruire):
+ #for i in range(1,aConstruire):
+ for i in range(1,7):
self.ajoutLineEdit()
QApplication.processEvents()
self.scrollArea.ensureWidgetVisible(self.lineEditVal1)
if self.indexDernierLabel % 2 == 1 : nouveauLE.setStyleSheet("background:rgb(210,210,210)")
else : nouveauLE.setStyleSheet("background:rgb(235,235,235)")
nouveauLE.setFrame(False)
- if monEnvQT5:
- nouveauLE.returnPressed.connect(self.changeValeur)
- else :
- self.connect(nouveauLE,SIGNAL("returnPressed()"),self.changeValeur)
+ nouveauLE.returnPressed.connect(self.changeValeur)
setattr(self,nomLineEdit,nouveauLE)
self.listeAffichageWidget.append(nouveauLE)
self.etablitOrdre()
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import range
+except : pass
+
+import types,os
# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QCheckBox, QScrollBar, QFrame, QApplication, QLabel
- from PyQt5.QtWidgets import QSizePolicy,QSpacerItem
- from PyQt5.QtGui import QPalette, QFont
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from six.moves import range
+from PyQt5.QtWidgets import QCheckBox, QScrollBar, QFrame, QApplication, QLabel
+from PyQt5.QtWidgets import QSizePolicy,QSpacerItem
+from PyQt5.QtGui import QPalette, QFont
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetPlusieursInto import Ui_WidgetPlusieursInto
-from politiquesValidation import PolitiquePlusieurs
-from qtSaisie import SaisieValeur
-from gereListe import GerePlie
-from gereListe import GereListe
+from .politiquesValidation import PolitiquePlusieurs
+from .qtSaisie import SaisieValeur
+from .gereListe import GerePlie
+from .gereListe import GereListe
class MonWidgetPlusieursInto (Ui_WidgetPlusieursInto,Feuille,GerePlie,GereListe):
GereListe.__init__(self)
self.parentQt.commandesLayout.insertWidget(-1,self)
- if monEnvQT5 : self.CBCheck.stateChanged.connect(self.changeTout)
- else : self.connect(self.CBCheck, SIGNAL('stateChanged(int)'),self.changeTout)
+ self.CBCheck.stateChanged.connect(self.changeTout)
self.gereIconePlier()
self.editor.listeDesListesOuvertes.add(self.node.item)
if maListe[i] in self.PourEtreCoche : courant.setChecked(True)
else : courant.setChecked(False)
- if monEnvQT5 : courant.toggled.connect(self.changeValeur)
- else : self.connect(courant,SIGNAL("toggled(bool)"),self.changeValeur)
+ courant.toggled.connect(self.changeValeur)
self.inhibe=False
self.vScrollBar.triggerAction(QScrollBar.SliderToMinimum)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os,sys
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import range
+except : pass
+
+import types,os,sys
# Modules Eficas
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetPlusieursIntoOrdonne import Ui_WidgetPlusieursIntoOrdonne
-from politiquesValidation import PolitiquePlusieurs
-from qtSaisie import SaisieValeur
-from gereListe import GereListe
-from gereListe import GerePlie
-from gereListe import LECustom
-from gereListe import MonLabelListeClic
+from .politiquesValidation import PolitiquePlusieurs
+from .qtSaisie import SaisieValeur
+from .gereListe import GereListe
+from .gereListe import GerePlie
+from .gereListe import LECustom
+from .gereListe import MonLabelListeClic
from Extensions.i18n import tr
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QFrame, QApplication, QScrollBar
- from PyQt5.QtCore import QTimer, QSize, Qt
- from PyQt5.QtGui import QIcon
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from six.moves import range
+from PyQt5.QtWidgets import QFrame, QApplication, QScrollBar
+from PyQt5.QtCore import QTimer, QSize, Qt
+from PyQt5.QtGui import QIcon
class MonWidgetPlusieursIntoOrdonne (Ui_WidgetPlusieursIntoOrdonne, Feuille,GereListe,GerePlie):
def setValeurs(self):
self.listeValeursCourantes=self.node.item.GetListeValeurs()
- if self.monSimpDef.max == "**" : aConstruire=7
+ if self.monSimpDef.max == "**" or self.monSimpDef.max == float('inf') : aConstruire=7
else : aConstruire=self.monSimpDef.max
if len(self.listeValeursCourantes) > aConstruire : aConstruire=len(self.listeValeursCourantes)
for i in range(1,aConstruire+1): self.ajoutLEResultat(i)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os,sys
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
-# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QFrame
- from PyQt5.QtCore import QTimer, QSize, Qt
- from PyQt5.QtGui import QIcon
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+import types,os,sys
+
+from PyQt5.QtWidgets import QFrame
+from PyQt5.QtCore import QTimer, QSize, Qt
+from PyQt5.QtGui import QIcon
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetPlusieursPlie import Ui_WidgetPlusieursPlie
self.AAfficher=self.lineEditVal
self.maCommande.listeAffichageWidget.append(self.lineEditVal)
- if monEnvQT5 :
- self.BVisuListe.clicked.connect(self.selectWidgetDeplie)
- else :
- self.connect(self.BVisuListe,SIGNAL("clicked()"), self.selectWidgetDeplie)
+ self.BVisuListe.clicked.connect(self.selectWidgetDeplie)
def setValeurs(self):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os,sys
-
-# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QFrame,QApplication, QFrame, QWidget
- from PyQt5.QtGui import QIcon
- from PyQt5.QtCore import QSize, Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import range
+ from builtins import object
+except : pass
+
+import types,os,sys
+
+from six.moves import range
+from PyQt5.QtWidgets import QFrame,QApplication, QFrame, QWidget
+from PyQt5.QtGui import QIcon
+from PyQt5.QtCore import QSize, Qt
from Extensions.i18n import tr
-from feuille import Feuille
-from politiquesValidation import PolitiquePlusieurs
-from qtSaisie import SaisieValeur
-from gereListe import GereListe
-from gereListe import LECustom
+from .feuille import Feuille
+from .politiquesValidation import PolitiquePlusieurs
+from .qtSaisie import SaisieValeur
+from .gereListe import GereListe
+from .gereListe import LECustom
from Tuple2 import Ui_Tuple2
from Tuple3 import Ui_Tuple3
-class TupleCustom :
+class TupleCustom(object) :
def __init__(self,tailleTuple,parent,parentQt,index):
QWidget.__init__(self,parent)
self.setupUi(self)
courant=getattr(self,nomLE)
courant.num=index
courant.dansUnTuple=True
- if monEnvQT5 : courant.returnPressed.connect(self.valueChange)
- else : self.connect(courant,SIGNAL("returnPressed()"),self.valueChange)
+ courant.returnPressed.connect(self.valueChange)
def valueChange(self):
icon3 = QIcon(fichier3)
self.BSelectFichier.setIcon(icon3)
self.BSelectFichier.setIconSize(QSize(32, 32))
- if monEnvQT5 :
- self.BSelectFichier.clicked.connect(self.selectInFile)
- else :
- self.connect(self.BSelectFichier,SIGNAL("clicked()"), self.selectInFile)
+ self.BSelectFichier.clicked.connect(self.selectInFile)
if self.objSimp.definition.validators.typeDesTuples[0]==self.editor.readercata.cata[0].sd_ligne :
val=[]
if hasattr(self.objSimp.jdc,'LineDico'):
- for k in self.objSimp.jdc.LineDico.keys() :
+ for k in self.objSimp.jdc.LineDico :
try :
valeur=self.objSimp.jdc.get_concept(k)
val.append((valeur,0))
if self.objSimp.definition.validators.typeDesTuples[0]==self.editor.readercata.cata[0].sd_generateur :
val=[]
if hasattr(self.objSimp.jdc,'MachineDico'):
- for k in self.objSimp.jdc.MachineDico.keys() :
+ for k in self.objSimp.jdc.MachineDico :
try :
valeur=self.objSimp.jdc.get_concept(k)
val.append((valeur,0))
if self.objSimp.definition.validators.typeDesTuples[0]==self.editor.readercata.cata[0].sd_transfo :
val=[]
if hasattr(self.objSimp.jdc,'TransfoDico'):
- for k in self.objSimp.jdc.TransfoDico.keys() :
+ for k in self.objSimp.jdc.TransfoDico :
try :
valeur=self.objSimp.jdc.get_concept(k)
val.append((valeur,0))
if self.objSimp.definition.validators.typeDesTuples[0]==self.editor.readercata.cata[0].sd_charge :
val=[]
if hasattr(self.objSimp.jdc,'LoadDico'):
- for k in self.objSimp.jdc.LoadDico.keys() :
+ for k in self.objSimp.jdc.LoadDico :
try :
valeur=self.objSimp.jdc.get_concept(k)
val.append((valeur,0))
if self.objSimp.definition.validators.typeDesTuples[0]==self.editor.readercata.cata[0].sd_moteur :
val=[]
if hasattr(self.objSimp.jdc,'MotorDico'):
- for k in self.objSimp.jdc.MotorDico.keys() :
+ for k in self.objSimp.jdc.MotorDico :
try :
valeur=self.objSimp.jdc.get_concept(k)
val.append((valeur,0))
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
# Modules Eficas
-from feuille import Feuille
-from monWidgetPlusieursTuple import MonWidgetPlusieursTuple
+from .feuille import Feuille
+from .monWidgetPlusieursTuple import MonWidgetPlusieursTuple
from desWidgetPlusieursTuple import Ui_WidgetPlusieursTuple
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
# Modules Eficas
-from feuille import Feuille
-from monWidgetPlusieursTuple import MonWidgetPlusieursTuple
+from .feuille import Feuille
+from .monWidgetPlusieursTuple import MonWidgetPlusieursTuple
from desWidgetPlusieursTuple import Ui_WidgetPlusieursTuple
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except : pass
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtCore import Qt
- from PyQt5.QtWidgets import QWidget
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+import types,os
+
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QWidget
# Modules Eficas
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetRadioButton import Ui_WidgetRadioButton
-from politiquesValidation import PolitiqueUnique
-from qtSaisie import SaisieValeur
+from .politiquesValidation import PolitiqueUnique
+from .qtSaisie import SaisieValeur
class MonWidgetRadioButtonCommun (Feuille):
def setValeursApresBouton(self):
if self.objSimp.get_valeur()==None : return
valeur=self.objSimp.get_valeur()
- if not(type(valeur) in types.StringTypes) : valeur=str(valeur)
+ if not(type(valeur) == str) : valeur=str(valeur)
try :
self.dict_bouton[valeur].setChecked(True)
self.dict_bouton[valeur].setFocus(True)
nomBouton="radioButton_"+str(i)
bouton=getattr(self,nomBouton)
valeur=self.maListeDeValeur[i-1]
- if not(type(valeur) in types.StringTypes) : valeur=str(valeur)
+ if not(type(valeur) == str) : valeur=str(valeur)
bouton.setText(tr(valeur))
self.dict_bouton[valeur]=bouton
- if monEnvQT5 : bouton.clicked.connect(self.boutonclic)
- else : self.connect(bouton,SIGNAL("clicked()"),self.boutonclic)
+ bouton.clicked.connect(self.boutonclic)
bouton.keyPressEvent=self.keyPressEvent
setattr(self,nomBouton,bouton)
i=i+1
i=i+1
def boutonclic(self):
- for valeur in self.dict_bouton.keys():
+ for valeur in self.dict_bouton:
if self.dict_bouton[valeur].isChecked():
#print "dans boutonclic is checked", valeur, type(valeur)
SaisieValeur.LEValeurPressed(self,valeur)
def selectSuivant(self):
aLeFocus=self.focusWidget()
nom=aLeFocus.objectName()[12:]
- i=nom.toInt()[0]+1
+ i=int(nom)+1
if i == len(self.maListeDeValeur) +1 : i=1
nomBouton="radioButton_"+str(i)
courant=getattr(self,nomBouton)
def selectPrecedent(self):
aLeFocus=self.focusWidget()
nom=aLeFocus.objectName()[12:]
- i=nom.toInt()[0]-1
+ i=int(nom)-1
if i == 0 : i= len(self.maListeDeValeur)
nomBouton="radioButton_"+str(i)
courant=getattr(self,nomBouton)
def checkFocused(self):
aLeFocus=self.focusWidget()
nom=aLeFocus.objectName()[12:]
- i=nom.toInt()[0]
+ i=int(nom)
if i > 0 and i <= len(self.maListeDeValeur):
nomBouton="radioButton_"+str(i)
courant=getattr(self,nomBouton)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+import types,os
# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QLineEdit
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QLineEdit
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetSDCOInto import Ui_WidgetSDCOInto
-from qtSaisie import SaisieSDCO
-from politiquesValidation import PolitiqueUnique
+from .qtSaisie import SaisieSDCO
+from .politiquesValidation import PolitiqueUnique
self.AAficher=self.LESDCO
self.initLBSDCO()
- if monEnvQT5 :
- self.LESDCO.returnPressed.connect(self.LESDCOReturnPressed)
- self.LBSDCO.itemDoubleClicked.connect(self.LBSDCODoubleClicked )
- else :
- self.connect(self.LESDCO, SIGNAL("returnPressed()"),self.LESDCOReturnPressed)
- self.connect(self.LBSDCO, SIGNAL("itemDoubleClicked(QListWidgetItem*)" ), self.LBSDCODoubleClicked )
+ self.LESDCO.returnPressed.connect(self.LESDCOReturnPressed)
+ self.LBSDCO.itemDoubleClicked.connect(self.LBSDCODoubleClicked )
def LESDCOReturnPressed(self) :
self.LBSDCO.clearSelection()
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+import types,os
# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QLineEdit
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetSimpBase import Ui_WidgetSimpBase
-from politiquesValidation import PolitiqueUnique
-from qtSaisie import SaisieValeur
+from .politiquesValidation import PolitiqueUnique
+from .qtSaisie import SaisieValeur
class MonWidgetSimpBase (Ui_WidgetSimpBase,Feuille):
def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
Feuille.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
- #print "MonWidgetSimpBase", nom
self.parentQt.commandesLayout.insertWidget(-1,self,1)
self.setFocusPolicy(Qt.StrongFocus)
- if monEnvQT5 : self.lineEditVal.returnPressed.connect(self.LEValeurPressed)
- else : self.connect(self.lineEditVal,SIGNAL("returnPressed()"),self.LEValeurPressed)
+ self.lineEditVal.returnPressed.connect(self.LEValeurPressed)
self.AAfficher=self.lineEditVal
self.maCommande.listeAffichageWidget.append(self.lineEditVal)
+ self.lineEditVal.focusInEvent=self.monFocusInEvent
+
+
+ def monFocusInEvent(self,event):
+ self.editor.nodeEnCours = self
+ QLineEdit.focusInEvent(self.lineEditVal,event)
#def showEvent(self, event):
# QWidget.showEvent(self,event)
def setValeurs(self):
+ #print ("dans setValeurs")
self.politique=PolitiqueUnique(self.node,self.editor)
valeur=self.node.item.get_valeur()
valeurTexte=self.politique.GetValeurTexte(valeur)
'Repertoire' : tr(u'Un repertoire est attendu. '),
'Heure' : tr(u'Heure sous la forme HH:MM'),
'Date' : tr(u'Date sous la forme JJ/MM/AA')}
- if mc.type[0] != types.ClassType:
+ if mc.type[0] != type:
commentaire = d_aides.get(mc.type[0], tr("Type de base inconnu"))
else : commentaire=""
return commentaire
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QRadioButton
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QRadioButton
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetSimpBool import Ui_WidgetSimpBool
-from politiquesValidation import PolitiqueUnique
-from qtSaisie import SaisieValeur
+from .politiquesValidation import PolitiqueUnique
+from .qtSaisie import SaisieValeur
class MonWidgetSimpBool (Ui_WidgetSimpBool,Feuille):
def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
Feuille.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
self.politique=PolitiqueUnique(self.node,self.editor)
- if monEnvQT5 :
- self.RBTrue.clicked.connect(self.boutonTrueClic)
- self.RBFalse.clicked.connect(self.boutonFalseClic)
- else :
- self.connect(self.RBTrue,SIGNAL("clicked()"),self.boutonTrueClic)
- self.connect(self.RBFalse,SIGNAL("clicked()"),self.boutonFalseClic)
+ self.RBTrue.clicked.connect(self.boutonTrueClic)
+ self.RBFalse.clicked.connect(self.boutonFalseClic)
self.parentQt.commandesLayout.insertWidget(-1,self)
self.maCommande.listeAffichageWidget.append(self.RBTrue)
+ self.AAfficher=self.RBTrue
def setValeurs(self):
valeur=self.node.item.get_valeur()
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+import types,os, locale
# Modules Eficas
-if monEnvQT5:
- from PyQt5.QtWidgets import QLineEdit, QRadioButton
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtWidgets import QLineEdit, QRadioButton
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetSimpComplexe import Ui_WidgetSimpComplexe
-from politiquesValidation import PolitiqueUnique
-from qtSaisie import SaisieValeur
+from .politiquesValidation import PolitiqueUnique
+from .qtSaisie import SaisieValeur
class MonWidgetSimpComplexe (Ui_WidgetSimpComplexe,Feuille):
Feuille.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
self.parentQt.commandesLayout.insertWidget(-1,self)
self.setFocusPolicy(Qt.StrongFocus)
- if monEnvQT5 :
- self.LEImag.returnPressed.connect(self.LEImagRPressed)
- self.LEReel.returnPressed.connect()"),self.LEReelRPressed)
- self.RBRI.clicked.connect(self.ValeurPressed )
- self.RBMP.clicked.connect(self.ValeurPressed )
- self.LEComp.returnPressed.connect(self.LECompRPressed)
- else :
- self.connect(self.LEImag,SIGNAL("returnPressed()"),self.LEImagRPressed)
- self.connect(self.LEReel,SIGNAL("returnPressed()"),self.LEReelRPressed)
- self.connect(self.RBRI,SIGNAL("clicked()"), self.ValeurPressed )
- self.connect(self.RBMP,SIGNAL("clicked()"), self.ValeurPressed )
- self.connect(self.LEComp,SIGNAL("returnPressed()"),self.LECompRPressed)
+ self.LEImag.returnPressed.connect(self.LEImagRPressed)
+ self.LEReel.returnPressed.connect(self.LEReelRPressed)
+ self.RBRI.clicked.connect(self.ValeurPressed )
+ self.RBMP.clicked.connect(self.ValeurPressed )
+ self.LEComp.returnPressed.connect(self.LECompRPressed)
self.maCommande.listeAffichageWidget.append(self.LEComp)
#self.maCommande.listeAffichageWidget.append(self.RBRI)
#self.maCommande.listeAffichageWidget.append(self.RBMP)
self.politique=PolitiqueUnique(self.node,self.editor)
valeur=self.node.item.get_valeur()
if valeur == None or valeur == '' : return
- if type(valeur) not in (types.ListType,types.TupleType) :
+ if type(valeur) not in (list,tuple) :
self.LEComp.setText(str(valeur))
else :
typ_cplx,x1,x2=valeur
commentaire=tr("expression valide")
valeur = str(self.LEReel.text())
try :
- a=string.atof(valeur)
+ a=locale.atof(valeur)
self.editor.affiche_infos(commentaire)
except :
commentaire=tr("expression invalide")
commentaire=tr("expression valide")
valeur = str(self.LEImag.text())
try :
- a=string.atof(valeur)
+ a=locale.atof(valeur)
self.editor.affiche_infos(commentaire)
except :
commentaire=tr("expression invalide")
self.editor.affiche_infos(commentaire,Qt.red)
return None
try :
- l.append(string.atof(str(self.LEReel.text())))
- l.append(string.atof(str(self.LEImag.text())))
+ l.append(locale.atof(str(self.LEReel.text())))
+ l.append(locale.atof(str(self.LEImag.text())))
except :
return None
- return `tuple(l)`
+ return repr(tuple(l))
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os,sys
+from __future__ import absolute_import
+import types,os,sys
# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtGui import QIcon
- from PyQt5.QtCore import QSize
-else:
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtGui import QIcon
+from PyQt5.QtCore import QSize
from Extensions.i18n import tr
from desWidgetSimpFichier import Ui_WidgetSimpFichier
-from monWidgetSimpBase import MonWidgetSimpBase
+from .monWidgetSimpBase import MonWidgetSimpBase
class MonWidgetSimpFichier (Ui_WidgetSimpFichier,MonWidgetSimpBase):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+import types,os
-# Modules Eficas
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QLineEdit
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+
+from PyQt5.QtWidgets import QLineEdit
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetSimpSalome import Ui_WidgetSimpSalome
-from politiquesValidation import PolitiqueUnique
-from qtSaisie import SaisieValeur
+from .politiquesValidation import PolitiqueUnique
+from .qtSaisie import SaisieValeur
class MonWidgetSimpSalome (Ui_WidgetSimpSalome,Feuille):
self.parentQt.commandesLayout.insertWidget(-1,self,1)
self.setFocusPolicy(Qt.StrongFocus)
self.politique=PolitiqueUnique(self.node,self.editor)
- if monEnvQT5: self.lineEditVal.returnPressed.connect(self.LEValeurPressed)
- else : self.connect(self.lineEditVal,SIGNAL("returnPressed()"),self.LEValeurPressed)
+ self.lineEditVal.returnPressed.connect(self.LEValeurPressed)
self.AAfficher=self.lineEditVal
self.maCommande.listeAffichageWidget.append(self.lineEditVal)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import range
+except : pass
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+import types,os
+
+from six.moves import range
+from PyQt5.QtCore import Qt
# Modules Eficas
from Extensions.i18n import tr
-from feuille import Feuille
-from politiquesValidation import PolitiqueUnique
-from qtSaisie import SaisieValeur
+from .feuille import Feuille
+from .politiquesValidation import PolitiqueUnique
+from .qtSaisie import SaisieValeur
class MonWidgetSimpTuple(Feuille):
courant=getattr(self,nomLineEdit)
if valeur !=None: courant.setText(str(valeur[i]))
setattr(self,nomLineEdit,courant)
- if monEnvQT5: courant.returnPressed.connect(self.valeursPressed)
- else : self.connect(courant,SIGNAL("returnPressed()"),self.valeursPressed)
+ courant.returnPressed.connect(self.valeursPressed)
def valeursPressed(self):
aLeFocus=self.focusWidget()
# Passage au champ suivant
nom=aLeFocus.objectName()[11:]
try :
- i=str(nom).toInt()[0]+1
+ i=int(nom)+1
except :
try :
i=i+1
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
# Modules Eficas
#from PyQt4.QtGui import *
#from PyQt4.QtCore import *
from Extensions.i18n import tr
-from feuille import Feuille
-from monWidgetSimpTuple import MonWidgetSimpTuple
+from .feuille import Feuille
+from .monWidgetSimpTuple import MonWidgetSimpTuple
from desWidgetTuple2 import Ui_WidgetTuple2
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
# Modules Eficas
#from PyQt4.QtGui import *
#from PyQt4.QtCore import *
from Extensions.i18n import tr
-from feuille import Feuille
-from monWidgetSimpTuple import MonWidgetSimpTuple
+from .feuille import Feuille
+from .monWidgetSimpTuple import MonWidgetSimpTuple
from desWidgetTuple3 import Ui_WidgetTuple3
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
# Modules Eficas
from Extensions.i18n import tr
from desWidgetSimpTxt import Ui_WidgetSimpTxt
-from monWidgetSimpBase import MonWidgetSimpBase
+from .monWidgetSimpBase import MonWidgetSimpBase
class MonWidgetSimpTxt (Ui_WidgetSimpTxt,MonWidgetSimpBase):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
# Modules Eficas
from PyQt4.QtGui import *
from PyQt4.QtCore import *
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetUniqueSDCO import Ui_WidgetUniqueSDCO
-from politiquesValidation import PolitiqueUnique
-from qtSaisie import SaisieSDCO
+from .politiquesValidation import PolitiqueUnique
+from .qtSaisie import SaisieSDCO
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+import types,os
# Modules Eficas
from Extensions.i18n import tr
-from feuille import Feuille
+from .feuille import Feuille
from desWidgetVide import Ui_WidgetVide
-from politiquesValidation import PolitiqueUnique
+from .politiquesValidation import PolitiqueUnique
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import types, string
+from __future__ import absolute_import
+try :
+ from builtins import range
+except : pass
+
+import types
from Accas import PARAMETRE
from Extensions.i18n import tr
#------------------
-class Validation :
+class Validation(object) :
#------------------
def __init__(self,node,parent) :
self.node=node
commentaire = None
valeur,validite=self.node.item.eval_valeur(valeurentree)
if not validite :
- commentaire = "impossible d'evaluer : %s " %`valeurentree`
+ commentaire = "impossible d'evaluer : %s " %repr(valeurentree)
return valeur,validite,commentaire
- if self.node.item.wait_TXM() and type(valeur) not in types.StringTypes : valeur=str(valeur)
+ if self.node.item.wait_TXM() and not( type(valeur) == str) : valeur=str(valeur)
testtype,commentaire = self.node.item.object.verif_type(valeur)
if not testtype :
return valeur,0,commentaire
valide=self.node.item.valide_item(valeur)
- if type(valide) == types.TupleType:
+ if type(valide) == tuple:
validite,commentaire=valide
else :
validite=valide
commentaire=" "
if not validite and commentaire is None:
- commentaire = "impossible d'evaluer : %s " %`valeurentree`
+ commentaire = "impossible d'evaluer : %s " %repr(valeurentree)
return valeur, validite, commentaire
# ----------------------------------------------------------------------------------------
if str(clef) != str(texteValeur) :
self.node.item.object.init_modif()
clefobj=self.node.item.object.GetNomConcept()
- if not self.parent.appliEficas.dict_reels.has_key(clefobj):
+ if not clefobj in self.parent.appliEficas.dict_reels:
self.parent.appliEficas.dict_reels[clefobj] = {}
self.parent.appliEficas.dict_reels[clefobj][clef]=texteValeur
self.parent.appliEficas.dict_reels[clefobj]
if clefobj=="" :
- if not self.parent.appliEficas.dict_reels.has_key(self.node.item.object.etape) :
+ if not self.node.item.object.etape in self.parent.appliEficas.dict_reels :
self.parent.appliEficas.dict_reels[self.node.item.object.etape] = {}
self.parent.appliEficas.dict_reels[self.node.item.object.etape][clef]=texteValeur
self.node.item.object.fin_modif()
else : return(valeur)
if "R" in self.node.item.object.definition.type:
clefobj=self.node.item.object.GetNomConcept()
- if self.parent.appliEficas.dict_reels.has_key(clefobj):
- if self.parent.appliEficas.dict_reels[clefobj].has_key(valeur):
+ if clefobj in self.parent.appliEficas.dict_reels:
+ if valeur in self.parent.appliEficas.dict_reels[clefobj] :
valeurTexte=self.parent.appliEficas.dict_reels[clefobj][valeur]
else :
- if string.find(str(valeur),'.') == -1 and string.find(str(valeur),'e') == -1 and string.find(str(valeur),'E'):
+ if str(valeur).find('.') == -1 and str(valeur).find('e') == -1 and str(valeur).find('E'):
# aucun '.' n'a ete trouve dans valeur --> on en rajoute un a la fin
if (self.is_param(valeur)):
return valeur
else:
- val2=eval(str(valeur)+'.')
+ try :
+ val2=eval(str(valeur)+'.')
+ except :
+ pass
return valeurTexte
def is_param(self,valeur) :
clef=eval(texteValeur)
if str(clef) != str(texteValeur) :
clefobj=self.node.item.object.GetNomConcept()
- if not self.parent.appliEficas.dict_reels.has_key(clefobj):
+ if not clefobj in self.parent.appliEficas :
self.parent.appliEficas.dict_reels[clefobj] = {}
self.parent.appliEficas.dict_reels[clefobj][clef]=texteValeur
if clefobj=="" :
- if not self.parent.appliEficas.dict_reels.has_key(self.node.item.object.etape) :
+ if not self.node.item.object.etape in self.parent.appliEficas.dict_reels :
self.parent.appliEficas.dict_reels[self.node.item.object.etape] = {}
self.parent.appliEficas.dict_reels[self.node.item.object.etape][clef]=texteValeur
def AjoutDsDictReelEtape(self):
try:
- if self.parent.appliEficas.dict_reels.has_key(self.node.item.object) :
+ if self.node.item.object in self.parent.appliEficas.dict_reels:
self.parent.appliEficas.dict_reels[self.node.item.sdnom]=self.parent.appliEficas.dict_reels[self.node.item.object]
del self.parent.appliEficas.dict_reels[self.node.item.object]
except :
valide=1
if listevaleur==None: return
if listevaleur=="": return
- if not( type(listevaleur) in (types.ListType,types.TupleType)) :
+ if not( type(listevaleur) in (list,tuple)) :
listevaleur=tuple(listevaleur)
# on verifie que la cardinalite max n a pas ete atteinte
min,max = self.node.item.GetMinMax()
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except : pass
+
import os, sys
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QApplication, QMainWindow, QBoxLayout, QMenu, QAction, QMessageBox
- from PyQt5.QtGui import QIcon
- from PyQt5.QtCore import Qt
-else:
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+import six
+
+
+from PyQt5.QtWidgets import QApplication, QMainWindow, QBoxLayout, QMenu, QAction, QMessageBox
+from PyQt5.QtGui import QIcon
+from PyQt5.QtCore import Qt
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
from myMain import Ui_Eficas
-from viewManager import MyTabview
-from getVersion import getEficasVersion
+from .viewManager import MyTabview
+from .getVersion import getEficasVersion
from Editeur import session
version=getEficasVersion()
- self.VERSION_EFICAS="Eficas QT4 Salome "+version
- if monEnvQT5 : self.VERSION_EFICAS="Eficas QT5 Salome "
+ self.VERSION_EFICAS="Eficas QT5 Salome " + version
self.salome=salome
self.parentMainWindow=parent
self.ihm="QT"
self.indice=0
self.first=1
self.dict_reels={}
- if monEnvQT5 : self.recent = []
- else : self.recent = QStringList()
+ self.recent = []
self.ficRecents={}
self.mesScripts={}
self.listeAEnlever=[]
self.suiteTelemac=False
if hasattr (self, 'CONFIGURATION') :
if self.CONFIGURATION.force_langue :
- from monChoixLangue import MonChoixLangue
+ from .monChoixLangue import MonChoixLangue
widgetLangue = MonChoixLangue(self)
ret=widgetLangue.exec_()
self.suiteTelemac=self.CONFIGURATION.suiteTelemac
from Extensions import localisation
app=QApplication
- localisation.localise(None,self.langue)
+ localisation.localise(None,self.langue,translatorFichier=self.CONFIGURATION.translatorFichier)
+
+
self.setupUi(self)
#if parent != None : self.parentCentralWidget = parent.centralWidget()
# actionARemplacer ne sert que pour l insert Menu
self.menuFichier.insertMenu(self.actionARemplacer ,self.recentMenu)
self.menuFichier.removeAction(self.actionARemplacer)
- if monEnvQT5 : self.connecterSignaux()
- else : self.connecterSignauxQT4()
+ self.connecterSignaux()
self.toolBar.addSeparator()
if self.code != None : self.construitMenu()
self.ssCode=ssCode
if self.code==None :
self.cleanPath()
- from monChoixCode import MonChoixCode
+ from .monChoixCode import MonChoixCode
widgetChoix = MonChoixCode(self)
ret=widgetChoix.exec_()
import sys
if hasattr(self,intituleAction):
action=getattr(self,intituleAction)
self.toolBar.removeAction(action)
- if self.code.upper() in Appli.__dict__.keys():
- listeTexte=apply(Appli.__dict__[self.code.upper()],(self,))
+ if self.code.upper() in Appli.__dict__:
+ listeTexte=Appli.__dict__[self.code.upper()],(self,)
if self.suiteTelemac : self.lookSuiteTelemac()
def initAides(self):
self.actionN1 = QAction(self)
self.actionN1.setText(tr("Process Output"))
self.menuN1.addAction(self.actionN1)
- if monEnvQT5 : self.actionN1.triggered.connect(self.newN1)
- else : self.connect(self.actionN1,SIGNAL("triggered()"),self.newN1)
-
+ self.actionN1.triggered.connect(self.newN1)
if hasattr(self,'actionOpenProcess'):return
self.actionOpenProcess = QAction(self)
self.actionOpenProcess.setText(tr("Open Process_Output File"))
self.menuN1.addAction(self.actionOpenProcess)
- if monEnvQT5 : self.actionOpenProcess.triggered.connect(self.openProcess)
- else : self.connect(self.actionOpenProcess,SIGNAL("triggered()"),self.openProcess)
+ self.actionOpenProcess.triggered.connect(self.openProcess)
def ajoutExecution(self):
self.menuExecution = self.menubar.addMenu(tr("&Run"))
if not(self.actionExecution in self.toolBar.actions()):
self.toolBar.addAction(self.actionExecution)
self.actionExecution.setText(tr("Run"))
- if monEnvQT5 : self.actionExecution.triggered.connect(self.run)
- else : self.connect(self.actionExecution,SIGNAL("triggered()"),self.run)
+ self.actionExecution.triggered.connect(self.run)
def ajoutSauveExecution(self):
self.actionSaveRun = QAction(self)
if not(self.actionSaveRun in self.toolBar.actions()):
self.toolBar.addAction(self.actionSaveRun)
self.actionSaveRun.setText(tr("Save Run"))
- if monEnvQT5 : self.actionSaveRun.triggered.connect(self.saveRun)
- else : self.connect(self.actionSaveRun,SIGNAL("triggered()"),self.saveRun)
+ self.actionSaveRun.triggered.connect(self.saveRun)
def griserActionsStructures(self):
self.actionCouper.setEnabled(False)
self.actionRechercherDsCatalogue.setVisible(False)
def connectRechercherDsCatalogue(self):
- if monEnvQT5:
- self.actionRechercherDsCatalogue.triggered.connect(self.handleRechercherDsCatalogue)
- else :
- self.connect(self.actionRechercherDsCatalogue,SIGNAL("triggered()"),self.handleRechercherDsCatalogue)
+ self.actionRechercherDsCatalogue.triggered.connect(self.handleRechercherDsCatalogue)
def ajoutSortieLegere(self):
if hasattr(self,'actionSortieLegere') : return
self.actionSortieLegere = QAction(self)
self.actionSortieLegere.setText(tr("Sortie Legere"))
self.menuFichier.insertAction(self.actionEnregistrer_sous,self.actionSortieLegere)
- if monEnvQT5:
- self.actionSortieLegere.triggered.connect(self.handleSortieLegere)
- else :
- self.connect(self.actionSortieLegere,SIGNAL("triggered()"),self.handleSortieLegere)
+ self.actionSortieLegere.triggered.connect(self.handleSortieLegere)
def ZCRACKS(self):
self.menuOptions.setTitle(tr("Options"))
def PSEN(self):
- if self.first:
- self.first=0
- if monEnvQT5:
- self.action_Nouveau.triggered.disconnect(self.fileNew)
- self.action_Nouveau.triggered.connect(self.newPSEN)
- self
- else :
- self.disconnect(self.action_Nouveau,SIGNAL("triggered()"),self.fileNew)
- self.connect(self.action_Nouveau,SIGNAL("triggered()"),self.newPSEN)
+ if self.first: self.first=0
+ self.action_Nouveau.triggered.disconnect(self.fileNew)
+ self.action_Nouveau.triggered.connect(self.newPSEN)
self.enleverActionsStructures()
self.enleverParametres()
self.enleverRechercherDsCatalogue()
def ajoutHelpPSEN(self):
self.actionParametres_Eficas.setText('Help PSEN')
- if monEnvQT5 : self.actionParametres_Eficas.triggered.connect(self.aidePSEN)
- else : self.connect(self.actionParametres_Eficas,SIGNAL("triggered()"),self.aidePSEN)
+ self.actionParametres_Eficas.triggered.connect(self.aidePSEN)
+
# Pour Aster
self.actionTraduitV9V10 = QAction(self)
self.actionTraduitV9V10.setObjectName("actionTraduitV9V10")
self.actionRegles_du_JdC.triggered.connect(self.jdcRegles)
self.actionFichier_Source.triggered.connect(self.jdcFichierSource)
self.actionFichier_Resultat.triggered.connect(self.visuJdcPy)
+ self.actionAfficher_l_Arbre.triggered.connect(self.ouvreArbre)
+ self.actionCacher_l_Arbre.triggered.connect(self.fermeArbre)
# Pour Aster
def initPatrons(self) :
# Mise a jour du menu des fichiers recemment ouverts
from Editeur import listePatrons
- if not(self.code in listePatrons.sous_menus.keys()) :
+ if not(self.code in listePatrons.sous_menus) :
if hasattr(self,"menuPatrons"):
self.menuPatrons.setAttribute(Qt.WA_DeleteOnClose)
self.menuPatrons.close()
self.menuPatrons.clear()
self.listePatrons = listePatrons.listePatrons(self.code)
idx = 0
- for nomSsMenu in self.listePatrons.liste.keys():
+ for nomSsMenu in self.listePatrons.liste:
ssmenu=self.menuPatrons.addMenu(nomSsMenu)
for fichier in self.listePatrons.liste[nomSsMenu]:
id = ssmenu.addAction(fichier)
self.ficPatrons[id]=fichier
- if monEnvQT5 : self.id.triggered.connect(self.handleOpenPatrons)
- else : self.connect(id, SIGNAL('triggered()'),self.handleOpenPatrons)
+ self.id.triggered.connect(self.handleOpenPatrons)
# self.Patrons.setItemParameter(id,idx)
idx=idx+1
def initRecents(self):
- if monEnvQT5 : self.recent = []
- else : self.recent = QStringList()
+ self.recent = []
try :
if sys.platform[0:5]=="linux" :
rep=os.path.join(os.environ['HOME'],'.config/Eficas',self.code)
except : pass
def addToRecentList(self, fn):
- if not monEnvQT5 : self.addToRecentListQT4(fn); return
while fn in self.recent: self.recent.remove(fn)
self.recent.insert(0,fn)
if len(self.recent) > 9:
def traductionV11V12(self):
- from gereTraduction import traduction
+ from .gereTraduction import traduction
traduction(self.CONFIGURATION.repIni,self.viewmanager,"V11V12")
def traductionV10V11(self):
- from gereTraduction import traduction
+ from .gereTraduction import traduction
traduction(self.CONFIGURATION.repIni,self.viewmanager,"V10V11")
def traductionV9V10(self):
- from gereTraduction import traduction
+ from .gereTraduction import traduction
traduction(self.CONFIGURATION.repIni,self.viewmanager,"V9V10")
def version(self) :
- from monVisu import DVisu
+ from .monVisu import DVisu
titre = tr("version ")
monVisuDialg=DVisu(parent=self,fl=0)
monVisuDialg.setWindowTitle(titre)
for rp in self.recent:
id = self.recentMenu.addAction(rp)
self.ficRecents[id]=rp
- if monEnvQT5 : id.triggered.connect(self.handleOpenRecent)
- else : self.connect(id, SIGNAL('triggered()'),self.handleOpenRecent)
+ id.triggered.connect(self.handleOpenRecent)
self.recentMenu.addSeparator()
self.recentMenu.addAction(tr('&Effacer'), self.handleClearRecent)
try:
self.viewmanager.newEditor()
except EficasException as exc:
- msg = unicode(exc)
+ msg = six.text_type(exc)
if msg != "": QMessageBox.warning(self, tr(u"Erreur"), msg)
def openProcess(self):
try:
self.viewmanager.handleOpen()
except EficasException as exc:
- msg = unicode(exc)
+ msg = six.text_type(exc)
if msg != "":
QMessageBox.warning(self, tr(u"Erreur"), msg)
def visuJdcPy(self):
self.viewmanager.handleViewJdcPy()
+ def ouvreArbre(self):
+ self.viewmanager.ouvreArbre()
+
+ def fermeArbre(self):
+ self.viewmanager.fermeArbre()
def NewInclude(self):
self.viewmanager.newIncludeEditor()
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import range
+except : pass
+
+import types,os
from Extensions.i18n import tr
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtCore import Qt
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from PyQt5.QtCore import Qt
# Import des panels
-class SaisieValeur:
+class SaisieValeur(object):
"""
Classe contenant les methodes communes aux panels
permettant de choisir des valeurs
if valeur == None :
nouvelleValeur=str(self.lineEditVal.text())
else :
- if hasattr(self,"lineEditVal"):self.lineEditVal.setText(tr(valeur.nom))
+ #PN PN PN ???? la 1 ligne est tres bizarre.
+ try :
+ if hasattr(self,"lineEditVal"):self.lineEditVal.setText(tr(valeur.nom))
+ except :
+ if hasattr(self,"lineEditVal"):self.lineEditVal.setText(valeur)
nouvelleValeur=valeur
+ if self.node.item.definition.validators != None :
+ if self.node.item.definition.validators.verif_item(nouvelleValeur) !=1 :
+ commentaire=self.node.item.definition.validators.info_erreur_item()
+ self.editor.affiche_infos(commentaire,Qt.red)
+ return
nouvelleValeurFormat=self.politique.GetValeurTexte(nouvelleValeur)
validite,commentaire=self.politique.RecordValeur(nouvelleValeurFormat)
if commentaire != "" :
except :
valeur=valeurBrute
- if type(valeur) in (types.ListType,types.TupleType) :
+ if type(valeur) in (list,tuple) :
if self.node.item.wait_complex() :
indice = 0
while (indice < len(valeur)):
else: # on n'attend pas un complexe
listeValeurs=valeurBrute.split(',')
- elif type(valeur) == types.StringType:
+ elif type(valeur) == bytes:
listeValeurs=valeur.split(',')
else:
listeValeurs.append(valeurBrute)
return listeValeurs,1
-class SaisieSDCO :
+class SaisieSDCO(object) :
def LESDCOReturnPressed(self):
"""
Il s'appuie sur la classe READERCATA
"""
# Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
import time
import os,sys,py_compile
import traceback
-import cPickle
+import six.moves.cPickle
import re
import types
import analyse_catalogue_initial
import autre_analyse_cata
import uiinfo
-from monChoixCata import MonChoixCata
+from .monChoixCata import MonChoixCata
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
-from determine import monEnvQT5
-if monEnvQT5 :
- from PyQt5.QtWidgets import QMessageBox, QApplication, QDialog
-else :
- from PyQt4.QtGui import *
+from PyQt5.QtWidgets import QMessageBox, QApplication, QDialog
-class READERCATA:
+class READERCATA(object):
def __init__(self,QWParent, appliEficas):
self.QWParent=QWParent
self.cataitem=None
self.cree_dico_inverse()
if self.code=="TELEMAC": self.cree_dico_CasToCata()
- #for k in self.dicoInverse.keys():
+ #for k in self.dicoInverse:
# genea= self.dicoInverse[k]
# for t in genea :
# print t[0]
for catalogue in self.appliEficas.CONFIGURATION.catalogues:
if isinstance(catalogue, CatalogDescription):
all_cata_list.append(catalogue)
- elif isinstance(catalogue, types.TupleType):
+ elif isinstance(catalogue, tuple):
all_cata_list.append(CatalogDescription.create_from_tuple(catalogue))
else:
- print ("Catalog description cannot be interpreted: ", catalogue)
+ print(("Catalog description cannot be interpreted: ", catalogue))
# This filter is only useful for codes that have subcodes (like MAP).
# Otherwise, the "code" attribute of the catalog description can (should) be None.
if self.fic_cata == None :
if self.appliEficas.salome == 0 :
- print ("Pas de catalogue pour code %s, version %s" %(self.code,self.version_code))
+ print(("Pas de catalogue pour code %s, version %s" %(self.code,self.version_code)))
sys.exit(1)
else :
self.appliEficas.close()
self.cata = self.import_cata(self.fic_cata)
if not self.cata :
QMessageBox.critical( self.QWParent, tr("Import du catalogue"),tr("Impossible d'importer le catalogue ")+ self.fic_cata)
- self.appliEficas.close()
+ self.appliEficas.close()
if self.appliEficas.salome == 0 :
sys.exit(1)
#
self.appliEficas.listeAEnlever.append(rep_cata)
- if sys.modules.has_key(nom_cata):
+ if nom_cata in list(sys.modules.keys()) :
del sys.modules[nom_cata]
- for k in sys.modules.keys():
+ for k in sys.modules:
if k[0:len(nom_cata)+1] == nom_cata+'.':
del sys.modules[k]
docu=l[deb:-1]
dict_clef_docu[clef]=docu
for oper in self.cata.JdC.commandes:
- if dict_clef_docu.has_key(oper.nom):
+ if oper.nom in dict_clef_docu :
oper.docu=dict_clef_docu[oper.nom]
def cree_dico_inverse(self):
#self.dicoFrancaisAnglais={}
#self.dicoAnglaisFrancais={}
- #for k in self.dicoInverse.keys():
+ #for k in self.dicoInverse:
# listefr=[]
# for nom, obj in self.dicoInverse[k] :
# listefr.append((tr(nom),obj))
def traite_entite(self,e):
boolIn=0
- for (nomFils, fils) in e.entites.items() :
+ for (nomFils, fils) in list(e.entites.items()) :
self.dicoMC[nomFils]=fils
self.traite_entite(fils)
boolIn=1
#if niveau != 0 :
# if isinstance(e,A_BLOC.BLOC): print decale, e.condition
# else : print decale, e. nom
- for (nom, fils) in e.entites.items() :
- if fils.entites.items() != [] : self.cree_rubrique(fils,dico,niveau+1)
+ for (nom, fils) in list(e.entites.items()) :
+ if list(fils.entites.items()) != [] : self.cree_rubrique(fils,dico,niveau+1)
#else : print (niveau+1)*" ", nom
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# permet de lancer EFICAS en n affichant rien
+try :
+ from builtins import object
+except : pass
-class appliEficasSSIhm:
+class appliEficasSSIhm(object):
def __init__ (self,code):
self.VERSION_EFICAS="Sans Ihm"
self.code=code
configuration=__import__(nameConf)
self.CONFIGURATION = configuration.make_config(self,prefsCode.repIni)
-class QWParentSSIhm:
+class QWParentSSIhm(object):
def __init__(self,code,appliEficas,version_code,ssCode=None):
self.ihm="QT"
self.code=code
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QAction, QMenu, QMessageBox
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
+
+from PyQt5.QtWidgets import QAction, QMenu, QMessageBox
from Extensions.i18n import tr
import types
#---------------------------#
-class PopUpMenuRacine :
+class PopUpMenuRacine(object) :
#---------------------------#
def createPopUpMenu(self):
#print "createPopUpMenu"
self.ParamApres = QAction(tr('Parametre'),self.tree)
- if monEnvQT5 :
- self.ParamApres.triggered.connect(self.addParametersApres)
- else :
- self.tree.connect(self.ParamApres,SIGNAL("triggered()"),self.addParametersApres)
+ self.ParamApres.triggered.connect(self.addParametersApres)
self.ParamApres.setStatusTip(tr("Insere un parametre"))
self.menu = QMenu(self.tree)
self.menu.addAction(self.ParamApres)
item.addParameters(True)
#---------------------------#
-class PopUpMenuNodeMinimal :
+class PopUpMenuNodeMinimal(object) :
#---------------------------#
def createPopUpMenu(self):
#print "createPopUpMenu"
#self.appliEficas.salome=True
- if monEnvQT5 : self.createActions()
- else : self.createActionsQT4()
+ self.createActions()
self.menu = QMenu(self.tree)
#self.menu.setStyleSheet("background:rgb(235,235,235); QMenu::item:selected { background-color: red; }")
#ne fonctionne pas --> la ligne de commentaire devient rouge
#items du menu
self.menu.addAction(self.Supprime)
if hasattr(self.appliEficas, 'mesScripts'):
- if self.editor.code in self.editor.appliEficas.mesScripts.keys() :
+ if self.editor.code in self.editor.appliEficas.mesScripts :
self.dict_commandes_mesScripts=self.appliEficas.mesScripts[self.editor.code].dict_commandes
- if self.tree.currentItem().item.get_nom() in self.dict_commandes_mesScripts.keys() :
+ if self.tree.currentItem().item.get_nom() in self.dict_commandes_mesScripts :
self.ajoutScript()
def ajoutScript(self):
# cochon mais je n arrive pas a faire mieux avec le mecanisme de plugin
if hasattr(self.appliEficas, 'mesScripts'):
- if self.editor.code in self.editor.appliEficas.mesScripts.keys() :
+ if self.editor.code in self.editor.appliEficas.mesScripts :
self.dict_commandes_mesScripts=self.appliEficas.mesScripts[self.editor.code].dict_commandes
else : return
listeCommandes=self.dict_commandes_mesScripts[self.tree.currentItem().item.get_nom()]
- if type(listeCommandes) != types.TupleType: listeCommandes=(listeCommandes,)
+ if type(listeCommandes) != tuple: listeCommandes=(listeCommandes,)
numero=0
for commande in listeCommandes :
conditionSalome=commande[3]
tip=commande[5]
self.action=QAction(label,self.tree)
self.action.setStatusTip(tip)
- if monEnvQT5 :
- if numero==4:
- self.action.triggered.connect(self.AppelleFonction4)
- if numero==3:
- self.action.triggered.connect(self.AppelleFonction3)
- numero=4
- if numero==2:
- self.action.triggered.connect(self.AppelleFonction2)
- numero=3
- if numero==1:
- self.action.triggered.connect(self.AppelleFonction1)
- numero=2
- if numero==0:
- self.action.triggered.connect(self.AppelleFonction0)
- numero=1
- else:
- if numero==4:
- self.tree.connect(self.action,SIGNAL("triggered()"),self.AppelleFonction4)
- if numero==3:
- self.tree.connect(self.action,SIGNAL("triggered()"),self.AppelleFonction3)
- numero=4
- if numero==2:
- self.tree.connect(self.action,SIGNAL("triggered()"),self.AppelleFonction2)
- numero=3
- if numero==1:
- self.tree.connect(self.action,SIGNAL("triggered()"),self.AppelleFonction1)
- numero=2
- if numero==0:
- self.tree.connect(self.action,SIGNAL("triggered()"),self.AppelleFonction0)
- numero=1
+ if numero==4: self.action.triggered.connect(self.AppelleFonction4)
+ if numero==3: self.action.triggered.connect(self.AppelleFonction3); numero=4
+ if numero==2: self.action.triggered.connect(self.AppelleFonction2); numero=3
+ if numero==1: self.action.triggered.connect(self.AppelleFonction1); numero=2
+ if numero==0: self.action.triggered.connect(self.AppelleFonction0); numero=1
self.menu.addAction(self.action)
if nodeTraite==None : nodeTraite=self.tree.currentItem()
nomCmd=nodeTraite.item.get_nom()
if hasattr(self.appliEficas, 'mesScripts'):
- if self.editor.code in self.editor.appliEficas.mesScripts.keys() :
+ if self.editor.code in self.editor.appliEficas.mesScripts :
self.dict_commandes_mesScripts=self.appliEficas.mesScripts[self.editor.code].dict_commandes
else : return
listeCommandes=self.dict_commandes_mesScripts[nomCmd]
QMessageBox.warning( None,
tr("item invalide"),
tr("l item doit etre valide"),)
- return
+ return
fonction=commande[0]
listenomparam=commande[2]
listeparam=[]
QMessageBox.warning( None,
tr("echec de la fonction"),
tr(commentaire),)
- return
+ return
except :
pass
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import os, string
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
+import os
from Extensions.i18n import tr
-from determine import monEnvQT5
-if monEnvQT5:
- from PyQt5.QtWidgets import QFileDialog, QMessageBox
- from PyQt5.QtCore import QFileInfo
-else :
- from PyQt4.QtGui import *
- from PyQt4.QtCore import *
+import six
+from PyQt5.QtWidgets import QFileDialog, QMessageBox
+from PyQt5.QtCore import QFileInfo
DictExtensions= {"MAP" : ".map"}
-class MyTabview:
+class MyTabview(object):
def __init__(self,appliEficas):
self.appliEficas=appliEficas
self.myQtab = self.appliEficas.myQtab
- if monEnvQT5:
- self.myQtab.currentChanged.connect(self.indexChanged)
- self.myQtab.tabCloseRequested.connect(self.closeTab)
- else :
- self.myQtab.connect(self.myQtab, SIGNAL('tabCloseRequested(int)'), self.closeTab)
- if self.appliEficas.multi== True:
- self.myQtab.connect(self.myQtab,SIGNAL("currentChanged(int)"),self.indexChanged)
+ self.myQtab.currentChanged.connect(self.indexChanged)
+ self.myQtab.tabCloseRequested.connect(self.closeTab)
def indexChanged(self):
index=self.myQtab.currentIndex()
- if self.dict_editors.has_key(index):
+ if index in self.dict_editors:
editor=self.dict_editors[index]
self.appliEficas.CONFIGURATION=editor.CONFIGURATION
self.appliEficas.code=editor.CONFIGURATION.code
self.appliEficas.definitCode(None,None)
if self.appliEficas.code == None:return
- if DictExtensions.has_key(self.appliEficas.code) :
+ if self.appliEficas.code in DictExtensions:
chaine="JDC (*"+DictExtensions[self.appliEficas.code]+");;"
extensions=tr(chaine+ "All Files (*)")
else :
tr('Ouvrir Fichier'),
self.appliEficas.CONFIGURATION.savedir,
extensions)
- if monEnvQT5 : fichier=fichier[0]
- if not fichier: return result
- fichier = os.path.abspath(unicode(fichier))
- ulfile = os.path.abspath(unicode(fichier))
+ fichier=fichier[0]
+ fichier = os.path.abspath(six.text_type(fichier))
+ ulfile = os.path.abspath(six.text_type(fichier))
self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
self.appliEficas.addToRecentList(fichier)
maPage=self.getEditor( fichier,units=units)
if index < 0 : return
self.dict_editors[index].viewJdcSource()
+ def ouvreArbre(self):
+ index=self.myQtab.currentIndex()
+ if index < 0 : return
+ self.dict_editors[index].ouvreArbre()
+
+ def fermeArbre(self):
+ index=self.myQtab.currentIndex()
+ if index < 0 : return
+ self.dict_editors[index].fermeArbre()
+
def handleViewJdcRegles(self):
index=self.myQtab.currentIndex()
if index < 0 : return
index=self.myQtab.currentIndex()
if index < 0 : return
editor=self.dict_editors[index]
- if editor in self.doubles.keys() :
+ if editor in self.doubles :
QMessageBox.warning(
None,
tr("Fichier Duplique"),
return
ok, newName = editor.saveFile()
if ok :
- fileName=os.path.basename(unicode(newName))
+ fileName=os.path.basename(six.text_type(newName))
self.myQtab.setTabText(index,fileName)
return ok
index=self.myQtab.currentIndex()
if index < 0 : return
editor=self.dict_editors[index]
- if editor in self.doubles.keys() :
+ if editor in self.doubles :
QMessageBox.warning(
None,
tr("Fichier Duplique"),
return
ok, newName = editor.sauveLigneFile()
if ok :
- fileName=os.path.basename(unicode(newName))
+ fileName=os.path.basename(six.text_type(newName))
self.myQtab.setTabText(index,fileName)
return ok
oldName=editor.fichier
ok,newName = editor.saveFileAs()
if ok :
- fileName=os.path.basename(unicode(newName))
+ fileName=os.path.basename(six.text_type(newName))
self.myQtab.setTabText(index,fileName)
- if editor in self.doubles.keys():
+ if editor in self.doubles :
if oldName != newName :
del self.doubles[editor]
return ok
newWin = 0
double = None
indexEditor=0
- for indexEditor in self.dict_editors.keys():
+ for indexEditor in self.dict_editors :
editor=self.dict_editors[indexEditor]
if self.samepath(fichier, editor.getFileName()):
- if monEnvQT5 :
- msgBox = QMessageBox()
- msgBox.setWindowTitle(tr("Fichier"))
- msgBox.setText(tr("Le fichier <b>%s</b> est deja ouvert", str(fichier)))
- msgBox.addButton(tr("&Duplication"),0)
- msgBox.addButton(tr("&Abandonner"),1)
- abort=msgBox.exec_()
- else :
- abort = QMessageBox.warning(self.appliEficas,
- tr("Fichier"),
- tr("Le fichier <b>%s</b> est deja ouvert.",str(fichier)),
- tr("&Duplication"),
- tr("&Abort"))
+ msgBox = QMessageBox()
+ msgBox.setWindowTitle(tr("Fichier"))
+ msgBox.setText(tr("Le fichier <b>%s</b> est deja ouvert", str(fichier)))
+ msgBox.addButton(tr("&Duplication"),0)
+ msgBox.addButton(tr("&Abandonner"),1)
+ abort=msgBox.exec_()
if abort: break
double=editor
else :
- from editor import JDCEditor
+ from .editor import JDCEditor
editor = JDCEditor(self.appliEficas,fichier, jdc, self.myQtab,units=units,vm = self,include=include)
if double != None :
@return flag indicating successful reset of the dirty flag (boolean)
"""
res=1
- if (editor.modified) and (editor in self.doubles.keys()) :
- if monEnvQT5 :
- msgBox = QMessageBox(None)
- msgBox.setWindowTitle(tr("Fichier Duplique"))
- msgBox.setText(tr("Le fichier ne sera pas sauvegarde."))
- msgBox.addButton(texte,0)
- msgBox.addButton(tr("&Annuler"),1)
- res=msgBox.exec_()
- else:
- res = QMessageBox.warning(
- None,
- tr("Fichier Duplique"),
- tr("Le fichier ne sera pas sauvegarde."),
- tr(texte),
- tr("&Annuler"))
+ if (editor.modified) and (editor in self.doubles) :
+ msgBox = QMessageBox(None)
+ msgBox.setWindowTitle(tr("Fichier Duplique"))
+ msgBox.setText(tr("Le fichier ne sera pas sauvegarde."))
+ msgBox.addButton(texte,0)
+ msgBox.addButton(tr("&Annuler"),1)
+ res=msgBox.exec_()
if res == 0 : return 1
return 2
if editor.modified:
fn = editor.getFileName()
if fn is None: fn = tr('Noname')
- if monEnvQT5 :
- msgBox = QMessageBox(None)
- msgBox.setWindowTitle(tr("Fichier Modifie"))
- msgBox.setText(tr("Le fichier ne sera pas sauvegarde."))
- msgBox.addButton(tr("&Sauvegarder"),1)
- msgBox.addButton(tr("&Quitter sans sauvegarder"),0)
- res=msgBox.exec_()
- else :
- res = QMessageBox.warning(self.appliEficas,
- tr("Fichier Modifie"),
- tr("Le fichier %s n a pas ete sauvegarde.",str(fn)),
- tr("&Sauvegarder"),
- tr(texte),
- tr("&Quitter sans sauvegarder") )
- if res == 2 : res = 1
+ msgBox = QMessageBox(None)
+ msgBox.setWindowTitle(tr("Fichier Modifie"))
+ msgBox.setText(tr("Le fichier ne sera pas sauvegarde."))
+ msgBox.addButton(tr("&Sauvegarder"),1)
+ msgBox.addButton(tr("&Quitter sans sauvegarder"),0)
+ res=msgBox.exec_()
+ if res == 2 : res = 1
if res == 0:
(ok, newName) = editor.saveFile()
if ok:
- fileName=os.path.basename(unicode(newName))
+ fileName=os.path.basename(six.text_type(newName))
index=self.myQtab.currentIndex()
self.myQtab.setTabText(index,fileName)
return ok
"""
-from N_utils import import_object
-from N_info import message, SUPERV
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import object
+except : pass
class ASSD(object):
def __init__(self, etape=None, sd=None, reg='oui'):
"""
- reg est un paramètre qui vaut oui ou non :
- - si oui (défaut) : on enregistre la SD auprès du JDC
+ reg est un parametre qui vaut oui ou non :
+ - si oui (défaut) : on enregistre la SD aupres du JDC
- si non : on ne l'enregistre pas
"""
self.etape = etape
sdj = property(_get_sdj, None, _del_sdj)
def __getitem__(self, key):
- from strfunc import convert
- text_error = convert(_(u"ASSD.__getitem__ est déprécié car la référence à "
- u"l'objet ETAPE parent sera supprimée."))
- # raise NotImplementedError(text_error)
+ text_error = "ASSD.__getitem__ est déprécié car la référence a l'objet ETAPE parent sera supprimée."
from warnings import warn
warn(text_error, DeprecationWarning, stacklevel=2)
return self.etape[key]
# 'del self.sdj' appellerait la méthode '_get_sdj()'...
self._del_sdj()
- def __del__(self):
- # message.debug(SUPERV, "__del__ ASSD %s <%s>", getattr(self, 'nom',
- # 'unknown'), self)
- pass
def accept(self, visitor):
"""
"""
Cette methode permet de pickler les objets ASSD
Ceci est possible car on coupe les liens avec les objets
- parent, etape et jdc qui conduiraient à pickler de nombreux
+ parent, etape et jdc qui conduiraient a pickler de nombreux
objets inutiles ou non picklables.
- En sortie, l'objet n'est plus tout à fait le même !
+ En sortie, l'objet n'est plus tout a fait le même !
"""
d = self.__dict__.copy()
for key in ('parent', 'etape', 'jdc'):
- if d.has_key(key):
+ if key in d :
del d[key]
- for key in d.keys():
+ for key in list(d.keys()):
if key in ('_as_co', ):
continue
if key[0] == '_':
"""Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD.
"""
if CONTEXT.debug:
- print '| accessible ?', self.nom
+ print(('| accessible ?', self.nom))
is_accessible = CONTEXT.get_current_step().sd_accessible()
if CONTEXT.debug:
- print ' `- is_accessible =', repr(is_accessible)
+ print((' `- is_accessible =', repr(is_accessible)))
return is_accessible
def filter_context(self, context):
"""Filtre le contexte fourni pour retirer (en gros) ce qui vient du catalogue."""
- from N_ENTITE import ENTITE
+ from .N_ENTITE import ENTITE
import types
ctxt = {}
- for key, value in context.items():
- if type(value) is types.ClassType:
+ for key, value in list(context.items()):
+ if type(value) is type:
continue
if type(value) is types.ModuleType and value.__name__.startswith('Accas'):
continue
- if issubclass(type(value), types.TypeType):
+ if issubclass(type(value), type):
continue
if isinstance(value, ENTITE):
continue
+++ /dev/null
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# 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 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
-
-"""
-
-"""
-
-class ASSD(object):
- """
- Classe de base pour definir des types de structures de donnees ASTER
- equivalent d un concept ASTER
- """
- idracine="SD"
-
- def __init__(self,etape=None,sd=None,reg='oui'):
- """
- reg est un paramètre qui vaut oui ou non :
- - si oui (défaut) : on enregistre la SD auprès du JDC
- - si non : on ne l'enregistre pas
- """
- self.etape=etape
- self.sd=sd
- self.nom=None
- if etape:
- self.parent=etape.parent
- else:
- self.parent=CONTEXT.get_current_step()
- if self.parent :
- self.jdc = self.parent.get_jdc_root()
- else:
- self.jdc = None
-
- if not self.parent:
- self.id=None
- elif reg == 'oui' :
- self.id = self.parent.reg_sd(self)
- else :
- self.id = self.parent.o_register(self)
- # permet de savoir si le concept a été calculé (1) ou non (0)
- self.executed = 0
- # initialise la partie "sd"
- super(ASSD, self).__init__(nomj='?&?&?&?&')
-
- def __getitem__(self,key):
- return self.etape[key]
-
- def set_name(self, nom):
- """Positionne le nom de self (et appelle sd_init)
- """
- self.nom = nom
- # test car FORMULE n'a pas de SD associée
- meth = getattr(super(ASSD, self), 'set_name', None)
- if meth:
- meth(nom)
-
- def reparent_sd(self):
- """Repositionne le parent des attributs de la SD associée.
- """
- # test car FORMULE n'a pas de SD associée
- meth = getattr(super(ASSD, self), 'reparent', None)
- if meth:
- meth(None, None)
-
- def get_name(self):
- """
- Retourne le nom de self, éventuellement en le demandant au JDC
- """
- if not self.nom :
- try:
- self.nom=self.parent.get_name(self) or self.id
- except:
- self.nom=""
- if self.nom.find('sansnom') != -1 or self.nom == '':
- self.nom = self.id
- return self.nom
-
- def supprime(self):
- """
- Cassage des boucles de références pour destruction du JDC
- """
- self.etape = None
- self.sd = None
- self.jdc = None
- self.parent = None
-
- def accept(self,visitor):
- """
- Cette methode permet de parcourir l'arborescence des objets
- en utilisant le pattern VISITEUR
- """
- visitor.visitASSD(self)
-
- def __getstate__(self):
- """
- Cette methode permet de pickler les objets ASSD
- Ceci est possible car on coupe les liens avec les objets
- parent, etape et jdc qui conduiraient à pickler de nombreux
- objets inutiles ou non picklables.
- """
- d=self.__dict__.copy()
- for key in ('parent','etape','jdc'):
- if d.has_key(key):del d[key]
- for key in d.keys():
- if key[0]=='_':del d[key]
- return d
-
- def par_lot(self):
- """
- Retourne True si l'ASSD est créée en mode PAR_LOT='OUI'.
- """
- if not hasattr(self, 'jdc') or self.jdc == None:
- val = None
- else:
- val = self.jdc.par_lot
- return val == 'OUI'
-
-class assd(ASSD):
- def __convert__(cls,valeur):
- return valeur
- __convert__=classmethod(__convert__)
qui permet de spécifier les caractéristiques des blocs de mots clés
"""
+from __future__ import absolute_import
+from __future__ import print_function
import types
-import string
import sys
import traceback
-import N_ENTITE
-import N_MCBLOC
-from N_Exception import AsException
-from N_types import force_list
-from strfunc import ufmt
+from . import N_ENTITE
+from . import N_MCBLOC
+from .N_Exception import AsException
+from .N_types import force_list
class BLOC(N_ENTITE.ENTITE):
self.fr = fr
self.ang = ang
self.docu = docu
- if type(regles) == types.TupleType:
+ if type(regles) == tuple:
self.regles = regles
else:
self.regles = (regles,)
if CONTEXT.debug:
l = traceback.format_exception(
sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
- print "WARNING : Erreur a l'evaluation de la condition " + string.join(l)
+ print(("WARNING : Erreur a l'evaluation de la condition " + ''.join(l)))
return 0
except SyntaxError:
# le texte de la condition n'est pas du Python correct -->
sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
raise AsException(
"Catalogue entite : ", self.nom, ", de pere : ", self.pere.nom,
- '\n', "Erreur dans la condition : ", self.condition, string.join(l))
+ '\n', "Erreur dans la condition : ", self.condition, ''.join(l))
except:
l = traceback.format_exception(
sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
raise AsException(
"Catalogue entite : ", self.nom, ", de pere : ", self.pere.nom,
- '\n', "Erreur dans la condition : ", self.condition, string.join(l))
+ '\n', "Erreur dans la condition : ", self.condition, ''.join(l))
else:
return 0
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-from N_ASSD import ASSD
-from N_Exception import AsException
-from N_VALIDATOR import ValError
-import N_utils
+from __future__ import absolute_import
+from .N_ASSD import ASSD
+from .N_Exception import AsException
+from .N_VALIDATOR import ValError
+from . import N_utils
-from asojb import AsBase
+#from asojb import AsBase
-class CO(ASSD, AsBase):
+#class CO(ASSD, AsBase):
+class CO(ASSD) :
def __init__(self, nom):
ASSD.__init__(self, etape=None, sd=None, reg='oui')
if self.parent:
try:
self.parent.NommerSdprod(self, nom)
- except AsException, e:
+ except AsException as e:
appel = N_utils.callee_where(niveau=2)
raise AsException(
"Concept CO, fichier: ", appel[1], " ligne : ", appel[0], '\n', e)
Module de conversion des valeurs saisies par l'utilisateur après vérification.
"""
-from N_types import is_int, is_float, is_sequence
+from __future__ import absolute_import
+try:
+ from builtins import object
+except : pass
+
+from .N_types import is_int, is_float, is_sequence
def has_int_value(real):
return abs(int(real) - real) < 1.e-12
-class Conversion:
+class Conversion(object):
"""Conversion de type.
"""
return tuple(result)
def function(self, o):
- raise NotImplementedError, 'cette classe doit être dérivée'
+ raise NotImplementedError('cette classe doit être dérivée')
class TypeConversion(Conversion):
""" Ce module contient la classe compte-rendu de validation
"""
-import string
-from strfunc import convert, ufmt
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except :
+ pass
+import six
-class CR:
+class CR(object):
"""
- Classe servant à la construction et à l'affichage des objets Comptes-rendus
+ Classe servant a la construction et a l'affichage des objets Comptes-rendus
"""
def __init__(self, verbeux='non', debut='', fin='', dec=' '):
self.subcr = []
def ok(self, comment):
- """ Ajoute un commentaire OK à la liste crok"""
+ """ Ajoute un commentaire OK a la liste crok"""
self.crok.append(comment)
def warn(self, comment):
- """ Ajoute un commentaire Warning à la liste crwarn"""
+ """ Ajoute un commentaire Warning a la liste crwarn"""
self.crwarn.append(comment)
def fatal(self, comment, *args):
- """Ajoute un commentaire Erreur Fatale à la liste crfatal à formater"""
- self.crfatal.append(ufmt(comment, *args))
+ """Ajoute un commentaire Erreur Fatale a la liste crfatal a formater"""
+ self.crfatal.append(comment)
+ self.crfatal.append(str( *args))
def exception(self, comment):
- """ Ajoute un commentaire Exception à la liste crexception"""
+ """ Ajoute un commentaire Exception a la liste crexception"""
self.crexception.append(comment)
def add(self, cr):
- """ Ajoute un objet CR à la liste subcr :il s'agit de l'objet CR d'un fils de self """
+ """ Ajoute un objet CR a la liste subcr :il s'agit de l'objet CR d'un fils de self """
self.subcr.append(cr)
def estvide(self):
"""
Insère en tete de chaque ligne du texte s la chaine self.dec
"""
- l = string.split(s, '\n')
- return self.dec + string.join(l, '\n' + self.dec)[:-3]
+ l = s.split( '\n')
+ a='\n' + self.dec
+ return self.dec + a.join(l)[:-3]
def __unicode__(self):
"""
"""
s = ''
self.beautifie_messages()
- s = s + string.join(self.crok_belle, '')
- s = s + string.join(self.crwarn_belle, '')
- s = s + string.join(self.crfatal_belle, '')
- s = s + string.join(self.crexception_belle, '')
+ s = s + ''.join(self.crok_belle)
+ s = s + ''.join(self.crwarn_belle)
+ s = s + ''.join(self.crfatal_belle)
+ s = s + ''.join(self.crexception_belle)
for subcr in self.subcr:
if self.verbeux == 'oui':
- s = s + unicode(subcr) + '\n'
+ s = s + six.text_type(subcr) + '\n'
else:
if not subcr.estvide():
- s = s + unicode(subcr)
+ s = s + six.text_type(subcr)
if s != '':
s = self.debut + '\n' + self.indent(s) + self.fin + '\n'
else:
def __str__(self):
"""Return the report representation"""
- # convert into the output encoding
- txt = convert(self.__unicode__())
+ txt = self.__unicode__()
return txt
def report(self, decalage=2):
def split(ligne, cesure):
- ligne = string.rstrip(ligne)
+ ligne = ligne.rstrip()
if len(ligne) <= cesure:
return ligne
else:
def justify_text(texte='', cesure=50):
- texte = string.strip(texte)
- liste_lignes = string.split(texte, '\n')
+ if not isinstance (texte,str) : texte = ''.join(texte)
+ texte = texte.strip()
+ liste_lignes = texte.split('\n')
l = [split(l, cesure) for l in liste_lignes]
- texte_justifie = string.join(l, '\n')
+ texte_justifie = '\n'.join(l)
return texte_justifie
d'éléments 'motif'
"""
texte = justify_text(texte, cesure=80)
- lignes = string.split(texte, '\n')
+ if texte.strip() == "" : return ''
+ lignes = texte.split( '\n')
longueur = 0
for ligne in lignes:
- ligne = string.rstrip(ligne)
+ ligne = ligne.rstrip()
if len(ligne) > longueur:
longueur = len(ligne)
longueur = longueur + 4
txt = motif * longueur + '\n'
for ligne in lignes:
+ if ligne == '' : continue
txt = txt + motif + ' ' + ligne + ' ' * \
(longueur - len(motif + ligne) - 2) + motif + '\n'
txt = txt + motif * longueur + '\n'
de toutes les classes de definition d'EFICAS.
"""
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import object
+except :
+ pass
import re
-import N_CR
-import N_OPS
-import N_VALIDATOR
-from strfunc import ufmt
+from . import N_CR
+from . import N_OPS
+from . import N_VALIDATOR
-from determine import monEnvQT5
-if monEnvQT5:
- stringTypes = (str, unicode)
-else :
- try:
- from PyQt4 import QtCore
- stringTypes = (str, unicode, QtCore.QString)
- except ImportError:
- stringTypes = (str, unicode)
+import six
+stringTypes = (str, six.text_type)
-class ENTITE:
+class ENTITE(object):
"""
Classe de base pour tous les objets de definition : mots cles et commandes
directement
Il s'agit principalement des mots cles
"""
- for k, v in self.entites.items():
+ for k, v in list(self.entites.items()):
v.pere = self
v.nom = k
"""
self.cr = self.CR()
self.verif_cata()
- for k, v in self.entites.items():
+ for k, v in list(self.entites.items()):
try:
cr = v.report()
cr.debut = u"Début " + v.__class__.__name__ + ' : ' + k
cr.fin = u"Fin " + v.__class__.__name__ + ' : ' + k
self.cr.add(cr)
except:
- self.cr.fatal(
- _(u"Impossible d'obtenir le rapport de %s %s"), k, `v`)
- print "Impossible d'obtenir le rapport de %s %s" % (k, `v`)
- print "père =", self
+ self.cr.fatal("Impossible d'obtenir le rapport de %s %s" % (k, repr(v)))
+ print(("Impossible d'obtenir le rapport de %s %s" % (k, repr(v))))
+ print(("père =", self))
return self.cr
def verif_cata_regles(self):
for regle in self.regles:
l = []
for mc in regle.mcs:
- if not self.entites.has_key(mc):
+ if not mc in self.entites :
l.append(mc)
if l != []:
txt = str(regle)
"""Verifie la definition d'un objet composite (commande, fact, bloc)."""
args = self.entites.copy()
mcs = set()
- for nom, val in args.items():
+ for nom, val in list(args.items()):
if val.label == 'SIMP':
mcs.add(nom)
# XXX
del args[nom]
# seuls les blocs peuvent entrer en conflit avec les mcs du plus haut
# niveau
- for nom, val in args.items():
+ for nom, val in list(args.items()):
if val.label == 'BLOC':
mcbloc = val.check_definition(parent)
# XXX
def check_min_max(self):
"""Vérifie les attributs min/max."""
if type(self.min) != int:
- if self.min != '**':
+ if self.min != '**'and self.min != float('-inf'):
self.cr.fatal(
_(u"L'attribut 'min' doit être un entier : %r"), self.min)
if type(self.max) != int:
- if self.max != '**':
+ if self.max != '**' and self.max != float('inf'):
self.cr.fatal(
_(u"L'attribut 'max' doit être un entier : %r"), self.max)
if self.min > self.max:
"""
- Ce module contient la classe ETAPE qui sert à vérifier et à exécuter
+ Ce module contient la classe ETAPE qui sert a verifier et a executer
une commande
"""
# Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except :
+ pass
import types
import sys
-import string
import os
import linecache
import traceback
from copy import copy
# Modules EFICAS
-import N_MCCOMPO
-from N_Exception import AsException
-import N_utils
-from N_utils import AsType
-from N_ASSD import ASSD
-from N_info import message, SUPERV
+from . import N_MCCOMPO
+from .N_Exception import AsException
+from . import N_utils
+from .N_utils import AsType
+from .N_ASSD import ASSD
class ETAPE(N_MCCOMPO.MCCOMPO):
"""
- Cette classe hérite de MCCOMPO car ETAPE est un OBJECT composite
+ Cette classe herite de MCCOMPO car ETAPE est un OBJECT composite
"""
nature = "OPERATEUR"
- # L'attribut de classe codex est utilisé pour rattacher le module de calcul éventuel (voir Build)
- # On le met à None pour indiquer qu'il n'y a pas de module de calcul
- # rattaché
+ # L'attribut de classe codex est utilise pour rattacher le module de calcul eventuel (voir Build)
+ # On le met a None pour indiquer qu'il n'y a pas de module de calcul
+ # rattache
codex = None
def __init__(self, oper=None, reuse=None, args={}, niveau=4):
"""
Attributs :
- - definition : objet portant les attributs de définition d'une étape de type opérateur. Il
- est initialisé par l'argument oper.
- - reuse : indique le concept d'entrée réutilisé. Il se trouvera donc en sortie
- si les conditions d'exécution de l'opérateur l'autorise
- - valeur : arguments d'entrée de type mot-clé=valeur. Initialisé avec l'argument args.
+ - definition : objet portant les attributs de definition d'une etape de type operateur. Il
+ est initialise par l'argument oper.
+ - reuse : indique le concept d'entree reutilise. Il se trouvera donc en sortie
+ si les conditions d'execution de l'operateur l'autorise
+ - valeur : arguments d'entree de type mot-cle=valeur. Initialise avec l'argument args.
"""
self.definition = oper
self.reuse = reuse
def make_register(self):
"""
- Initialise les attributs jdc, id, niveau et réalise les
- enregistrements nécessaires
+ Initialise les attributs jdc, id, niveau et realise les
+ enregistrements necessaires
"""
if self.parent:
self.jdc = self.parent.get_jdc_root()
def nettoiargs(self):
"""
- Cette methode a pour fonction de retirer tous les arguments egaux à None
- de la liste des arguments. Ils sont supposés non présents et donc retirés.
+ Cette methode a pour fonction de retirer tous les arguments egaux a None
+ de la liste des arguments. Ils sont supposes non presents et donc retires.
"""
- for k in self.valeur.keys():
+ for k in list(self.valeur.keys()):
if self.valeur[k] == None:
del self.valeur[k]
def Build_sd(self, nom):
"""
- Construit le concept produit de l'opérateur. Deux cas
- peuvent se présenter :
+ Construit le concept produit de l'operateur. Deux cas
+ peuvent se presenter :
- - le parent n'est pas défini. Dans ce cas, l'étape prend en charge la création
+ - le parent n'est pas defini. Dans ce cas, l'etape prend en charge la creation
et le nommage du concept.
- - le parent est défini. Dans ce cas, l'étape demande au parent la création et
+ - le parent est defini. Dans ce cas, l'etape demande au parent la creation et
le nommage du concept.
"""
- # message.debug(SUPERV, "Build_sd %s", self.nom)
self.sdnom = nom
try:
if self.parent:
sd = self.parent.create_sdprod(self, nom)
if type(self.definition.op_init) == types.FunctionType:
- apply(self.definition.op_init, (
+ self.definition.op_init(*(
self, self.parent.g_context))
else:
sd = self.get_sd_prod()
# On ne nomme le concept que dans le cas de non reutilisation
# d un concept
sd.set_name(nom)
- except AsException, e:
+ except AsException as e:
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1], e)
except EOFError:
sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1] + '\n',
- string.join(l))
+ ''.join(l))
self.Execute()
return sd
def get_sd_prod(self):
"""
- Retourne le concept résultat de l'étape
+ Retourne le concept resultat de l'etape
Deux cas :
- cas 1 : sd_prod de oper n'est pas une fonction
il s'agit d'une sous classe de ASSD
- on construit le sd à partir de cette classe
+ on construit le sd a partir de cette classe
et on le retourne
- cas 2 : il s'agit d'une fonction
- on l'évalue avec les mots-clés de l'étape (mc_liste)
- on construit le sd à partir de la classe obtenue
+ on l'evalue avec les mots-cles de l'etape (mc_liste)
+ on construit le sd a partir de la classe obtenue
et on le retourne
"""
if type(self.definition.sd_prod) == types.FunctionType:
d = self.cree_dict_valeurs(self.mc_liste)
try:
- sd_prod = apply(self.definition.sd_prod, (), d)
+ sd_prod = self.definition.sd_prod(*(), **d)
except EOFError:
raise
- except Exception, exc:
+ except Exception as exc:
if CONTEXT.debug:
traceback.print_exc()
raise AsException("impossible d affecter un type au resultat:",
str(exc))
else:
sd_prod = self.definition.sd_prod
- # on teste maintenant si la SD est réutilisée ou s'il faut la créer
+ # on teste maintenant si la SD est reutilisee ou s'il faut la creer
if self.definition.reentrant != 'n' and self.reuse:
# Le concept produit est specifie reutilise (reuse=xxx). C'est une erreur mais non fatale.
# Elle sera traitee ulterieurement.
self.sd = sd_prod(etape=self)
# Si l'operateur est obligatoirement reentrant et reuse n'a pas ete specifie, c'est une erreur.
# On ne fait rien ici. L'erreur sera traiter par la suite.
- # précaution
+ # precaution
if self.sd is not None and not isinstance(self.sd, ASSD):
raise AsException("""
-Impossible de typer le résultat !
+Impossible de typer le resultat !
Causes possibles :
Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte,
- soit il y a une "," à la fin d'une commande précédente.
- Développeur : La fonction "sd_prod" retourne un type invalide.""")
+ soit il y a une "," a la fin d'une commande precedente.
+ Developpeur : La fonction "sd_prod" retourne un type invalide.""")
return self.sd
def get_type_produit(self):
def get_type_produit_brut(self):
"""
- Retourne le type du concept résultat de l'étape
+ Retourne le type du concept resultat de l'etape
Deux cas :
- cas 1 : sd_prod de oper n'est pas une fonction
il s'agit d'une sous classe de ASSD
on retourne le nom de la classe
- cas 2 : il s'agit d'une fonction
- on l'évalue avec les mots-clés de l'étape (mc_liste)
- et on retourne son résultat
+ on l'evalue avec les mots-cles de l'etape (mc_liste)
+ et on retourne son resultat
"""
if type(self.definition.sd_prod) == types.FunctionType:
d = self.cree_dict_valeurs(self.mc_liste)
- sd_prod = apply(self.definition.sd_prod, (), d)
+ sd_prod = self.definition.sd_prod(*(), **d)
else:
sd_prod = self.definition.sd_prod
return sd_prod
def get_etape(self):
"""
- Retourne l'étape à laquelle appartient self
- Un objet de la catégorie etape doit retourner self pour indiquer que
- l'étape a été trouvée
+ Retourne l'etape a laquelle appartient self
+ Un objet de la categorie etape doit retourner self pour indiquer que
+ l'etape a ete trouvee
"""
return self
def supprime(self):
"""
- Méthode qui supprime toutes les références arrières afin que l'objet puisse
- etre correctement détruit par le garbage collector
+ Methode qui supprime toutes les references arrières afin que l'objet puisse
+ etre correctement detruit par le garbage collector
"""
N_MCCOMPO.MCCOMPO.supprime(self)
self.jdc = None
self.sd.supprime()
def __del__(self):
- # message.debug(SUPERV, "__del__ ETAPE %s <%s>", getattr(self, 'nom', 'unknown'), self)
- # if self.sd:
- # message.debug(SUPERV, " sd : %s", self.sd.nom)
pass
def get_created_sd(self):
- """Retourne la liste des sd réellement produites par l'étape.
- Si reuse est présent, `self.sd` a été créée avant, donc n'est pas dans
+ """Retourne la liste des sd reellement produites par l'etape.
+ Si reuse est present, `self.sd` a ete creee avant, donc n'est pas dans
cette liste."""
if not self.reuse and self.sd:
return [self.sd, ]
def isactif(self):
"""
- Indique si l'étape est active (1) ou inactive (0)
+ Indique si l'etape est active (1) ou inactive (0)
"""
return self.actif
Methode utilisee pour que l etape self se declare etape
courante. Utilise par les macros
"""
- # message.debug(SUPERV, "call etape.set_current_step", stack_id=-1)
cs = CONTEXT.get_current_step()
if self.parent != cs:
- raise AsException("L'étape courante", cs.nom, cs,
+ raise AsException("L'etape courante", cs.nom, cs,
"devrait etre le parent de", self.nom, self)
else:
CONTEXT.unset_current_step()
"""
cs = CONTEXT.get_current_step()
if self != cs:
- raise AsException("L'étape courante", cs.nom, cs,
+ raise AsException("L'etape courante", cs.nom, cs,
"devrait etre", self.nom, self)
else:
CONTEXT.unset_current_step()
sous etape de self ou non
1 = oui
0 = non
- Une étape simple n'a pas de sous etape
+ Une etape simple n'a pas de sous etape
"""
return 0
def get_file(self, unite=None, fic_origine='', fname=None):
"""
- Retourne le nom du fichier correspondant à un numero d'unité
+ Retourne le nom du fichier correspondant a un numero d'unite
logique (entier) ainsi que le source contenu dans le fichier
"""
if self.jdc:
l'appelant en argument (d) en fonction de sa definition
"""
if type(self.definition.op_init) == types.FunctionType:
- apply(self.definition.op_init, (self, d))
+ self.definition.op_init(*(self, d))
if self.sd:
d[self.sd.nom] = self.sd
def copy(self):
- """ Méthode qui retourne une copie de self non enregistrée auprès du JDC
+ """ Methode qui retourne une copie de self non enregistree auprès du JDC
et sans sd
"""
etape = copy(self)
return etape
def copy_reuse(self, old_etape):
- """ Méthode qui copie le reuse d'une autre étape.
+ """ Methode qui copie le reuse d'une autre etape.
"""
if hasattr(old_etape, "reuse"):
self.reuse = old_etape.reuse
def copy_sdnom(self, old_etape):
- """ Méthode qui copie le sdnom d'une autre étape.
+ """ Methode qui copie le sdnom d'une autre etape.
"""
if hasattr(old_etape, "sdnom"):
self.sdnom = old_etape.sdnom
def get_cmd(self, nomcmd):
"""
- Méthode pour recuperer la definition d'une commande
+ Methode pour recuperer la definition d'une commande
donnee par son nom dans les catalogues declares
au niveau du jdc
Appele par un ops d'une macro en Python
def copy_intern(self, etape):
"""
- Méthode permettant lors du processus de recopie de copier
+ Methode permettant lors du processus de recopie de copier
les elements internes d'une etape dans une autre
"""
return
def full_copy(self, parent=None):
"""
- Méthode permettant d'effectuer une copie complète
- d'une étape (y compris concept produit, éléments internes)
- Si l'argument parent est fourni, la nouvelle étape
+ Methode permettant d'effectuer une copie complète
+ d'une etape (y compris concept produit, elements internes)
+ Si l'argument parent est fourni, la nouvelle etape
aura cet objet comme parent.
"""
new_etape = self.copy()
self.parent.NommerSdprod(self.sd, self.sd.nom)
def is_include(self):
- """Permet savoir si on a affaire à la commande INCLUDE
+ """Permet savoir si on a affaire a la commande INCLUDE
car le comportement de ces macros est particulier.
"""
return self.nom.startswith('INCLUDE')
def sd_accessible(self):
- """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD produite par l'étape.
+ """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD produite par l'etape.
"""
if CONTEXT.debug:
- print '`- ETAPE sd_accessible :', self.nom
+ print(('`- ETAPE sd_accessible :', self.nom))
return self.parent.sd_accessible()
def get_concept(self, nomsd):
"""
- Méthode pour recuperer un concept à partir de son nom
+ Methode pour recuperer un concept a partir de son nom
"""
- # pourrait être appelée par une commande fortran faisant appel à des fonctions python
+ # pourrait etre appelee par une commande fortran faisant appel a des fonctions python
# on passe la main au parent
return self.parent.get_concept(nomsd)
"""
# Modules EFICAS
-from strfunc import get_encoding, to_unicode
+from __future__ import absolute_import
+from .strfunc import get_encoding, to_unicode
+import six
class AsException(Exception):
args = []
for x in self.args:
ustr = to_unicode(x)
- if type(ustr) is not unicode:
- ustr = unicode( repr(x) )
+ if type(ustr) is not six.text_type:
+ ustr = six.text_type( repr(x) )
args.append(ustr)
return " ".join(args)
def __str__(self):
- return unicode(self).encode(get_encoding())
+ return six.text_type(self).encode(get_encoding())
class InterruptParsingError(Exception):
qui permet de spécifier les caractéristiques des mots clés facteurs
"""
+from __future__ import absolute_import
+from __future__ import print_function
import types
-import N_ENTITE
-import N_MCFACT
-import N_MCLIST
-from N__F import _F
-from N_types import is_sequence
-from strfunc import ufmt
+from . import N_ENTITE
+from . import N_MCFACT
+from . import N_MCLIST
+from .N__F import _F
+from .N_types import is_sequence
-import N_OBJECT
+from . import N_OBJECT
class FACT(N_ENTITE.ENTITE):
self.fr = fr
self.ang=ang
self.docu = docu
- if type(regles) == types.TupleType:
+ if type(regles) == tuple:
self.regles = regles
else:
self.regles = (regles,)
self.defaut = defaut
self.min = min
self.max = max
+ if self.max == "**" : self.max=float('inf')
+ if self.min == "**" : self.min=float('-inf')
self.entites = args
self.position = None
self.affecter_parente()
if val is None:
if self.defaut == None:
val = {}
- elif type(self.defaut) == types.TupleType:
+ elif type(self.defaut) == tuple:
val = self.defaut
# Est ce utile ? Le défaut pourrait etre uniquement un dict
- elif type(self.defaut) == types.DictType or isinstance(self.defaut, _F):
+ elif type(self.defaut) == dict or isinstance(self.defaut, _F):
val = self.defaut
else:
# On ne devrait jamais passer par la
- print "On ne devrait jamais passer par la"
+ print ("On ne devrait jamais passer par la")
return None
elif is_sequence(val) and len(val) == 0 and self.statut == 'o':
# On est dans le cas où le mcfact est présent mais est une liste/tuple
# On cree toujours une liste de mcfact
l = self.list_instance()
l.init(nom=nom, parent=parent)
- if type(val) in (types.TupleType, types.ListType, self.list_instance):
+ if type(val) in (tuple, list, self.list_instance):
for v in val:
- if type(v) == types.DictType or isinstance(v, _F):
+ if type(v) == dict or isinstance(v, _F):
objet = self.class_instance(
nom=nom, definition=self, val=v, parent=parent)
l.append(objet)
l.append(v)
else:
l.append(N_OBJECT.ErrorObj(self, v, parent, nom))
- elif type(val) == types.DictType or isinstance(val, _F):
+ elif type(val) == dict or isinstance(val, _F):
objet = self.class_instance(
nom=nom, definition=self, val=val, parent=parent)
l.append(objet)
# de la division réelle pour les entiers, et non la division entière
# 1/2=0.5 (et non 0). Comportement par défaut dans Python 3.0.
from __future__ import division
+from __future__ import absolute_import
+try :
+ from builtins import zip
+ from builtins import str
+except :
+ pass
from math import sin, cos, tan, asin, acos, atan2, atan, sinh, cosh, tanh
from math import pi, exp, log, log10, sqrt
-from N_ASSD import ASSD
-from N_info import message, SUPERV
+from .N_ASSD import ASSD
+from six.moves import zip
class FONCTION(ASSD):
ctxt.update(getattr(self.parent, 'const_context', {}))
ctxt.update(getattr(self.parent, 'macro_const_context', {}))
self.parent_context = self.filter_context(ctxt)
- # message.debug(SUPERV, "add parent_context %s %s", self.nom,
- # self.parent_context)
def __call__(self, *val):
"""Evaluation de la formule"""
try:
# globals() pour math.*
res = eval(self.code, context, globals())
- except Exception, exc:
- message.error(SUPERV, "ERREUR LORS DE L'ÉVALUATION DE LA FORMULE '%s' "
- ":\n>> %s", self.nom, str(exc))
+ except Exception as exc:
+ mes = "ERREUR LORS DE L EVALUATION DE LA FORMULE %s" %self.nom
+ print (mes)
raise
return res
self.expression = texte
try:
self.code = compile(texte, texte, 'eval')
- except SyntaxError, exc:
- message.error(SUPERV, "ERREUR LORS DE LA CREATION DE LA FORMULE '%s' "
- ":\n>> %s", self.nom, str(exc))
+ except SyntaxError as exc:
+ mes = "ERREUR LORS DE LA CREATION DE LA FORMULE %s" %self.nom
+ print (mes)
raise
def __setstate__(self, state):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-import N_MACRO
-import N_FORM_ETAPE
+from __future__ import absolute_import
+from . import N_MACRO
+from . import N_FORM_ETAPE
class FORM(N_MACRO.MACRO):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-import N_MACRO_ETAPE
+from __future__ import absolute_import
+from . import N_MACRO_ETAPE
class FORM_ETAPE(N_MACRO_ETAPE.MACRO_ETAPE):
"""
"""
-from N_ASSD import ASSD
+from __future__ import absolute_import
+from .N_ASSD import ASSD
+import six
class GEOM(ASSD):
return self.nom
def __convert__(cls, valeur):
- if isinstance(valeur, (str, unicode)) and len(valeur.strip()) <= 8:
+ if isinstance(valeur, (str, six.text_type)) and len(valeur.strip()) <= 8:
return valeur.strip()
raise ValueError(
_(u'On attend une chaine de caractères (de longueur <= 8).'))
"""
- Ce module contient la classe JDC qui sert à interpréter un jeu de commandes
+ Ce module contient la classe JDC qui sert a interpreter un jeu de commandes
"""
# Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+except : pass
import os
-import string
import traceback
import types
import sys
import linecache
# Modules EFICAS
-import N_OBJECT
-import N_CR
-from N_Exception import AsException, InterruptParsingError
-from N_ASSD import ASSD
-from N_info import message, SUPERV
-from strfunc import get_encoding
+from . import N_OBJECT
+from . import N_CR
+from .N_Exception import AsException, InterruptParsingError
+from .N_ASSD import ASSD
+from .strfunc import get_encoding
+from six.moves import range
MemoryErrorMsg = """MemoryError :
-En général, cette erreur se produit car la mémoire utilisée hors du fortran
+En general, cette erreur se produit car la memoire utilisee hors du fortran
(jeveux) est importante.
Causes possibles :
- le calcul produit de gros objets Python dans une macro-commande ou
- dans le jeu de commande lui-même,
+ dans le jeu de commande lui-meme,
- le calcul appelle un solveur (MUMPS par exemple) ou un outil externe
- qui a besoin de mémoire hors jeveux,
+ qui a besoin de memoire hors jeveux,
- utilisation de jeveux dynamique,
- ...
Solution :
- - distinguer la mémoire limite du calcul (case "Mémoire totale" de astk)
- de la mémoire réservée à jeveux (case "dont Aster"), le reste étant
+ - distinguer la memoire limite du calcul (case "Memoire totale" de astk)
+ de la memoire reservee a jeveux (case "dont Aster"), le reste etant
disponible pour les allocations dynamiques.
"""
NONE = None
"""
- from N_utils import SEP
+ from .N_utils import SEP
def __init__(self, definition=None, procedure=None, cata=None,
cata_ord_dico=None, parent=None,
self.procedure = procedure
self.definition = definition
self.cata = cata
- if type(self.cata) != types.TupleType and cata != None:
+ if type(self.cata) != tuple and cata != None:
self.cata = (self.cata,)
self._build_reserved_kw_list()
self.cata_ordonne_dico = cata_ord_dico
self.appli = appli
self.parent = parent
self.context_ini = context_ini
- # On conserve les arguments supplémentaires. Il est possible de passer
+ # On conserve les arguments supplementaires. Il est possible de passer
# des informations globales au JDC par ce moyen. Il pourrait etre plus
# sur de mettre en place le mecanisme des mots-cles pour verifier la
- # validité des valeurs passées.
- # Ceci reste à faire
+ # validite des valeurs passees.
+ # Ceci reste a faire
# On initialise avec les parametres de la definition puis on
# update avec ceux du JDC
self.args = self.definition.args
# on met le jdc lui-meme dans le context global pour l'avoir sous
# l'etiquette "jdc" dans le fichier de commandes
self.g_context = {'jdc': self}
- # message.debug(SUPERV, "g_context : %s - %s", self.g_context, id(self.g_context))
# Dictionnaire pour stocker tous les concepts du JDC (acces rapide par
# le nom)
self.sds_dict = {}
self.index_etape_courante = 0
self.UserError = "UserError"
self.alea = None
- # permet transitoirement de conserver la liste des étapes
+ # permet transitoirement de conserver la liste des etapes
self.hist_etape = False
def compile(self):
"""
Cette methode compile la chaine procedure
- Si des erreurs se produisent, elles sont consignées dans le
+ Si des erreurs se produisent, elles sont consignees dans le
compte-rendu self.cr
"""
try:
encoded_filename = self.nom.encode(get_encoding())
self.proc_compile = compile(
self.procedure, encoded_filename, 'exec')
- except SyntaxError, e:
+ except SyntaxError as e:
if CONTEXT.debug:
traceback.print_exc()
l = traceback.format_exception_only(SyntaxError, e)
- self.cr.exception("Compilation impossible : " + string.join(l))
- except MemoryError, e:
+ self.cr.exception("Compilation impossible : " + ''.join(l))
+ except MemoryError as e:
self.cr.exception(MemoryErrorMsg)
- except SystemError, e:
+ except SystemError as e:
erreurs_connues = """
Causes possibles :
- - offset too large : liste trop longue derrière un mot-clé.
+ - offset too large : liste trop longue derrière un mot-cle.
Solution : liste = (valeurs, ..., )
MOT_CLE = *liste,
"""
def exec_compile(self):
"""
- Cette méthode execute le jeu de commandes compilé dans le contexte
+ Cette methode execute le jeu de commandes compile dans le contexte
self.g_context de l'objet JDC
"""
CONTEXT.set_current_step(self)
- # Le module nommage utilise le module linecache pour accéder
+ # Le module nommage utilise le module linecache pour acceder
# au source des commandes du jeu de commandes.
# Dans le cas d'un fichier, on accède au contenu de ce fichier
- # Dans le cas d'une chaine de caractères il faut accéder
+ # Dans le cas d'une chaine de caractères il faut acceder
# aux commandes qui sont dans la chaine
import linecache
- linecache.cache[self.nom] = 0, 0, string.split(
- self.procedure, '\n'), self.nom
+ linecache.cache[self.nom] = 0, 0, self.procedure.split('\n'), self.nom
try:
- exec self.exec_init in self.g_context
- # message.debug(SUPERV, "JDC.exec_compile_1 - len(g_context) = %d",
- # len(self.g_context.keys()))
+ exec(self.exec_init, self.g_context)
for obj_cata in self.cata:
if type(obj_cata) == types.ModuleType:
init2 = "from " + obj_cata.__name__ + " import *"
- exec init2 in self.g_context
- # message.debug(SUPERV, "JDC.exec_compile_2 - len(g_context) = %d",
- # len(self.g_context.keys()))
+ exec(init2, self.g_context)
- # Initialisation du contexte global pour l'évaluation des conditions de BLOC
+ # Initialisation du contexte global pour l'evaluation des conditions de BLOC
# On utilise une copie de l'initialisation du contexte du jdc
self.condition_context = self.g_context.copy()
# Si l'attribut context_ini n'est pas vide, on ajoute au contexte global
- # le contexte initial (--> permet d'évaluer un JDC en récupérant un contexte
+ # le contexte initial (--> permet d'evaluer un JDC en recuperant un contexte
# d'un autre par exemple)
if self.context_ini:
self.g_context.update(self.context_ini)
# Update du dictionnaire des concepts
- for sdnom, sd in self.context_ini.items():
+ for sdnom, sd in list(self.context_ini.items()):
if isinstance(sd, ASSD):
self.sds_dict[sdnom] = sd
if self.appli != None:
self.appli.affiche_infos(
- 'Interprétation du fichier de commandes en cours ...')
+ 'Interpretation du fichier de commandes en cours ...')
# On sauve le contexte pour garder la memoire des constantes
# En mode edition (EFICAS) ou lors des verifications le contexte
- # est recalculé
+ # est recalcule
# mais les constantes sont perdues
self.const_context = self.g_context
- # message.debug(SUPERV, "pass")
- exec self.proc_compile in self.g_context
- # message.debug(SUPERV, "JDC.exec_compile_3 - len(g_context) = %d",
- # len(self.g_context.keys()))
+ exec(self.proc_compile, self.g_context)
CONTEXT.unset_current_step()
if self.appli != None:
self.affiche_fin_exec()
self.traiter_fin_exec('commande')
- except AsException, e:
+ except AsException as e:
# une erreur a ete identifiee
if CONTEXT.debug:
traceback.print_exc()
- # l'exception a été récupérée avant (où, comment ?),
+ # l'exception a ete recuperee avant (ou, comment ?),
# donc on cherche dans le texte
txt = str(e)
if txt.find('MemoryError') >= 0:
self.cr.exception(txt)
CONTEXT.unset_current_step()
- except NameError, e:
+ except NameError as e:
etype, value, tb = sys.exc_info()
l = traceback.extract_tb(tb)
s = traceback.format_exception_only("Erreur de nom", e)[0][:-1]
self.cr.exception(msg)
CONTEXT.unset_current_step()
- except self.UserError, exc_val:
- self.traiter_user_exception(exc_val)
- CONTEXT.unset_current_step()
- self.affiche_fin_exec()
- self.traiter_fin_exec('commande')
+ # except self.UserError as exc_val:
+ # self.traiter_user_exception(exc_val)
+ # CONTEXT.unset_current_step()
+ # self.affiche_fin_exec()
+ # self.traiter_fin_exec('commande')
except:
# erreur inattendue
# sys_exc_typ,sys_exc_value,sys_exc_frame = sys_exc.info()
- # (tuple de 3 éléments)
+ # (tuple de 3 elements)
if CONTEXT.debug:
traceback.print_exc()
exc_typ, exc_val, exc_fr = sys.exc_info()
l = traceback.format_exception(exc_typ, exc_val, exc_fr)
self.cr.exception(
- "erreur non prevue et non traitee prevenir la maintenance " + '\n' + string.join(l))
+ "erreur non prevue et non traitee prevenir la maintenance " + '\n' + ''.join(l))
del exc_typ, exc_val, exc_fr
CONTEXT.unset_current_step()
Par defaut il n'y a pas de traitement. Elle doit etre surchargee
pour en introduire un
"""
- message.info(SUPERV, "FIN D'EXECUTION %s %s", mode, etape)
+ print ( "FIN D'EXECUTION %s %s" %s( mode, etape))
def traiter_user_exception(self, exc_val):
"""Cette methode realise un traitement sur les exceptions utilisateur
- Par defaut il n'y a pas de traitement. La méthode doit etre
- surchargée pour en introduire un.
+ Par defaut il n'y a pas de traitement. La methode doit etre
+ surchargee pour en introduire un.
"""
return
def register(self, etape):
"""
- Cette méthode ajoute etape dans la liste des etapes : self.etapes
- et retourne un numéro d'enregistrement
+ Cette methode ajoute etape dans la liste des etapes : self.etapes
+ et retourne un numero d'enregistrement
"""
self.etapes.append(etape)
self.index_etapes[etape] = len(self.etapes) - 1
- # message.debug(SUPERV, "#%d %s", self.index_etapes[etape], etape.nom)
return self.g_register(etape)
def o_register(self, sd):
Retourne un identificateur pour concept
"""
self.nsd = self.nsd + 1
- nom = sd.idracine + self.SEP + `self.nsd`
+ nom = sd.idracine + self.SEP + repr(self.nsd)
return nom
def g_register(self, etape):
Retourne un identificateur pour etape
"""
self.nstep = self.nstep + 1
- idetape = etape.idracine + self.SEP + `self.nstep`
+ idetape = etape.idracine + self.SEP + repr(self.nstep)
return idetape
def create_sdprod(self, etape, nomsd):
Cette methode doit fabriquer le concept produit retourne
par l'etape etape et le nommer.
- Elle est appelée à l'initiative de l'etape
+ Elle est appelee a l'initiative de l'etape
pendant le processus de construction de cette etape :
methode __call__ de la classe CMD (OPER ou MACRO)
- Ce travail est réalisé par le contexte supérieur
+ Ce travail est realise par le contexte superieur
(etape.parent) car dans certains cas, le concept ne doit
- pas etre fabriqué mais l'etape doit simplement utiliser
- un concept préexistant.
+ pas etre fabrique mais l'etape doit simplement utiliser
+ un concept preexistant.
Deux cas possibles :
- - Cas 1 : etape.reuse != None : le concept est réutilisé
- - Cas 2 : l'étape appartient à une macro qui a déclaré un
+ - Cas 1 : etape.reuse != None : le concept est reutilise
+ - Cas 2 : l'etape appartient a une macro qui a declare un
concept de sortie qui doit etre produit par cette
etape.
Dans le cas du JDC, le deuxième cas ne peut pas se produire.
Nomme la SD apres avoir verifie que le nommage est possible : nom
non utilise
Si le nom est deja utilise, leve une exception
- Met le concept créé dans le concept global g_context
+ Met le concept cree dans le concept global g_context
"""
o = self.sds_dict.get(sdnom, None)
if isinstance(o, ASSD):
raise AsException("Nom de concept deja defini : %s" % sdnom)
if sdnom in self._reserved_kw:
raise AsException(
- "Nom de concept invalide. '%s' est un mot-clé réservé." % sdnom)
+ "Nom de concept invalide. '%s' est un mot-cle reserve." % sdnom)
# Ajoute a la creation (appel de reg_sd).
self.sds_dict[sdnom] = sd
# du JDC
if restrict == 'non':
self.g_context[sdnom] = sd
- # message.debug(SUPERV, "g_context[%r] = %s", sdnom, sd)
def reg_sd(self, sd):
"""
def delete_concept_after_etape(self, etape, sd):
"""
- Met à jour les étapes du JDC qui sont après etape suite à
+ Met a jour les etapes du JDC qui sont après etape suite a
la disparition du concept sd
"""
- # Cette methode est définie dans le noyau mais ne sert que pendant
+ # Cette methode est definie dans le noyau mais ne sert que pendant
# la phase de creation des etapes et des concepts. Il n'y a aucun
- # traitement particulier à réaliser.
- # Dans d'autres conditions, il faut surcharger cette méthode
+ # traitement particulier a realiser.
+ # Dans d'autres conditions, il faut surcharger cette methode
return
def supprime(self):
etape.supprime()
def clean(self, netapes):
- """Nettoie les `netapes` dernières étapes de la liste des étapes."""
+ """Nettoie les `netapes` dernières etapes de la liste des etapes."""
if self.hist_etape:
return
- for i in xrange(netapes):
+ for i in range(netapes):
e = self.etapes.pop()
jdc = e.jdc
parent = e.parent
e.supprime()
e.parent = parent
e.jdc = jdc
- # message.debug(SUPERV, "JDC.clean - etape = %r - refcount(e) = %d",
- # e.nom, sys.getrefcount(e))
del self.index_etapes[e]
def get_file(self, unite=None, fic_origine='', fname=None):
"""
- Retourne le nom du fichier correspondant à un numero d'unité
+ Retourne le nom du fichier correspondant a un numero d'unite
logique (entier) ainsi que le source contenu dans le fichier
"""
if self.appli:
- # Si le JDC est relié à une application maitre, on délègue la
+ # Si le JDC est relie a une application maitre, on delègue la
# recherche
return self.appli.get_file(unite, fic_origine)
else:
en fonction de la valeur du mot cle PAR_LOT et
du contexte : application maitre ou pas
- En PAR_LOT='NON', il n'y a pas d'ambiguité.
- En PAR_LOT='OUI', E_SUPERV positionne l'attribut à 'NON' après la phase
- d'analyse et juste avant la phase d'exécution.
+ En PAR_LOT='NON', il n'y a pas d'ambiguite.
+ d'analyse et juste avant la phase d'execution.
`user_value` : permet de stocker la valeur choisie par l'utilisateur
pour l'interroger plus tard (par exemple dans `get_contexte_avant`).
"""
- # message.debug(SUPERV, "set par_lot = %r", par_lot)
if user_value:
self.par_lot_user = par_lot
if self.appli == None:
"""
CONTEXT.set_current_step(self)
try:
- # Le module nommage utilise le module linecache pour accéder
+ # Le module nommage utilise le module linecache pour acceder
# au source des commandes du jeu de commandes.
# Dans le cas d'un fichier, on accède au contenu de ce fichier
- # Dans le cas de la console interactive, il faut pouvoir accéder
+ # Dans le cas de la console interactive, il faut pouvoir acceder
# aux commandes qui sont dans le buffer de la console
import linecache
import code
comme DETRUIRE ou les macros
Si etape == None, on retourne le contexte en fin de JDC
"""
- # L'étape courante pour laquelle le contexte a été calculé est
- # mémorisée dans self.index_etape_courante
+ # L'etape courante pour laquelle le contexte a ete calcule est
+ # memorisee dans self.index_etape_courante
# XXX on pourrait faire mieux dans le cas PAR_LOT="NON" : en
- # mémorisant l'étape
- # 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
- # message.debug(SUPERV, "g_context : %s", [k for k, v in self.g_context.items() if isinstance(v, ASSD)])
- # message.debug(SUPERV, "current_context : %s", [k for k, v in
+ # memorisant l'etape
+ # courante pendant le processus de construction des etapes.
+ # Si on insère des commandes (par ex, dans EFICAS), il faut prealablement
+ # remettre ce pointeur a 0
# self.current_context.items() if isinstance(v, ASSD)])
if self.par_lot_user == 'NON':
d = self.current_context = self.g_context.copy()
return d
# retirer les sd produites par 'etape'
sd_names = [sd.nom for sd in etape.get_created_sd()]
- # message.debug(SUPERV, "reuse : %s, sdprods : %s", etape.reuse,
- # sd_names)
for nom in sd_names:
try:
del d[nom]
if e.isactif():
e.update_context(d)
self.index_etape_courante = index_etape
- # message.debug(SUPERV, "returns : %s", [k for k, v in d.items() if
- # isinstance(v, ASSD)])
return d
def get_global_contexte(self):
"""Retourne "un" contexte global ;-)"""
- # N'est utilisé que par INCLUDE (sauf erreur).
- # g_context est remis à {} en PAR_LOT='OUI'. const_context permet
- # de retrouver ce qui y a été mis par exec_compile.
- # Les concepts n'y sont pas en PAR_LOT='OUI'. Ils sont ajoutés
+ # N'est utilise que par INCLUDE (sauf erreur).
+ # g_context est remis a {} en PAR_LOT='OUI'. const_context permet
+ # de retrouver ce qui y a ete mis par exec_compile.
+ # Les concepts n'y sont pas en PAR_LOT='OUI'. Ils sont ajoutes
# par get_global_contexte de la MACRO.
d = self.const_context.copy()
d.update(self.g_context)
def get_contexte_courant(self, etape_courante=None):
"""
Retourne le contexte tel qu'il est (ou 'sera' si on est en phase
- de construction) au moment de l'exécution de l'étape courante.
+ de construction) au moment de l'execution de l'etape courante.
"""
if etape_courante is None:
etape_courante = CONTEXT.get_current_step()
def get_concept(self, nomsd):
"""
- Méthode pour récuperer un concept à partir de son nom
+ Methode pour recuperer un concept a partir de son nom
"""
co = self.get_contexte_courant().get(nomsd.strip(), None)
if not isinstance(co, ASSD):
def get_concept_by_type(self, nomsd, typesd, etape):
"""
- Méthode pour récuperer un concept à partir de son nom et de son type.
+ Methode pour recuperer un concept a partir de son nom et de son type.
Il aura comme père 'etape'.
"""
assert issubclass(typesd, ASSD), typesd
def del_concept(self, nomsd):
"""
- Méthode pour supprimer la référence d'un concept dans le sds_dict.
- Ne détruire pas le concept (différent de supprime).
+ Methode pour supprimer la reference d'un concept dans le sds_dict.
+ Ne detruire pas le concept (different de supprime).
"""
try:
del self.sds_dict[nomsd.strip()]
def get_cmd(self, nomcmd):
"""
- Méthode pour recuperer la definition d'une commande
+ Methode pour recuperer la definition d'une commande
donnee par son nom dans les catalogues declares
au niveau du jdc
"""
def append_reset(self, etape):
"""
Ajoute une etape provenant d'un autre jdc a la liste des etapes
- et remet à jour la parenté de l'étape et des concepts
+ et remet a jour la parente de l'etape et des concepts
"""
self.etapes.append(etape)
self.index_etapes[etape] = len(self.etapes) - 1
"""On peut acceder aux "valeurs" (jeveux) des ASSD si le JDC est en PAR_LOT="NON".
"""
if CONTEXT.debug:
- print ' `- JDC sd_accessible : PAR_LOT =', self.par_lot
+ print((' `- JDC sd_accessible : PAR_LOT =', self.par_lot))
return self.par_lot == 'NON'
def _build_reserved_kw_list(self):
- """Construit la liste des mots-clés réservés (interdits pour le
+ """Construit la liste des mots-cles reserves (interdits pour le
nommage des concepts)."""
self._reserved_kw = set()
for cat in self.cata:
qui permet de spécifier les caractéristiques d'un JDC
"""
+from __future__ import absolute_import
import types
-import string
import traceback
-import N_ENTITE
-import N_JDC
-from strfunc import ufmt
+from . import N_ENTITE
+from . import N_JDC
class JDC_CATA(N_ENTITE.ENTITE):
"""
self.code = code
self.execmodul = execmodul
- if type(regles) == types.TupleType:
+ if type(regles) == tuple:
self.regles = regles
else:
self.regles = (regles,)
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-from N_ASSD import ASSD
+from __future__ import absolute_import
+from .N_ASSD import ASSD
class LASSD(ASSD,list):pass
qui permet de spécifier les caractéristiques d'une macro-commande
"""
+from __future__ import absolute_import
import types
-import string
import traceback
-import N_ENTITE
-import N_MACRO_ETAPE
-import nommage
-from strfunc import ufmt
+from . import N_ENTITE
+from . import N_MACRO_ETAPE
+from . import nommage
class MACRO(N_ENTITE.ENTITE):
# xxx est donné par la valeur absolue de op. L'execution est egalement effectuée via cette subroutine.
# - Si op est une fonction Python, la construction de la macro est effectuée par l'appel à cette fonction
# Suivant le cas on garde l info dans self.op ou dans self.proc
- if type(op) == types.IntType:
+ if type(op) == int:
self.proc = None
self.op = op
else:
self.ang=ang
self.repetable = repetable
self.docu = docu
- if type(regles) == types.TupleType:
+ if type(regles) == tuple:
self.regles = regles
else:
self.regles = (regles,)
"""
- Ce module contient la classe MACRO_ETAPE qui sert à vérifier et à exécuter
+ Ce module contient la classe MACRO_ETAPE qui sert a verifier et a executer
une commande
"""
# Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+except : pass
import types
import sys
-import string
import traceback
from warnings import warn
# Modules EFICAS
-import N_MCCOMPO
-import N_ETAPE
-from N_Exception import AsException
-import N_utils
-from N_utils import AsType
-from N_CO import CO
-from N_ASSD import ASSD
-from N_info import message, SUPERV
+from . import N_MCCOMPO
+from . import N_ETAPE
+from .N_Exception import AsException
+from . import N_utils
+from .N_utils import AsType
+from .N_CO import CO
+from .N_ASSD import ASSD
+from six.moves import range
class MACRO_ETAPE(N_ETAPE.ETAPE):
def __init__(self, oper=None, reuse=None, args={}):
"""
Attributs :
- - definition : objet portant les attributs de définition d'une étape
- de type macro-commande. Il est initialisé par
+ - definition : objet portant les attributs de definition d'une etape
+ de type macro-commande. Il est initialise par
l'argument oper.
- - reuse : indique le concept d'entrée réutilisé. Il se trouvera donc
- en sortie si les conditions d'exécution de l'opérateur
+ - reuse : indique le concept d'entree reutilise. Il se trouvera donc
+ en sortie si les conditions d'execution de l'operateur
l'autorise
- - valeur : arguments d'entrée de type mot-clé=valeur. Initialisé
+ - valeur : arguments d'entree de type mot-cle=valeur. Initialise
avec l'argument args.
"""
N_ETAPE.ETAPE.__init__(self, oper, reuse, args, niveau=5)
self.index_etape_courante = 0
self.etapes = []
self.index_etapes = {}
- # Dans le cas d'une macro écrite en Python, l'attribut Outputs est un
+ # Dans le cas d'une macro ecrite en Python, l'attribut Outputs est un
# dictionnaire qui contient les concepts produits de sortie
- # (nom : ASSD) déclarés dans la fonction sd_prod
+ # (nom : ASSD) declares dans la fonction sd_prod
self.Outputs = {}
self.sdprods = []
self.UserError = "UserError"
- # permet de stocker le nom du dernier concept nommé dans la macro
+ # permet de stocker le nom du dernier concept nomme dans la macro
self.last = None
def make_register(self):
"""
- Initialise les attributs jdc, id, niveau et réalise les enregistrements
- nécessaires
+ Initialise les attributs jdc, id, niveau et realise les enregistrements
+ necessaires
"""
N_ETAPE.ETAPE.make_register(self)
if self.parent:
def Build_sd(self, nom):
"""
- Construit le concept produit de l'opérateur. Deux cas
- peuvent se présenter :
+ Construit le concept produit de l'operateur. Deux cas
+ peuvent se presenter :
- - le parent n'est pas défini. Dans ce cas, l'étape prend en charge
- la création et le nommage du concept.
+ - le parent n'est pas defini. Dans ce cas, l'etape prend en charge
+ la creation et le nommage du concept.
- - le parent est défini. Dans ce cas, l'étape demande au parent la
- création et le nommage du concept.
+ - le parent est defini. Dans ce cas, l'etape demande au parent la
+ creation et le nommage du concept.
"""
- # message.debug(SUPERV, "%s", self.nom)
self.sdnom = nom
try:
# On positionne la macro self en tant que current_step pour que les
- # étapes créées lors de l'appel à sd_prod et à op_init aient la macro
+ # etapes creees lors de l'appel a sd_prod et a op_init aient la macro
# comme parent
self.set_current_step()
if self.parent:
sd = self.parent.create_sdprod(self, nom)
if type(self.definition.op_init) == types.FunctionType:
- apply(self.definition.op_init, (
+ self.definition.op_init(*(
self, self.parent.g_context))
else:
sd = self.get_sd_prod()
# d un concept
sd.set_name(nom)
self.reset_current_step()
- except AsException, e:
+ except AsException as e:
self.reset_current_step()
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1], e)
- except (EOFError, self.UserError):
+ #except (EOFError, self.UserError):
+ except (EOFError):
# Le retablissement du step courant n'est pas strictement
# necessaire. On le fait pour des raisons de coherence
self.reset_current_step()
sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1] + '\n',
- string.join(l))
+ ''.join(l))
self.Execute()
return sd
def get_sd_prod(self):
"""
- Retourne le concept résultat d'une macro étape
+ Retourne le concept resultat d'une macro etape
La difference avec une etape ou une proc-etape tient a ce que
le concept produit peut exister ou pas
Deux cas :
- cas 1 : sd_prod n'est pas une fonction
il s'agit d'une sous classe de ASSD
- on construit le sd à partir de cette classe
+ on construit le sd a partir de cette classe
et on le retourne
- cas 2 : sd_prod est une fonction
- on l'évalue avec les mots-clés de l'étape (mc_liste)
- on construit le sd à partir de la classe obtenue
+ on l'evalue avec les mots-cles de l'etape (mc_liste)
+ on construit le sd a partir de la classe obtenue
et on le retourne
"""
sd_prod = self.definition.sd_prod
d = self.cree_dict_valeurs(self.mc_liste)
try:
# la sd_prod d'une macro a l'objet macro_etape lui meme en premier argument
- # Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
- # les concepts produits dans self.sdprods, il faut le mettre à
- # zéro avant de l'appeler
+ # Comme sd_prod peut invoquer la methode type_sdprod qui ajoute
+ # les concepts produits dans self.sdprods, il faut le mettre a
+ # zero avant de l'appeler
self.sdprods = []
- sd_prod = apply(sd_prod, (self,), d)
- except (EOFError, self.UserError):
+ sd_prod = sd_prod(*(self,), **d)
+ #except (EOFError, self.UserError):
+ except (EOFError):
raise
- except Exception, exc:
+ except Exception as exc:
if CONTEXT.debug:
traceback.print_exc()
raise AsException("impossible d affecter un type au resultat:",
str(exc))
- # on teste maintenant si la SD est réutilisée ou s'il faut la créer
+ # on teste maintenant si la SD est reutilisee ou s'il faut la creer
if self.definition.reentrant != 'n' and self.reuse:
# Le concept produit est specifie reutilise (reuse=xxx). C'est une erreur mais non fatale.
# Elle sera traitee ulterieurement.
self.typret = sd_prod
# Si la commande est obligatoirement reentrante et reuse n'a pas ete specifie, c'est une erreur.
# On ne fait rien ici. L'erreur sera traitee par la suite.
- # précaution
+ # precaution
if self.sd is not None and not isinstance(self.sd, ASSD):
raise AsException("""
-Impossible de typer le résultat !
+Impossible de typer le resultat !
Causes possibles :
Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte,
- soit il y a une "," à la fin d'une commande précédente.
- Développeur : La fonction "sd_prod" retourne un type invalide.""")
+ soit il y a une "," a la fin d'une commande precedente.
+ Developpeur : La fonction "sd_prod" retourne un type invalide.""")
return self.sd
def get_type_produit(self, force=0):
def get_type_produit_brut(self, force=0):
"""
- Retourne le type du concept résultat de l'étape et eventuellement type
- les concepts produits "à droite" du signe égal (en entrée)
+ Retourne le type du concept resultat de l'etape et eventuellement type
+ les concepts produits "a droite" du signe egal (en entree)
Deux cas :
- cas 1 : sd_prod de oper n'est pas une fonction
il s'agit d'une sous classe de ASSD
on retourne le nom de la classe
- cas 2 : il s'agit d'une fonction
- on l'évalue avec les mots-clés de l'étape (mc_liste)
- et on retourne son résultat
+ on l'evalue avec les mots-cles de l'etape (mc_liste)
+ et on retourne son resultat
"""
if not force and hasattr(self, 'typret'):
return self.typret
if type(self.definition.sd_prod) == types.FunctionType:
d = self.cree_dict_valeurs(self.mc_liste)
- # Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
- # les concepts produits dans self.sdprods, il faut le mettre à zéro
+ # Comme sd_prod peut invoquer la methode type_sdprod qui ajoute
+ # les concepts produits dans self.sdprods, il faut le mettre a zero
self.sdprods = []
- sd_prod = apply(self.definition.sd_prod, (self,), d)
+ sd_prod = self.definition.sd_prod(*(self,), **d)
else:
sd_prod = self.definition.sd_prod
return sd_prod
On tient compte des commandes qui modifient le contexte
comme DETRUIRE ou les macros
"""
- # L'étape courante pour laquelle le contexte a été calculé est
- # mémorisée dans self.index_etape_courante
- # message.debug(SUPERV, "g_context : %s", [k for k, v in self.g_context.items() if isinstance(v, ASSD)])
- # message.debug(SUPERV, "current_context : %s", [k for k, v in
+ # L'etape courante pour laquelle le contexte a ete calcule est
+ # memorisee dans self.index_etape_courante
# self.current_context.items() if isinstance(v, ASSD)])
d = self.current_context = self.g_context.copy()
if etape is None:
return d
# retirer les sd produites par 'etape'
sd_names = [sd.nom for sd in etape.get_created_sd()]
- # message.debug(SUPERV, "etape: %s, reuse : %s, sdprods de %s : %s",
- # self.nom, etape.reuse, etape.nom, sd_names)
for nom in sd_names:
try:
del d[nom]
except KeyError:
pass
- # Exemple avec INCLUDE_MATERIAU appelé dans une macro.
+ # Exemple avec INCLUDE_MATERIAU appele dans une macro.
# Les fonctions restent uniquement dans le contexte de INCLUDE_MATERIAU,
# elles ne sont donc pas dans le contexte de la macro appelante.
# from warnings import warn
def supprime(self):
"""
- Méthode qui supprime toutes les références arrières afin que
- l'objet puisse etre correctement détruit par le garbage collector
+ Methode qui supprime toutes les references arrières afin que
+ l'objet puisse etre correctement detruit par le garbage collector
"""
N_MCCOMPO.MCCOMPO.supprime(self)
self.jdc = None
etape.supprime()
def clean(self, netapes):
- """Nettoie les `netapes` dernières étapes de la liste des étapes."""
+ """Nettoie les `netapes` dernières etapes de la liste des etapes."""
if self.jdc.hist_etape:
return
- for i in xrange(netapes):
+ for i in range(netapes):
e = self.etapes.pop()
jdc = e.jdc
parent = e.parent
e.supprime()
e.parent = parent
e.jdc = jdc
- # message.debug(SUPERV, "MACRO.clean - etape = %s - refcount(e) = %d",
- # e.nom, sys.getrefcount(e))
del self.index_etapes[e]
def type_sdprod(self, co, t):
Cette methode a pour fonction de typer le concept co avec le type t
dans les conditions suivantes :
1. co est un concept produit de self
- 2. co est un concept libre : on le type et on l attribue à self
+ 2. co est un concept libre : on le type et on l attribue a self
Elle enregistre egalement les concepts produits (on fait l hypothese
- que la liste sdprods a été correctement initialisee, vide probablement)
+ que la liste sdprods a ete correctement initialisee, vide probablement)
"""
if not hasattr(co, 'etape'):
# Le concept vaut None probablement. On ignore l'appel
Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" % (co, mcs.definition.type))
co.etape = self
# affectation du bon type du concept
- # message.debug(SUPERV, "MACRO.type_sdprod : changement de type de
- # %s --> %s", co, t)
co.change_type(t)
self.sdprods.append(co)
elif co.etape == self:
# Cas 2 : le concept est produit par la macro (self)
# On est deja passe par type_sdprod (Cas 1 ou 3).
- # XXX Peut-il être créer par une autre macro ?
- # On vérifie juste que c'est un vrai CO non déjà typé
+ # XXX Peut-il etre creer par une autre macro ?
+ # On verifie juste que c'est un vrai CO non deja type
# if co.etape == co._etape:
if co.is_typco() == 1:
- # Le concept a été créé par la macro (self)
+ # Le concept a ete cree par la macro (self)
# On peut changer son type
co.change_type(t)
else:
- # Le concept a été créé par une macro parente
+ # Le concept a ete cree par une macro parente
# Le type du concept doit etre coherent avec le type demande
# (seulement derive)
if not isinstance(co, t):
# et on change le type du concept comme demande
# Au prealable, on verifie que le concept existant (co) est une instance
# possible du type demande (t)
- # Cette règle est normalement cohérente avec les règles de
- # vérification des mots-clés
+ # Cette règle est normalement coherente avec les règles de
+ # verification des mots-cles
if not isinstance(co, t):
raise AsException("""
Impossible de changer le type du concept produit (%s) en (%s).
self.sdprods.append(co)
elif self.issubstep(co.etape):
- # Cas 4 : Le concept est propriété d'une sous etape de la macro (self).
+ # Cas 4 : Le concept est propriete d'une sous etape de la macro (self).
# On est deja passe par type_sdprod (Cas 3 ou 1).
# Il suffit de le mettre dans la liste des concepts produits (self.sdprods)
# Le type du concept et t doivent etre derives.
self.sdprods.append(co)
else:
- # Cas 5 : le concept est produit par une autre étape
+ # Cas 5 : le concept est produit par une autre etape
# On ne fait rien
return
def reg_sd(self, sd):
"""
Methode appelee dans l __init__ d un ASSD a sa creation pour
- s enregistrer (reserve aux ASSD créés au sein d'une MACRO)
+ s enregistrer (reserve aux ASSD crees au sein d'une MACRO)
"""
return self.jdc.o_register(sd)
Cette methode doit fabriquer le concept produit retourne
par l'etape etape et le nommer.
- Elle est appelée à l'initiative de l'etape
+ Elle est appelee a l'initiative de l'etape
pendant le processus de construction de cette etape : methode __call__
de la classe CMD (OPER ou MACRO)
- Ce travail est réalisé par le contexte supérieur (etape.parent)
- car dans certains cas, le concept ne doit pas etre fabriqué mais
- l'etape doit simplement utiliser un concept préexistant.
- - Cas 1 : etape.reuse != None : le concept est réutilisé
- - Cas 2 : l'étape appartient à une macro qui a déclaré un concept
+ Ce travail est realise par le contexte superieur (etape.parent)
+ car dans certains cas, le concept ne doit pas etre fabrique mais
+ l'etape doit simplement utiliser un concept preexistant.
+ - Cas 1 : etape.reuse != None : le concept est reutilise
+ - Cas 2 : l'etape appartient a une macro qui a declare un concept
de sortie qui doit etre produit par cette etape.
"""
- if self.Outputs.has_key(nomsd):
- # Il s'agit d'un concept de sortie de la macro. Il ne faut pas le créer
+ if nomsd in self.Outputs:
+ # Il s'agit d'un concept de sortie de la macro. Il ne faut pas le creer
# Il faut quand meme appeler la fonction sd_prod si elle existe.
# get_type_produit le fait et donne le type attendu par la commande
- # pour verification ultérieure.
+ # pour verification ulterieure.
sdprod = etape.get_type_produit_brut()
sd = self.Outputs[nomsd]
# On verifie que le type du concept existant sd.__class__ est un sur type de celui attendu
- # Cette règle est normalement cohérente avec les règles de
- # vérification des mots-clés
+ # Cette règle est normalement coherente avec les règles de
+ # verification des mots-cles
if not issubclass(sdprod, sd.__class__):
raise AsException(
"Le type du concept produit %s devrait etre une sur classe de %s" % (sd.__class__, sdprod))
# La propriete du concept est transferee a l'etape avec le type
- # attendu par l'étape
+ # attendu par l'etape
etape.sd = sd
sd.etape = etape
if self.reuse == sd and etape.reuse != sd \
- and getattr(sd, "executed", 0) == 1: # n'a pas été pas détruit
- raise AsException("Le concept '%s' est réentrant dans la macro-commande %s. "
- "Il devrait donc l'être dans %s (produit sous le nom '%s')."
+ and getattr(sd, "executed", 0) == 1: # n'a pas ete pas detruit
+ raise AsException("Le concept '%s' est reentrant dans la macro-commande %s. "
+ "Il devrait donc l'etre dans %s (produit sous le nom '%s')."
% (sd.nom, self.nom, etape.nom, nomsd))
# On donne au concept le type produit par la sous commande.
# Le principe est le suivant : apres avoir verifie que le type deduit par la sous commande
# on affecte au concept ce type car il peut etre plus precis
# (derive, en general)
sd.__class__ = sdprod
- # On force également le nom stocké dans l'attribut sdnom : on lui donne le nom
- # du concept associé à nomsd
+ # On force egalement le nom stocke dans l'attribut sdnom : on lui donne le nom
+ # du concept associe a nomsd
etape.sdnom = sd.nom
# pour l'ajouter au contexte de la macro
self.g_context[sd.nom] = sd
def NommerSdprod(self, sd, sdnom, restrict='non'):
"""
- Cette méthode est appelée par les etapes internes de la macro.
+ Cette methode est appelee par les etapes internes de la macro.
La macro appelle le JDC pour valider le nommage.
- On considère que l'espace de nom est unique et géré par le JDC.
- Si le nom est déjà utilisé, l'appel lève une exception.
+ On considère que l'espace de nom est unique et gere par le JDC.
+ Si le nom est deja utilise, l'appel lève une exception.
Si restrict=='non', on insère le concept dans le contexte du parent de la macro.
Si restrict=='oui', on insère le concept uniquement dans le contexte de la macro.
"""
# create_sdprod. La seule chose a verifier apres conversion eventuelle du nom
# est de verifier que le nom n'est pas deja attribue. Ceci est fait en delegant
# au JDC par l'intermediaire du parent.
- # message.debug(SUPERV, "macro results = %s, (sdnom: %r, restrict: %r)",
- # self.Outputs.keys(), sdnom, restrict)
- if self.Outputs.has_key(sdnom):
+ if sdnom in self.Outputs :
# Il s'agit d'un concept de sortie de la macro produit par une
# sous commande
sdnom = self.Outputs[sdnom].nom
elif len(sdnom) > 0:
if sdnom[0] in ('_', '.') and sdnom[1:].isdigit():
- # il est déjà de la forme _9000012 ou .9000017
+ # il est deja de la forme _9000012 ou .9000017
pass
elif sdnom[0] == '_':
# Si le nom du concept commence par le caractère '_', on lui attribue
# un identificateur JEVEUX construit par gcncon.
- # nom commençant par __ : il s'agit de concepts qui seront détruits
+ # nom commençant par __ : il s'agit de concepts qui seront detruits
# nom commençant par _ : il s'agit de concepts intermediaires
- # qui seront gardés
+ # qui seront gardes
if len(sdnom) > 1 and sdnom[1] == '_':
sdnom = self.gcncon('.')
else:
pass
else:
# On est dans le cas d'un nom de concept global
- # XXX à voir, création de CO() dans CALC_ESSAI (sdls139a)
+ # XXX a voir, creation de CO() dans CALC_ESSAI (sdls139a)
if not sd.is_typco():
raise AsException(
- "Résultat non déclaré par la macro %s : %s" % (self.nom, sdnom))
+ "Resultat non declare par la macro %s : %s" % (self.nom, sdnom))
self.last = sdnom
if restrict == 'non':
# On demande le nommage au parent mais sans ajout du concept dans le contexte du parent
# On ajoute dans le contexte de la macro les concepts nommes
# Ceci est indispensable pour les CO (macro) dans un INCLUDE
self.g_context[sdnom] = sd
- # message.debug(SUPERV, "g_context[%s] = %s", sdnom, sd)
else:
# La demande de nommage vient probablement d'une macro qui a mis
# le concept dans son contexte. On ne traite plus que le nommage (restrict="oui")
- # message.debug(SUPERV, "restrict=oui co[%s] = %s", sdnom, sd)
self.parent.NommerSdprod(sd, sdnom, restrict='oui')
def delete_concept_after_etape(self, etape, sd):
"""
- Met à jour les étapes de la MACRO qui sont après etape suite à
+ Met a jour les etapes de la MACRO qui sont après etape suite a
la disparition du concept sd
"""
- # Cette methode est définie dans le noyau mais ne sert que pendant la phase de creation
- # des etapes et des concepts. Il n'y a aucun traitement particulier à réaliser
- # Dans d'autres conditions, il faudrait surcharger cette méthode.
+ # Cette methode est definie dans le noyau mais ne sert que pendant la phase de creation
+ # des etapes et des concepts. Il n'y a aucun traitement particulier a realiser
+ # Dans d'autres conditions, il faudrait surcharger cette methode.
return
def get_created_sd(self):
- """Retourne la liste des sd réellement produites par l'étape.
- Si reuse est présent, `self.sd` a été créée avant, donc n'est pas dans
+ """Retourne la liste des sd reellement produites par l'etape.
+ Si reuse est present, `self.sd` a ete creee avant, donc n'est pas dans
cette liste."""
sdprods = self.sdprods[:]
if not self.reuse and self.sd:
def get_last_concept(self):
"""Retourne le dernier concept produit dans la macro.
- Peut-être utile pour accéder au contenu 'fortran' dans une
+ Peut-etre utile pour acceder au contenu 'fortran' dans une
clause 'except'."""
return self.g_context.get(self.last, None)
def update_context(self, d):
"""
- Met à jour le contexte contenu dans le dictionnaire d
+ Met a jour le contexte contenu dans le dictionnaire d
Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
Une fonction enregistree dans op_init peut egalement modifier le contexte
"""
if type(self.definition.op_init) == types.FunctionType:
- apply(self.definition.op_init, (self, d))
+ self.definition.op_init(*(self, d))
if self.sd != None:
d[self.sd.nom] = self.sd
for co in self.sdprods:
d = self.g_context = self.macro_const_context
globs = self.get_global_contexte()
d.update(globs)
- exec code in globs, d
- # pour ne pas conserver des références sur tout
+ exec(code, globs, d)
+ # pour ne pas conserver des references sur tout
self.macro_const_context = {}
def get_global_contexte(self):
# Le contexte global est forme par concatenation du contexte
# du parent de self et de celui de l'etape elle meme (self)
# Pour les concepts, cela ne doit rien changer. Mais pour les constantes,
- # les valeurs de get_contexte_avant sont moins récentes que dans
- # get_global_contexte. On prend donc la précaution de ne pas écraser
- # ce qui y est déjà.
+ # les valeurs de get_contexte_avant sont moins recentes que dans
+ # get_global_contexte. On prend donc la precaution de ne pas ecraser
+ # ce qui y est deja.
d = self.parent.get_global_contexte()
d.update(self.g_context)
- d.update([(k, v) for k, v in self.parent.get_contexte_avant(self).items()
+ d.update([(k, v) for k, v in list(self.parent.get_contexte_avant(self).items())
if d.get(k) is None])
return d
def get_contexte_courant(self, etape_fille_du_jdc=None):
"""
- Retourne le contexte tel qu'il est au moment de l'exécution de
- l'étape courante.
+ Retourne le contexte tel qu'il est au moment de l'execution de
+ l'etape courante.
"""
ctx = {}
# update car par ricochet on modifierait jdc.current_context
def get_concept(self, nomsd):
"""
- Méthode pour recuperer un concept à partir de son nom
- dans le contexte du jdc connu avant l'exécution de la macro courante.
+ Methode pour recuperer un concept a partir de son nom
+ dans le contexte du jdc connu avant l'execution de la macro courante.
"""
# chercher dans self.get_contexte_avant, puis si non trouve
# self.parent.get_concept est peut-etre plus performant
def get_concept_by_type(self, nomsd, typesd, etape=None):
"""
- Méthode pour récuperer un concept à partir de son nom et de son type.
+ Methode pour recuperer un concept a partir de son nom et de son type.
Il aura comme père 'etape' (ou la macro courante si etape est absente).
"""
return self.parent.get_concept_by_type(nomsd, typesd, etape=etape or self)
def copy(self):
- """ Méthode qui retourne une copie de self non enregistrée auprès du JDC
+ """ Methode qui retourne une copie de self non enregistree auprès du JDC
et sans sd
On surcharge la methode de ETAPE pour exprimer que les concepts crees
par la MACRO d'origine ne sont pas crees par la copie mais eventuellement
return etape
def copy_intern(self, etape):
- """ Cette méthode effectue la recopie des etapes internes d'une macro
- passée en argument (etape)
+ """ Cette methode effectue la recopie des etapes internes d'une macro
+ passee en argument (etape)
"""
self.etapes = []
self.index_etapes = {}
Cette methode sert a reinitialiser la parente de l'objet
"""
N_ETAPE.ETAPE.reparent(self, parent)
- # on ne change pas la parenté des concepts. On s'assure uniquement que
- # le jdc en référence est le bon
+ # on ne change pas la parente des concepts. On s'assure uniquement que
+ # le jdc en reference est le bon
for concept in self.sdprods:
concept.jdc = self.jdc
for e in self.etapes:
def update_const_context(self, d):
"""
- Met à jour le contexte des constantes pour l'évaluation de
+ Met a jour le contexte des constantes pour l'evaluation de
formules dans la macro.
"""
- # Dans le jdc, const_context est mis à jour par exec_compile
- # Dans la macro, on n'a pas le code à compiler pour récupèrer les
- # constantes locales à la macro. On demande donc explicitement de
- # définir les constantes "locales".
+ # Dans le jdc, const_context est mis a jour par exec_compile
+ # Dans la macro, on n'a pas le code a compiler pour recupèrer les
+ # constantes locales a la macro. On demande donc explicitement de
+ # definir les constantes "locales".
self.macro_const_context.update(d)
def sd_accessible(self):
sauf pour INCLUDE.
"""
if CONTEXT.debug:
- print ' `- MACRO sd_accessible :', self.nom
+ print((' `- MACRO sd_accessible :', self.nom))
return self.parent.sd_accessible() or not self.is_include()
de type ENTITE
"""
+from __future__ import absolute_import
import types
-import N_MCCOMPO
+from . import N_MCCOMPO
class MCBLOC(N_MCCOMPO.MCCOMPO):
# et caché ('c')
# On n'ajoute aucune information sur les blocs. Ils n'ont pas de défaut seulement
# une condition.
- for k, v in self.definition.entites.items():
- if not dico.has_key(k):
+ for k, v in list(self.definition.entites.items()):
+ if not k in dico:
if v.label == 'SIMP':
# Mot clé simple
dico[k] = v.defaut
des OBJECT composites
"""
+from __future__ import absolute_import
+from __future__ import print_function
from copy import copy
-import N_OBJECT
+from . import N_OBJECT
class MCCOMPO(N_OBJECT.OBJECT):
à partir du dictionnaire des arguments (valeur)
"""
if CONTEXT.debug:
- print "MCCOMPO.build_mc ", self.nom
+ print(("MCCOMPO.build_mc ", self.nom))
# Dans la phase de reconstruction args peut contenir des mots-clés
# qui ne sont pas dans le dictionnaire des entites de definition (self.definition.entites)
# de l'objet courant (self)
# 2- les entités non présentes dans les arguments, présentes dans la définition avec un défaut
# Phase 1.1 : on traite d'abord les SIMP pour enregistrer les mots cles
# globaux
- for k, v in self.definition.entites.items():
+ for k, v in list(self.definition.entites.items()):
if v.label != 'SIMP':
continue
- if args.has_key(k) or v.statut == 'o':
+ if k in args or v.statut == 'o':
#
# Creation par appel de la methode __call__ de la definition de la sous entite k de self
# si une valeur existe dans args ou est obligatoire (generique si toutes les
self.append_mc_global(objet)
elif objet.definition.position == 'global_jdc':
self.append_mc_global_jdc(objet)
- if args.has_key(k):
+ if k in args:
del args[k]
# Phase 1.2 : on traite les autres entites que SIMP
# (FACT en fait car un BLOC ne peut avoir le meme nom qu'un mot-clef)
- for k, v in self.definition.entites.items():
+ for k, v in list(self.definition.entites.items()):
if v.label == 'SIMP':
continue
- if args.has_key(k) or v.statut == 'o':
+ if k in args or v.statut == 'o':
#
# Creation par appel de la methode __call__ de la definition de la sous entite k de self
# si une valeur existe dans args ou est obligatoire (generique si toutes les
#
objet = v(val=args.get(k, None), nom=k, parent=self)
mc_liste.append(objet)
- if args.has_key(k):
+ if k in args:
del args[k]
# Phase 2:
# A ce stade, mc_liste ne contient que les fils de l'objet courant
# args ne contient plus que des mots-clés qui n'ont pas été attribués car ils sont
# à attribuer à des blocs du niveau inférieur ou bien sont des mots-clés erronés
- for k, v in self.definition.entites.items():
+ for k, v in list(self.definition.entites.items()):
if v.label != 'BLOC':
continue
# condition and a or b : Equivalent de l'expression : condition ?
assert intersection_vide(dico, dadd)
dico.update(dadd)
else:
- assert not dico.has_key(v.nom), "deja vu : %s" % v.nom
+ assert not v.nom in dico, "deja vu : %s" % v.nom
dico[v.nom] = v.get_valeur()
# On rajoute tous les autres mots-clés locaux possibles avec la valeur
# une condition.
# XXX remplacer le not has_key par un dico différent et faire dico2.update(dico)
# ce n'est qu'un pb de perf
- for k, v in self.definition.entites.items():
- if not dico.has_key(k):
+ for k, v in list(self.definition.entites.items()):
+ if not k in dico :
if v.label == 'SIMP':
# Mot clé simple
dico[k] = v.defaut
"""Semblable à `cree_dict_valeurs(liste=self.mc_liste)` en supprimant les
valeurs None."""
dico = self.cree_dict_valeurs(self.mc_liste, condition=0)
- dico = dict([(k, v) for k, v in dico.items() if v is not None])
+ dico = dict([(k, v) for k, v in list(dico.items()) if v is not None])
return dico
def cree_dict_condition(self, liste=[], condition=0):
# On ajoute la cle "reuse" pour les MCCOMPO qui ont un attribut reuse. A destination
# uniquement des commandes. Ne devrait pas etre dans cette classe mais
# dans une classe dérivée
- if not dico.has_key('reuse') and hasattr(self, 'reuse'):
+ if not 'reuse' in dico and hasattr(self, 'reuse'):
dico['reuse'] = self.reuse
return dico
etape = self.get_etape()
if etape:
dict_mc_globaux_fac = self.recherche_mc_globaux_facultatifs()
- for k, v in etape.mc_globaux.items():
+ for k, v in list(etape.mc_globaux.items()):
dict_mc_globaux_fac[k] = v.get_valeur()
if self.jdc:
- for k, v in self.jdc.mc_globaux.items():
+ for k, v in list(self.jdc.mc_globaux.items()):
dict_mc_globaux_fac[k] = v.get_valeur()
return dict_mc_globaux_fac
else:
etape = self.get_etape()
if not etape:
return {}
- for k, v in etape.definition.entites.items():
+ for k, v in list(etape.definition.entites.items()):
if v.label != 'SIMP':
continue
if v.position != 'global':
pass
# On a rien trouve, le mot cle est absent.
# On leve une exception
- raise IndexError, "Le mot cle %s n existe pas dans %s" % (key, self)
+ raise IndexError("Le mot cle %s n existe pas dans %s" % (key, self))
def get_child(self, name, restreint='non'):
"""
dico = {}
for child in self.mc_liste:
daux = child.get_sd_mcs_utilisees()
- for cle in daux.keys():
+ for cle in daux:
dico[cle] = dico.get(cle, [])
dico[cle].extend(daux[cle])
return dico
def intersection_vide(dict1, dict2):
"""Verification qu'il n'y a pas de clé commune entre 'dict1' et 'dict2'."""
- sk1 = set(dict1.keys())
- sk2 = set(dict2.keys())
+ sk1 = set(dict1)
+ sk2 = set(dict2)
inter = sk1.intersection(sk2)
ok = len(inter) == 0
if not ok:
- print 'ERREUR: Mot(s)-clef(s) vu(s) plusieurs fois :', tuple(inter)
+ print(('ERREUR: Mot(s)-clef(s) vu(s) plusieurs fois :', tuple(inter)))
return ok
de type ENTITE
"""
-import N_MCCOMPO
+from __future__ import absolute_import
+from . import N_MCCOMPO
class MCFACT(N_MCCOMPO.MCCOMPO):
de type ENTITE
"""
+from __future__ import absolute_import
+try :
+ from future import standard_library
+ standard_library.install_aliases()
+except :
+ pass
from copy import copy
-import UserList
import types
+try:
+ from UserList import UserList
+except ImportError:
+ from collections import UserList
-class MCList(UserList.UserList):
+
+
+
+class MCList(UserList):
""" Liste semblable a la liste Python
mais avec quelques methodes en plus
if resu != None:
return resu
# Phase 3 : on cherche dans les entites possibles pour les défauts
- for k, v in obj.definition.entites.items():
+ for k, v in list(obj.definition.entites.items()):
# if k == name: return v.defaut
if k == name:
if v.defaut != None:
dico = {}
for child in self.data:
daux = child.get_sd_mcs_utilisees()
- for cle in daux.keys():
+ for cle in daux:
dico[cle] = dico.get(cle, [])
dico[cle].extend(daux[cle])
return dico
"""
Dans le cas d un mot cle facteur de longueur 1 on simule un scalaire
"""
- if type(key) != types.IntType and len(self) == 1:
+ if type(key) != int and len(self) == 1:
return self.data[0].get_mocle(key)
else:
return self.data[key]
dresu = []
for mcf in self:
dico = mcf.cree_dict_valeurs(mcf.mc_liste)
- for i in dico.keys():
+ for i in list(dico.keys()):
if dico[i] == None:
del dico[i]
dresu.append(dico)
de type ENTITE
"""
+from __future__ import absolute_import
from copy import copy
from Noyau.N_ASSD import ASSD
from Noyau.N_CO import CO
-import N_OBJECT
-from N_CONVERT import ConversionFactory
-from N_types import force_list, is_sequence
+from . import N_OBJECT
+from .N_CONVERT import ConversionFactory
+from .N_types import force_list, is_sequence
class MCSIMP(N_OBJECT.OBJECT):
elif not is_sequence(v) and self.definition.max != 1:
v = (v, )
# traitement particulier pour les complexes ('RI', r, i)
- if 'C' in self.definition.type and self.definition.max != 1 \
- and v[0] in ('RI', 'MP'):
+ if 'C' in self.definition.type and self.definition.max != 1 and v != None and v[0] in ('RI', 'MP'):
v = (v, )
return v
Ce module contient la classe OBJECT classe mère de tous les objets
servant à controler les valeurs par rapport aux définitions
"""
-from N_CR import CR
-from strfunc import ufmt
+from __future__ import absolute_import
+try :
+ from builtins import object
+except :
+ pass
+from .N_CR import CR
-class OBJECT:
+class OBJECT(object):
"""
Classe OBJECT : cette classe est virtuelle et sert de classe mère
qui permet de spécifier les caractéristiques d'un opérateur
"""
+from __future__ import absolute_import
import types
-import string
import traceback
-import N_ENTITE
-import N_ETAPE
-import nommage
-from strfunc import ufmt
+from . import N_ENTITE
+from . import N_ETAPE
+from . import nommage
class OPER(N_ENTITE.ENTITE):
self.ang = ang
self.repetable = repetable
self.docu = docu
- if type(regles) == types.TupleType:
+ if type(regles) == tuple:
self.regles = regles
else:
self.regles = (regles,)
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-from N_utils import import_object
+from __future__ import absolute_import
+try :
+ from builtins import object
+except :
+ pass
+from .N_utils import import_object
-class OPS:
+class OPS(object):
"""Wrapper to ops functions.
This allows to import them only when they are needed."""
qui permet de spécifier les caractéristiques d'une procédure
"""
+from __future__ import absolute_import
import types
-import string
import traceback
-import N_ENTITE
-import N_PROC_ETAPE
-from strfunc import ufmt
+from . import N_ENTITE
+from . import N_PROC_ETAPE
class PROC(N_ENTITE.ENTITE):
#self.ang=""
self.ang=ang
self.docu = docu
- if type(regles) == types.TupleType:
+ if type(regles) == tuple:
self.regles = regles
else:
self.regles = (regles,)
"""
# Modules Python
+from __future__ import absolute_import
import types
import sys
-import string
import traceback
# Modules EFICAS
-import N_MCCOMPO
-import N_ETAPE
-from N_Exception import AsException
-import N_utils
+from . import N_MCCOMPO
+from . import N_ETAPE
+from .N_Exception import AsException
+from . import N_utils
class PROC_ETAPE(N_ETAPE.ETAPE):
try:
if self.parent:
if type(self.definition.op_init) == types.FunctionType:
- apply(self.definition.op_init, (
+ self.definition.op_init(*(
self, self.parent.g_context))
else:
pass
- except AsException, e:
+ except AsException as e:
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1], e)
except EOFError:
sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1] + '\n',
- string.join(l))
+ ''.join(l))
self.Execute()
return None
Seule une fonction enregistree dans op_init pourrait le faire
"""
if type(self.definition.op_init) == types.FunctionType:
- apply(self.definition.op_init, (self, d))
+ self.definition.op_init(*(self, d))
r.verif({"INFO":v1,"AFFE":v2)
"""
+from __future__ import absolute_import
+try :
+ from builtins import object
+except :
+ pass
import types
-class REGLE:
+class REGLE(object):
def __init__(self, *args):
"""
Ceci permet d'avoir un traitement identique pour les listes et les dictionnaires
"""
- if type(args) == types.DictionaryType:
+ if type(args) == dict:
return args
- elif type(args) == types.ListType:
+ elif type(args) == list:
dico = {}
for arg in args:
dico[arg] = 0
sur présence de la sensibilité.
"""
-from types import TupleType, ListType
-EnumTypes = (TupleType, ListType)
+from __future__ import absolute_import
-from N_REGLE import REGLE
+from .N_REGLE import REGLE
# -----------------------------------------------------------------------------
class CONCEPT_SENSIBLE(REGLE):
if not hasattr(etape.sd,"sensi"):
etape.sd.sensi = {}
# si ENSEMBLE, la sd nominale est forcément produite
- if self.mode == self._modes['ENSEMBLE'] and not etape.sd.sensi.has_key('nominal'):
+ if self.mode == self._modes['ENSEMBLE'] and not 'nominal' in etape.sd.sensi :
etape.sd.sensi['nominal'] = id_etape
# liste des paramètres sensibles
valeur = obj[self.mocle]
if valeur == None:
# pas de sensibilité, la sd nominale est produite
- if not etape.sd.sensi.has_key('nominal'):
+ if not 'nominal' in etape.sd.sensi:
etape.sd.sensi['nominal'] = id_etape
return '', 1
- if not type(valeur) in EnumTypes:
+ if not type(valeur) in (list, tuple):
valeur = [valeur,]
for v in valeur:
- if not etape.sd.sensi.has_key(v.get_name()):
+ if not v.get_name() in etape.sd.sensi:
etape.sd.sensi[v.get_name()] = id_etape
return '', 1
text = "Commande non réentrante en l'absence de sensibilité."
return text, 0
else:
- if not type(valeur) in EnumTypes:
+ if not type(valeur) in (list, tuple):
valeur = [valeur,]
for ps in valeur:
if hasattr(sd, 'sensi') and sd.sensi.get(ps.nom, id_etape) != id_etape:
concept = obj[self.mocle]
except IndexError:
return '', 1
- if not type(concept) in EnumTypes:
+ if not type(concept) in (list, tuple):
concept = [concept,]
l_ps = obj["SENSIBILITE"]
for co in concept:
return text, 0
else:
# sensibilité spécifiée
- if not type(l_ps) in EnumTypes:
+ if not type(l_ps) in (list, tuple):
l_ps = [l_ps,]
for ps in l_ps:
if not hasattr(co,"sensi") or not co.sensi.get(ps.nom):
qui permet de spécifier les caractéristiques des mots clés simples
"""
+from __future__ import absolute_import
import types
-import N_ENTITE
-import N_MCSIMP
-from strfunc import ufmt
+from . import N_ENTITE
+from . import N_MCSIMP
class SIMP(N_ENTITE.ENTITE):
def __init__(self, typ,ang="", fr="", statut='f', into=None, defaut=None,
min=1, max=1, homo=1, position='local',
- val_min='**', val_max='**', docu="", validators=None,
+ val_min=float('-inf'), val_max=float('inf'), docu="", validators=None,
sug=None):
"""
Un mot-clé simple est caractérisé par les attributs suivants :
"""
N_ENTITE.ENTITE.__init__(self, validators)
# Initialisation des attributs
- if type(typ) == types.TupleType:
+ if type(typ) == tuple:
self.type = typ
else:
self.type = (typ,)
self.docu = docu
self.sug = sug
self.ang=ang
+ if self.max == '**' : self.max = float('inf')
+ if self.val_max == '**' : self.val_max = float('inf')
+ if self.min == '**' : self.min = float('-inf')
+ if self.val_min == '**' : self.val_min = float('-inf')
def verif_cata(self):
"""
Ce module contient toutes les classes necessaires pour
implanter le concept de validateur dans Accas
"""
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+ from builtins import object
+except : pass
+
import types
import traceback
import re
-from N_ASSD import ASSD
-from N_types import is_int, is_float_or_int, is_complex, is_number, is_str, is_sequence
-from strfunc import convert, ufmt
+from .N_ASSD import ASSD
+from .N_types import is_int, is_float_or_int, is_complex, is_number, is_str, is_sequence
from Extensions.i18n import tr
+import six
+from six.moves import range
return mro
-class Protocol:
+class Protocol(object):
def __init__(self, name):
self.registry = {}
if self.is_complexe(obj):
return obj
elif type_permis == 'TXM':
- if is_str(obj):
- return obj
+ if is_str(obj):
+ return obj
elif type_permis == 'shell':
if is_str(obj):
return obj
elif type_permis == 'Fichier':
import os
- if (len(typ) > 2 and typ[2] == "Sauvegarde") or os.path.isfile(obj):
- return obj
- else:
- raise ValError(
- ufmt(_(tr(u"%s n'est pas un fichier valide")), repr(obj)))
+ try :
+ if (len(typ) > 2 and typ[2] == "Sauvegarde") or os.path.isfile(obj):
+ return obj
+ else:
+ raise ValError( "%s n'est pas un fichier valide" % repr(obj))
+ except :
+ raise ValError( "%s n'est pas un fichier valide" % repr(obj))
+
elif type_permis == 'FichierNoAbs':
import os
if (len(typ) > 2 and typ[2] == "Sauvegarde") or isinstance(obj, type("")):
return obj
else:
- raise ValError(
- ufmt(_(tr("%s n'est pas un fichier valide")), repr(obj)))
+ raise ValError( "%s n'est pas un fichier valide" % repr(obj))
+
elif type_permis == 'Repertoire':
import os
- if os.path.isdir(obj):
- return obj
- else:
- raise ValError(
- ufmt(_(tr(u"%s n'est pas un repertoire valide")), repr(obj)))
- elif type(type_permis) == types.ClassType or isinstance(type_permis, type):
+ try :
+ if os.path.isdir(obj): return obj
+ else: raise ValError( "%s n'est pas un repertoire valide" % repr(obj))
+ except :
+ raise ValError( "%s n'est pas un repertoire valide" % repr(obj))
+ elif type(type_permis) == type or isinstance(type_permis, type):
try:
if self.is_object_from(obj, type_permis):
return obj
- except Exception, err:
+ except Exception as err:
pass
elif type(type_permis) == types.InstanceType or isinstance(type_permis, object):
try:
if type_permis.__convert__(obj):
return obj
- except Exception, err:
+ except Exception as err:
pass
else:
- print convert(ufmt(_(tr(u"Type non encore gere %s")), `type_permis`))
+ print(("Type non encore gere %s" %type_permis))
raise ValError(
- ufmt(_(tr(u"%s (de type %s) n'est pas d'un type autorise: %s %s")),
- repr(obj), type(obj), typ, unicode(err)))
+ tr("%s (de type %s) n'est pas d'un type autorise: %s %s") % (repr(obj), type(obj), typ, err))
def is_complexe(self, valeur):
""" Retourne 1 si valeur est un complexe, 0 sinon """
try:
v = convert(objet)
return v is not None
- except ValueError, err:
+ except ValueError as err:
raise
except:
return 0
def default(self, obj, min, max):
length = len(obj)
- if length < min or length > max:
+ if (length < min) or( length > max):
raise ValError(
- ufmt(
- _(tr(u"Nombre d'arguments de %s incorrect (min = %s, max = %s)")),
- repr(obj), min, max))
+ "Nombre d'arguments de %s incorrect (min = %s, max = %s)" % (repr(obj), min, max))
return obj
# pas de registre par instance. Registre unique pour toutes les instances
registry = {}
- def __init__(self, name, into=None, val_min='**', val_max='**'):
+ def __init__(self, name, into=None, val_min=float('-inf'), val_max=float('inf')):
+
PProtocol.__init__(
self, name, into=into, val_min=val_min, val_max=val_max)
self.val_min = val_min
if into:
if obj not in into:
raise ValError(
- ufmt(
- _(tr(u"La valeur : %s ne fait pas partie des choix possibles %s")), repr(obj), into))
+ tr("La valeur : %s ne fait pas partie des choix possibles %s") % (repr(obj), into))
else:
# on est dans le cas d'un ensemble continu de valeurs possibles
# (intervalle)
val_max = obj + 1
if obj < val_min or obj > val_max:
raise ValError(
- ufmt(
- _(tr(u"La valeur : %s est en dehors du domaine de validite [ %s , %s ]")),
- repr(obj), self.val_min, self.val_max))
+ tr("La valeur : %s est en dehors du domaine de validite [ %s , %s ]") %(repr(obj), self.val_min, self.val_max))
return obj
-class MinStr:
+class MinStr(object):
# exemple de classe pour verificateur de type
# on utilise des instances de classe comme type (typ=MinStr(3,6), par
# exemple)
self.max = max
def __convert__(self, valeur):
- if is_str(valeur) and self.min <= len(valeur) <= self.max:
- return valeur
+ if is_str(valeur) and self.min <= len(valeur) <= self.max: return valeur
raise ValError(
- ufmt(
- _(tr(u"%s n'est pas une chaine de longueur comprise entre %s et %s")),
- valeur, self.min, self.max))
+ "%s n'est pas une chaine de longueur comprise entre %s et %s" % (valeur, self.min, self.max))
def __repr__(self):
- return ufmt(_(tr(u"TXM de longueur entre %s et %s")), self.min, self.max)
+ return tr("TXM de longueur entre %s et %s" % (self.min, self.max))
class Valid(PProtocol):
fonctionnement et dans certains cas leur comportement par défaut.
@ivar cata_info: raison de la validite ou de l'invalidite du validateur meme
- @type cata_info: C{string}
+ @type cata_info: C{}
"""
registry = {}
la validation demandée par le validateur. Elle est utilisée
pour produire le compte-rendu de validité du mot clé associé.
"""
- return _(u"valeur valide")
+ return "valeur valide"
def aide(self):
"""
self.cata_info = ""
def info(self):
- return ufmt(_(tr(u"valeur %s obligatoire")), `self.elem`)
+ return (tr(u"valeur %s obligatoire") % self.elem)
def default(self, valeur, elem):
return valeur
elem.remove(v)
if elem:
raise ValError(
- ufmt(_(tr(u"%s ne contient pas les elements obligatoires : %s ")),
- valeur, elem))
+ tr("%s ne contient pas les elements obligatoires : %s ") % (valeur, elem))
return valeur
def has_into(self):
return 1
def info_erreur_item(self):
- return _(u"La valeur n'est pas dans la liste des choix possibles")
+ return tr("La valeur n'est pas dans la liste des choix possibles")
class Together(ListVal):
self.cata_info = ""
def info(self):
- return ufmt(_(tr(u"%s present ensemble")), `self.elem`)
+ return (tr("%s present ensemble") % self.elem)
def default(self, valeur, elem):
return valeur
if v in elem: elem.remove(v)
if ( len(elem) == 0 ): return valeur
if len(elem) != len(list(self.elem)) :
- raise ValError( ufmt(_(tr(u"%s ne contient pas les elements devant etre presents ensemble: %s ")), valeur, elem))
+ raise ValError(tr("%s ne contient pas les elements devant etre presents ensemble: %s ") %( valeur, elem))
return valeur
def has_into(self):
return 1
def info_erreur_item(self):
- return _(u"La valeur n'est pas dans la liste des choix possibles")
+ return tr("La valeur n'est pas dans la liste des choix possibles")
class Absent(ListVal):
self.cata_info = ""
def info(self):
- return ufmt(_(tr(u"%s absent")), `self.elem`)
+ return (tr("%s absent") % self.elem)
def default(self, valeur, elem):
return valeur
for val in valeur:
v = self.adapt(val)
if v in elem:
- raise ValError( ufmt(_(tr(u"%s n'est pas autorise : %s ")), v, elem))
+ raise ValError(tr("%s n'est pas autorise : %s ")% (v, elem))
return valeur
def has_into(self):
return 1
def info_erreur_item(self):
- return _(u"La valeur n'est pas dans la liste des choix possibles")
+ return tr("La valeur n'est pas dans la liste des choix possibles")
class NoRepeat(ListVal):
self.cata_info = ""
def info(self):
- return _(u"Pas de doublon dans la liste")
+ return tr("Pas de doublon dans la liste")
def info_erreur_liste(self):
- return _(u"Les doublons ne sont pas permis")
+ return tr("Les doublons ne sont pas permis")
def default(self, valeur):
if valeur in self.liste:
- raise ValError(ufmt(_(tr(u"%s est un doublon")), valeur))
+ raise ValError( tr("%s est un doublon") % valeur)
return valeur
def convert(self, valeur):
self.cata_info = ""
def info(self):
- return ufmt(_(tr(u"longueur de la chaine entre %s et %s")), self.low, self.high)
+ return (tr("longueur de la chaine entre %s et %s") %( self.low, self.high))
def info_erreur_item(self):
- return _(tr(u"Longueur de la chaine incorrecte"))
+ return tr("Longueur de la chaine incorrecte")
def convert(self, valeur):
for val in valeur:
def default(self, valeur, low, high):
if not is_str(valeur):
- raise ValError(ufmt(_(tr(u"%s n'est pas une chaine")), repr(valeur)))
+ raise ValError ("%s n'est pas une chaine" % repr(valeur))
if valeur[0] == "'" and valeur[-1] == "'":
low = low + 2
high = high + 2
if len(valeur) < low or len(valeur) > high:
raise ValError(
- ufmt(_(tr(u"%s n'est pas de la bonne longueur")), repr(valeur)))
+ "%s n'est pas de la bonne longueur" % repr(valeur))
return valeur
self.cata_info = ""
def info(self):
- return _(u"regarde si c'est une chaine")
+ return tr("regarde si c'est une chaine")
def info_erreur_item(self):
- return _(u"Ce n'est pas une chaine")
+ return tr("Ce n'est pas une chaine")
def convert(self, valeur):
for val in valeur:
def default(self, valeur):
if not is_str(valeur):
- raise ValError(ufmt(_(tr(u"%s n'est pas une chaine")), repr(valeur)))
+ raise ValError (tr("%s n'est pas une chaine") % repr(valeur))
return valeur
self.cata_info = ""
def info(self):
- return ufmt(_(tr(u"liste %s")), self.ord)
+ return ("liste %s" % self.ord)
def info_erreur_liste(self):
- return ufmt(_(tr(u"La liste doit etre en ordre %s")), self.ord)
+ return (tr("La liste doit etre en ordre %s") % self.ord)
def convert(self, valeur):
self.val = None
if self.ord == 'croissant':
if self.val is not None and valeur < self.val:
raise ValError(
- ufmt(_(tr(u"%s n'est pas par valeurs croissantes")), repr(self.liste)))
+ (tr("%s n'est pas par valeurs croissantes") % repr(self.liste)))
elif self.ord == 'decroissant':
if self.val is not None and valeur > self.val:
raise ValError(
- ufmt(_(tr(u"%s n'est pas par valeurs decroissantes")), repr(self.liste)))
+ (tr("%s n'est pas par valeurs decroissantes") % repr(self.liste)))
self.val = valeur
return valeur
return validator.convert(valeur)
except:
pass
- raise ValError(ufmt(_(tr(u"%s n'est pas du bon type")), repr(valeur)))
+ raise ValError(tr("%s n'est pas du bon type")% repr(valeur))
def info_erreur_item(self):
l = []
def __init__(self, low, high):
self.low = low
self.high = high
- self.cata_info = ufmt(_(tr(u"%s doit etre inferieur a %s")), low, high)
+ self.cata_info = (tr("%s doit etre inferieur a %s") % (low, high))
def info(self):
- return ufmt(_(tr(u"valeur dans l'intervalle %s , %s")), self.low, self.high)
+ return (tr("valeur dans l'intervalle %s , %s") %( self.low, self.high))
def convert_item(self, valeur):
if valeur > self.low and valeur < self.high:
return valeur
- raise ValError(ufmt(_(tr(u"%s devrait etre comprise entre %s et %s")),
- valeur, self.low, self.high))
+ raise ValError(tr("%s devrait etre comprise entre %s et %s") % (valeur, self.low, self.high))
def verif_item(self, valeur):
return valeur > self.low and valeur < self.high
def info_erreur_item(self):
- return ufmt(_(tr(u"La valeur doit etre comprise entre %s et %s")), self.low, self.high)
+ return (tr("la valeur %s doit etre comprise entre %s et %s") % (valeur, self.low, self.high))
+
def verif_cata(self):
if self.low > self.high:
catalogues
"""
- def __init__(self, min='**', max='**'):
+ def __init__(self, min=float('-inf'), max=float('inf')):
self.min = min
self.max = max
- self.cata_info = ufmt(_(tr(u"%s doit etre inferieur a %s")), min, max)
+ self.cata_info = (tr("%s doit etre inferieur a %s") %(min, max))
def info(self):
- return ufmt(_(tr(u"longueur de liste comprise entre %s et %s")), self.min, self.max)
+ return (tr("longueur de liste comprise entre %s et %s") %(self.min, self.max))
def info_erreur_liste(self):
- return ufmt(
- _(tr(u"Le cardinal de la liste doit etre compris entre %s et %s")),
- self.min, self.max)
+ return (tr("Le cardinal de la liste doit etre compris entre %s et %s") % (self.min, self.max))
def is_list(self):
return self.max == '**' or self.max > 1
l = 1
if self.max != '**' and l > self.max:
raise ValError(
- ufmt(_(tr(u"%s devrait etre de longueur inferieure a %s")), valeur, self.max))
+ tr("%s devrait etre de longueur inferieure a %s") % (valeur, self.max))
if self.min != '**' and l < self.min:
raise ValError(
- ufmt(_(tr(u"%s devrait etre de longueur superieure a %s")), valeur, self.min))
+ tr("%s devrait etre de longueur superieure a %s") % (valeur, self.min))
return valeur
def verif_item(self, valeur):
return _(u"valeur paire")
def info_erreur_item(self):
- return _(u"La valeur saisie doit etre paire")
+ return tr("La valeur saisie doit etre paire")
def convert(self, valeur):
for val in valeur:
v = self.adapt(val)
if v % 2 != 0:
raise ValError(
- ufmt(_(tr(u"%s contient des valeurs non paires")), repr(valeur)))
+ tr("%s contient des valeurs non paires") % repr(valeur))
return valeur
def default(self, valeur):
return valeur
def verif_item(self, valeur):
- if type(valeur) not in (int, long):
+ if type(valeur) not in six.integer_types:
return 0
return valeur % 2 == 0
self.cata_info = ""
def info(self):
- return "valeur dans %s" % `self.into`
+ return ("valeur dans %s" % self.into)
def convert_item(self, valeur):
if valeur in self.into:
return valeur
raise ValError(
- ufmt(_(tr(u"%s contient des valeurs hors des choix possibles: %s ")),
- valeur, self.into))
+ tr("%s contient des valeurs hors des choix possibles: %s ") % (valeur, self.into))
def verif_item(self, valeur):
if valeur not in self.into:
return liste_choix
def info_erreur_item(self):
- return _(u"La valeur n'est pas dans la liste des choix possibles")
+ return tr("La valeur n'est pas dans la liste des choix possibles")
def ImpairVal(valeur):
self.cata_info = ""
def info(self):
- return ufmt(_(tr(u"valeur %s pour la somme des cles A et B ")), self.somme)
+ return (tr("valeur %s pour la somme des cles A et B ") % self.somme)
def verif(self, valeur):
if is_sequence(valeur):
for val in valeur:
- if not val.has_key("A"):
+ if not "A" in val:
return 0
- if not val.has_key("B"):
+ if not "B" in val:
return 0
if val["A"] + val["B"] != self.somme:
return 0
return 1
else:
- if not valeur.has_key("A"):
+ if not "A" in valeur:
return 0
- if not valeur.has_key("B"):
+ if not "B" in valeur:
return 0
if valeur["A"] + valeur["B"] != self.somme:
return 0
def info(self):
return self.function.info
+ def info_erreur_item(self):
+ return self.function.info
+
def verif(self, valeur):
return self.function(valeur)
return valeur
# MC ca ne devrait plus servir !
-CoercableFuncs = {types.IntType: int,
- types.LongType: long,
- types.FloatType: float,
- types.ComplexType: complex,
- types.UnicodeType: unicode}
+CoercableFuncs = {int: int,
+ int: int,
+ float: float,
+ complex: complex,
+ str: six.text_type}
class TypeVal(ListVal):
def __init__(self, aType):
# Si aType n'est pas un type, on le retrouve a l'aide de la fonction type
# type(1) == int;type(0.2)==float;etc.
- if type(aType) != types.TypeType:
+ if type(aType) != type:
aType = type(aType)
self.aType = aType
try:
self.coerce = self.identity
def info(self):
- return ufmt(_(tr(u"valeur de %s")), self.aType)
+ return (tr("valeur de %s") % self.aType)
def identity(self, value):
if type(value) == self.aType:
if type(aClass) == types.InstanceType:
# instance ancienne mode
aClass = aClass.__class__
- elif type(aClass) == types.ClassType:
+ elif type(aClass) == type:
# classe ancienne mode
aClass = aClass
elif type(aClass) == type:
# instance nouvelle mode
aClass = type(aClass)
else:
- raise ValError(_(u"type non supporté"))
+ raise ValError(tr("type non supporté"))
self.aClass = aClass
def info(self):
- return ufmt(_(tr(u"valeur d'instance de %s")), self.aClass.__name__)
+ return (tr("valeur d'instance de %s") % self.aClass.__name__)
def verif_item(self, valeur):
if not isinstance(valeur, self.aClass):
return 1
-class VerifTypeTuple(Valid, ListVal):
+class VerifTypeTuple(ListVal):
def __init__(self, typeDesTuples):
self.typeDesTuples = typeDesTuples
self.cata_info = ""
def info(self):
- return _(tr(": verifie les types dans un tuple"))
+ return tr(": verifie les types dans un tuple")
def info_erreur_liste(self):
- return _(tr("Les types entres ne sont pas permis"))
+ return tr("Les types entres ne sont pas permis")
def default(self, valeur):
- # if valeur in self.liste : raise ValError("%s est un doublon" %
- # valeur)
return valeur
def is_list(self):
def convert_item(self, valeur):
if len(valeur) != len(self.typeDesTuples):
raise ValError(
- ufmt(_(tr(u"%s devrait etre de type %s ")), valeur, self.typeDesTuples))
+ tr("%s devrait etre de type %s ") %( valeur, self.typeDesTuples))
for i in range(len(valeur)):
ok = self.verifType(valeur[i], self.typeDesTuples[i])
if ok != 1:
raise ValError(
- ufmt(_(tr(u"%s devrait etre de type %s ")), valeur, self.typeDesTuples))
+ tr("%s devrait etre de type %s ") % (valeur, self.typeDesTuples))
return valeur
def verif_item(self, valeur):
def verifType(self, valeur, type_permis):
if type_permis == 'R':
- if type(valeur) in (types.IntType, types.FloatType, types.LongType):
+ if type(valeur) in (int, float, int):
return 1
elif type_permis == 'I':
- if type(valeur) in (types.IntType, types.LongType):
+ if type(valeur) in (int, int):
return 1
elif type_permis == 'C':
if self.is_complexe(valeur):
return 1
elif type_permis == 'TXM':
- if type(valeur) == types.StringType:
+ if type(valeur) == bytes:
return 1
elif isinstance(valeur, type_permis):
return 1
return 0
def verif(self, valeur):
- if type(valeur) in (types.ListType, types.TupleType):
+ if type(valeur) in (list, tuple):
liste = list(valeur)
for val in liste:
if self.verif_item(val) != 1:
if valeur in self.listeDesFreres:
return valeur
raise ValError(
- ufmt(_(tr(u"%s n'est pas dans %s")), valeur, self.listeDesFreres))
+ tr("%s n'est pas dans %s") % (valeur, self.listeDesFreres))
class RegExpVal(ListVal):
Vérifie qu'une chaîne de caractère corresponde à l'expression régulière 'pattern'
"""
- errormsg = u'La chaîne "%(value)s" ne correspond pas au motif "%(pattern)s"'
+ errormsg = 'La chaîne "%(value)s" ne correspond pas au motif "%(pattern)s"'
def __init__(self, pattern):
self.pattern = pattern
self.compiled_regexp = re.compile(pattern)
def info(self):
- return u'Une chaîne correspondant au motif "%s" est attendue.' % self.pattern
+ return tr('Une chaîne correspondant au motif ') + str(self.pattern) + tr(" est attendue")
+
+ def info_erreur_item(self):
+ return tr('Une chaîne correspondant au motif ') + str(self.pattern) + tr(" est attendue")
def verif_item(self, valeur):
if self.compiled_regexp.match(valeur):
def __init__(self, ext):
self.ext = ext
- self.errormsg = u'"%%(value)s" n\'est pas un nom de fichier %(ext)s valide' % {
+ self.errormsg = '"%%(value)s" n\'est pas un nom de fichier %(ext)s valide' % {
"ext": ext}
- #RegExpVal.__init__(self, "^[\w\-]+\.%s$" % self.ext)
#PNPN Modif pour Adao
- #RegExpVal.__init__(self, "^[\S]+\.%s$" % self.ext
RegExpVal.__init__(self, "^\S+\.%s$" % self.ext)
def info(self):
- return u'Un nom de fichier se terminant par ".%s" est attendu.' % self.ext
+ return ('Un nom de fichier se terminant par ".%s" est attendu.' % self.ext)
+
+ def info_erreur_item(self):
+ return ('Un nom de fichier se terminant par ".%s" est attendu.' % self.ext)
-class CreeMotClef:
+class CreeMotClef(object):
def __init__(self,MotClef ):
self.MotClef=MotClef
self.MCSimp=None
def convert(self, lval):
- print "dans convert"
try : valeur=lval[0]
except : return lval
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-import UserDict
+from __future__ import absolute_import
+try :
+ from past.builtins import cmp
+except :
+ pass
+try:
+ from UserDict import UserDict
+except ImportError:
+ from collections import UserDict
-class _F(UserDict.UserDict):
+class _F(UserDict):
"""
Cette classe a un comportement semblable à un
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2013 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# 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 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
-
-
-"""Module to manage information printing : debug, info, error.
-Should replace 'print' and 'UTMESS' calls at least in the supervisor
-modules.
-Only used for debug right now.
-"""
-
-import os
-import os.path as osp
-import re
-import traceback
-from functools import partial
-from subprocess import Popen, PIPE
-
-from N_utils import Enum, Singleton
-from strfunc import convert
-
-
-def default_print(text):
- """Basic print function."""
- print convert(text)
-
-LEVEL = Enum(
- 'DEBUG',
- 'INFO',
- 'WARN',
- 'ERROR'
-)
-
-
-class Category(object):
-
- """Define a category of message for different parts of the code.
- This allows to store different parameters for each category of message."""
-
- def __init__(self):
- self._level = LEVEL.INFO
- self._fmt = "%-8s"
- self._header = {
- LEVEL.DEBUG: "DEBUG",
- LEVEL.INFO: None,
- LEVEL.WARN: "WARNING",
- LEVEL.ERROR: "ERROR",
- }
-
- def set_level(self, level):
- """Set the current level."""
- self._level = level
-
- def get_level(self):
- """Return the current level."""
- return self._level
-
- def set_header(self, level, header):
- """Set the header of ``level`` messages."""
- self._header[level] = header
-
- def get_header(self, level):
- """Return the header at this ``level``."""
- header = self._header.get(level, "")
- if header:
- header = self._fmt % header
- return header
-
- def active(self, level):
- """Tell if a message should be print at this ``level``."""
- return self._level <= level
-
-
-ALL = Category()
-SUPERV = Category()
-SUPERV.set_header(LEVEL.ERROR, None)
-MISS = Category()
-
-REGEXP_ORIG = re.compile('File [\'\"]*(.*?)[\'\"]*, *line ([0-9]+), *in (.*)')
-
-# slighty different and very simplier than logger objects
-# from the logging module.
-
-
-class InfoLevel(Singleton):
-
- """Store informations level."""
- _singleton_id = 'N_info.InfoLevel'
-
- def __init__(self, level):
- """Initialization"""
- self._parts = []
- for part in self._parts:
- part.level = level
- self.reset_print_function()
- self._msg_callback = []
- # self.extend_message(ALL, stack_header_callback)
- self.extend_message(ALL, insert_header)
-
- def add(self, category):
- """Add a category of message."""
- self._parts.append(category)
-
- def set_level(self, category, level):
- """Set the current level for ``category``."""
- assert category in self._parts, "unknown category : %s" % category
- assert LEVEL.exists(level), "unknown level : %s" % level
- category.set_level(level)
- if category == ALL:
- for part in self._parts:
- part.set_level(level)
-
- def set_debug(self):
- """Set debug level for all categories."""
- self.set_level(ALL, LEVEL.DEBUG)
-
- def set_header(self, category, level, header):
- """Set the header of ``level`` messages."""
- category.set_header(level, header)
-
- def register_print_function(self, print_function):
- """Define the `print_function` to use."""
- self._print = print_function
-
- def reset_print_function(self):
- """Register the default 'print function'."""
- self._print = default_print
-
- def extend_message(self, category, callback):
- """Allow to extend the message calling an external function."""
- self._msg_callback.append((category, callback))
-
- def _message(self, category, level, msg, args, kwargs):
- """Print the message if the level is reached."""
- if category.active(level):
- if kwargs.get('utmess'):
- func = self._message_utmess
- else:
- func = self._message_print
- func = self._message_print
- apply(func, (category, level, msg, args, kwargs))
-
- def _message_print(self, category, level, msg, args, kwargs):
- """Print the message if the level is reached."""
- for cat, cbk in self._msg_callback:
- if cat in (ALL, category):
- msg, args = cbk(category, level, msg, args, kwargs)
- if len(args) > 0:
- try:
- msg = msg % args
- except Exception, err:
- msg = repr((msg, args, err))
- self._print(msg)
-
- def _message_utmess(self, category, level, msg, args, kwargs):
- """Print the message if the level is reached."""
- # how to use callbacks ? valk ?
- from Utilitai.Utmess import MessageLog
- code = {
- LEVEL.DEBUG: 'I',
- LEVEL.INFO: 'I',
- LEVEL.WARN: 'A',
- LEVEL.ERROR: 'F',
- }
- valk = kwargs.get('valk', ())
- vali = kwargs.get('vali', ())
- valr = kwargs.get('valr', ())
- msg = MessageLog.GetText(code[level], msg, valk, vali, valr)
- for cat, cbk in self._msg_callback:
- if cat in (ALL, category):
- msg, args = cbk(category, level, msg, args, kwargs)
- self._print(msg)
-
- def debug(self, category, msg, *args, **kwargs):
- """Print a debug message."""
- self._message(category or ALL, LEVEL.DEBUG, msg, args, kwargs)
-
- def info(self, category, msg, *args, **kwargs):
- """Print an information message."""
- self._message(category or ALL, LEVEL.INFO, msg, args, kwargs)
-
- def warn(self, category, msg, *args, **kwargs):
- """Print a warning message."""
- self._message(category or ALL, LEVEL.WARN, msg, args, kwargs)
-
- def error(self, category, msg, *args, **kwargs):
- """Print an error message."""
- self._message(category or ALL, LEVEL.ERROR, msg, args, kwargs)
-
- critical = error
-
- def add_memory_info(self, category):
- """Shortcut to add memory informations."""
- self.extend_message(category, mem_msg_callback)
-
- def use_aster_print(self):
- """Shortcut to use aster.affiche function to print the messages."""
- import aster
- self.register_print_function(partial(aster.affiche, 'MESSAGE'))
-
-
-# defined extensions
-def insert_header(category, level, msg, args, kwargs):
- """Insert the header."""
- header = category.get_header(level)
- if header:
- msg = header + msg
- return msg, args
-
-
-def stack_header_callback(category, level, msg, args, kwargs):
- """To insert the origin."""
- if level <= LEVEL.DEBUG:
- stack_id = -5 + kwargs.get('stack_id', 0)
- stack = traceback.format_stack(limit=10)[stack_id]
- mat = REGEXP_ORIG.search(stack)
- origin = '[%s:%s in %s] ' % (
- osp.basename(mat.group(1)), mat.group(2), mat.group(3))
- msg = origin + msg
- return msg, args
-
-
-# objet singleton
-message = InfoLevel(LEVEL.INFO)
-message.add(ALL)
-message.add(SUPERV)
-message.add(MISS)
-
-# callback to add memory information
-_pid = os.getpid()
-
-RE_VMPEAK = re.compile('VmPeak:\s*([0-9]+)\s*([kMGBo]+)', re.M | re.I)
-
-
-def memory_used(pid):
- """Return the current VmPeak value."""
- p = Popen(['cat', '/proc/%s/status' % pid], stdout=PIPE)
- output = p.communicate()[0]
- mat = RE_VMPEAK.search(output)
- mem = mat and int(mat.group(1)) or 0.
- return mem / 1024.
-
-current_memory_used = partial(memory_used, _pid)
-
-
-def mem_msg_callback(category, level, msg, args, kwargs):
- """Callback to add memory infos to message."""
- if level <= LEVEL.DEBUG:
- msg = msg + " - VmPeak : %.2f Mo"
- args = tuple(list(args) + [current_memory_used(), ])
- return msg, args
-
-
-if __name__ == "__main__":
- message.set_level(SUPERV, LEVEL.WARN)
- message.set_level(MISS, LEVEL.DEBUG)
- # message.debug(None, "debug message")
- message.info(ALL, "information message")
- message.warn(None, "warning message")
- message.error(ALL, "error message")
- message.add_memory_info()
- # message.debug(MISS, "debug supervisor message")
- message.info(SUPERV, "information supervisor message")
- message.warn(SUPERV, "warning supervisor message")
- message.error(SUPERV, "error supervisor message")
- message.critical(MISS, "test the critical alias")
"""
# eficas sentinel
+from __future__ import absolute_import
+import six
try:
import numpy as NP
_np_arr = NP.ndarray
def is_int(obj):
- return isinstance(obj, int) or type(obj) is long
+ return isinstance(obj, int) or type(obj) is int
def is_float(obj):
def is_str(obj):
- return isinstance(obj, (str, unicode))
+ return isinstance(obj, (str, six.text_type))
def is_list(obj):
def is_assd(obj):
- from N_ASSD import ASSD
+ from .N_ASSD import ASSD
return isinstance(obj, ASSD)
"""
# Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+try :
+ from builtins import str
+ from builtins import object
+except :
+ pass
import sys
# Modules EFICAS
-from N_Exception import AsException
-from N_types import is_int, is_float, is_complex, is_str, is_sequence, is_assd
-from strfunc import get_encoding
+from .N_Exception import AsException
+from .N_types import is_int, is_float, is_complex, is_str, is_sequence, is_assd
+from .strfunc import get_encoding
+import six
SEP = '_'
-try:
- # Si la version de Python possède la fonction _getframe
- # on l'utilise.
- cur_frame = sys._getframe
-except:
- # Sinon on l'émule
- def cur_frame(offset=0):
- """ Retourne la frame d execution effective eventuellement en remontant
- de offset niveaux dans la pile d execution
- Si il y a moins de offset niveaux retourne None
- """
- try:
- 1 / 0
- except:
- frame = sys.exc_info()[2].tb_frame.f_back
- while offset > 0:
- if frame == None:
- return None
- frame = frame.f_back
- offset = offset - 1
- return frame
-
+try :
+ cur_frame = sys._getframe
+except :
+ print ('pb avec la version de python pour cur_frame = sys._getframe')
def callee_where(niveau=4):
"""
recupere la position de l appel
"""
- frame = cur_frame(niveau)
+ frame = sys._getframe(niveau)
if frame == None:
return 0, "inconnu", 0, {}
try:
# Python 2.7 compile function does not accept unicode filename, so we encode it
# with the current locale encoding in order to have a correct traceback.
# Here, we convert it back to unicode.
- filename = unicode(frame.f_code.co_filename, get_encoding())
+ filename = six.text_type(frame.f_code.co_filename, get_encoding())
return frame.f_lineno, filename, frame.f_code.co_firstlineno, frame.f_locals
except:
return 0, "inconnu", 0, {}
def prbanner(s):
- print "*" * (len(s) + 10)
- print "*" * 5 + s + "*" * 5
- print "*" * (len(s) + 10)
+ print(("*" * (len(s) + 10)))
+ print(("*" * 5 + s + "*" * 5))
+ print(("*" * (len(s) + 10)))
def repr_float(valeur):
try:
__import__(modname)
mod = sys.modules[modname]
- except ImportError, err:
+ except ImportError as err:
raise ImportError(
- u"can not import module : %s (%s)" % (modname, str(err)))
+ "can not import module : %s (%s)" % (modname, str(err)))
try:
object = getattr(mod, objname)
- except AttributeError, err:
- raise AttributeError(u"object (%s) not found in module '%s'. "
+ except AttributeError as err:
+ raise AttributeError("object (%s) not found in module '%s'. "
"Module content is: %s" % (objname, modname, tuple(dir(mod))))
return object
"""
Ce package fournit les classes de base d'EFICAS.
- Ces classes permettent d'effectuer quelques opérations basiques :
+ Ces classes permettent d'effectuer quelques operations basiques :
- - la création
-
- - la vérification des définitions
-
- - la création d'objets de type OBJECT à partir d'une définition de type ENTITE
+ - la creation
+ - la verification des definitions
+ - la creation d'objets de type OBJECT a partir d'une definition 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ù
-import context
-import __builtin__
-__builtin__.CONTEXT = context
+# sous le nom CONTEXT afin d'avoir acces aux fonctions
+# get_current_step, set_current_step et unset_current_step de n'importe ou
+
+from __future__ import absolute_import
+from . import context
+try :
+ import __builtin__
+ __builtin__.CONTEXT = context
+except :
+ import builtins
+ builtins.CONTEXT = context
-def _(msg):
- """Differs translation."""
- # 'codex' should install its translation functions later
- return msg
-__builtin__._ = _
# Classes de base
-from N_SIMP import SIMP
-from N_FACT import FACT
+#from .N_SIMP import SIMP
+#from .N_FACT import FACT
-# 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
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2013 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# 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 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
-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):
- if value not in self.values:
- self.values.append(value)
-
- 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))
-
- def __repr__(self):
- 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.
- """
-
- def __init__(self):
- 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
-
- 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 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é
- # sd : concept qui contient obj
- # maj='maj', l'opérateur a le droit de modifier ojb
- if obj.exists:
- import md5
- 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:
- 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():
- pass
- else:
- self.err(obj, 'Le checksum a changé')
-
- def visitAsBase(self, obj):
- key = (obj.nomj(), obj.__class__.__name__)
- self.names[key] = self._marq
-
- def force(self, force=False):
- if not force:
- self._marq = 1
- else:
- 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)
- return res
-
- def checkedAsBase(self, obj):
- key = (obj.nomj(), obj.__class__.__name__)
- res = self.names.get(key, 0) >= self._marq
- self.help_dbg(key, res)
- return res
-
- def help_dbg(self, key, res):
- if self._debug:
- if res:
- s = 'ignore'
- else:
- 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])
-
-
-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))
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2013 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# 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 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
-"""
-Description des types de base aster
-
-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.
-
-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
-"""
-
-from basetype import Type
-
-
-class SDNom(Type):
-
- """Objet représentant une sous-partie de nom
- d'objet jeveux"""
- nomj = None
- debut = None
- fin = None
- just = None
- justtype = None
-
- 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
- just : la justification a droite ou a gauche ('l' ou 'r')
- 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
- 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))
-
- def __call__(self):
- if self._parent is None or self._parent._parent is None:
- debut = self.debut or 0
- prefix = ' ' * debut
- else:
- # normalement
- # assert self._parent.nomj is self
- nomparent = self._parent._parent.nomj
- prefix = nomparent()
- debut = self.debut or nomparent.fin or len(prefix)
- fin = self.fin or 24
- nomj = self.nomj or ''
- nomj = self.just(nomj, fin - debut)
- prefix = prefix.ljust(24)
- res = prefix[:debut] + nomj + prefix[fin:]
- return res[:24]
-
- def fcata(self):
- return self.just(self.nomj, self.fin - self.debut).replace(' ', '?')
-
- def __repr__(self):
- 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)
-
- def __getstate__(self):
- return (self.nomj, self.debut, self.fin, self.justtype)
-
- def __setstate__(self, (nomj, debut, fin, just)):
- self.nomj = nomj
- self.debut = debut
- self.fin = fin
- if just == 'l' or just is None:
- self.just = str.ljust
- elif just == 'r':
- self.just = str.rjust
- else:
- raise ValueError("Justification '%s' invalide" % just)
- self.justtype = just
-
- def update(self, (nomj, debut, fin, just)):
- if nomj is not None:
- self.nomj = nomj
- if self.debut is None:
- self.debut = debut
- if self.fin is None:
- self.fin = fin
- if self.justtype is None and just is not None:
- if just == 'l':
- self.just = str.ljust
- elif just == 'r':
- self.just = str.rjust
- else:
- raise ValueError("Justification '%s' invalide" % just)
- self.justtype = just
-
- 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)
- if self.nomj is None and self._parent._name is not None:
- self.nomj = "." + self._parent._name
+++ /dev/null
-# coding=utf-8
-# person_in_charge: mathieu.courtois at edf.fr
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2015 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.
-# ======================================================================
-
-"""
- Description des OJB jeveux
-"""
-from basetype import Type
-from asnom import SDNom
-from ascheckers import CheckLog
-import traceback
-import sys
-
-# pour utilisation dans eficas
-try:
- import aster
- from Utilitai.Utmess import UTMESS
-except:
- pass
-
-# -----------------------------------------------------------------------------
-
-
-class AsBase(Type):
- nomj = SDNom()
- optional = False
-
- 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):
- self.nomj.nomj = nomj
- 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"
- 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)
- if checker.checkedAsBase(self):
- return checker
- checker.visitAsBase(self)
-
- # 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)):
- v.check(checker)
- for name in dir(self):
- 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)
-
- checker.optional = optional
- return checker
-
- def dump(self, indent=""):
- import pydoc
- l = []
- checkers = []
- nomj = self.nomj()
- if self.optional:
- f = "(f)"
- else:
- f = "(o)"
- l.append(f + " " + nomj)
- for name in self._subtypes:
- obj = getattr(self, name)
- if isinstance(obj, (AsBase, OJB)):
- l.append(obj.dump(indent))
- for name in dir(self):
- if name.startswith('check_'):
- obj = getattr(self, name)
- if callable(obj) and name.startswith("check_"):
- checkers.append(obj)
-
- indent = " " * len(nomj)
- for checker in checkers:
- doc = pydoc.text.document(checker)
- for line in doc.splitlines():
- l.append(indent + line)
- return "\n".join(l)
-
- def short_repr(self):
- 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()
- else:
- 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 !
- 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)
- if checker is None:
- return True
- val = self.__get__(obj, obj.__class__)
- if callable(checker):
- return checker(obj, attrname, val, log)
- elif val == checker:
- return True
- else:
- log.err(obj, "Attribut incorrect %s %r!=%r" %
- (self.name, val, checker))
- return False
-
-# -----------------------------------------------------------------------------
-
-
-class JeveuxExists(JeveuxAttr):
-
- def __init__(self):
- pass
-
- def __get__(self, obj, klass):
- if obj is None:
- return self
- nomj = obj.nomj()
- if len(nomj) != 24:
- raise AssertionError(repr(nomj))
- 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:
- 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:
- return None
-
-# -----------------------------------------------------------------------------
-
-
-class OJB(AsBase):
- _clas = None
- _genr = None
- _type = None
- _ltyp = None
- _xous = None
- _docu = None
- _exists = True
-
- clas = JeveuxStrAttr("CLAS")
- genr = JeveuxStrAttr("GENR")
- type = JeveuxStrAttr("TYPE")
- ltyp = JeveuxIntAttr("LTYP")
- xous = JeveuxStrAttr("XOUS")
- docu = JeveuxStrAttr("DOCU")
- exists = JeveuxExists()
- nomj = SDNom()
-
- def __init__(self, nomj=None, **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
- if name in attrs:
- 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)
- else:
- return None
-
- def changeJeveuxValues(self, nbval, indices, reel, imag, num = 1):
- """Modify values of existing data structures"""
- nomj = self.nomj()
- if aster.jeveux_exists(nomj):
- obj_simple = aster.jeveux_getattr(nomj, 'XOUS')[1].strip() == 'S'
- if obj_simple:
- assert num==1,"""For vectors last argument must be set to 1"""
- # aster.putvectjev can be used for vectors (num=1) and collections
- aster.putvectjev(nomj, nbval, indices, reel, imag, num)
-
- def get_stripped(self):
- """Fonction utilitaire, renvoie une liste de chaines 'strippées'"""
- data = self.get()
- if data is not None:
- 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)
- if isinstance(v, JeveuxAttr):
- 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
- if checker.checkedOJB(self):
- return checker
- checker.visitOJB(self)
- if self.exists:
- 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)
- return checker
-
- def dump(self, indent=""):
- if self.optional:
- f = "(f)"
- else:
- f = "(o)"
- return f + " " + self.nomj() + " " + str(self.exists)
-
-# -----------------------------------------------------------------------------
-
-
-def Facultatif(ojb):
- ojb.optional = True
- return ojb
-
-# -----------------------------------------------------------------------------
-
-
-class OJBVect(OJB):
- lonmax = JeveuxIntAttr("LONMAX")
- lonuti = JeveuxIntAttr("LONUTI")
- _xous = "S"
- _genr = "V"
-
-# -----------------------------------------------------------------------------
-
-
-class OJBPtnom(OJB):
- nommax = JeveuxIntAttr("NOMMAX")
- nomuti = JeveuxIntAttr("NOMUTI")
- _xous = "S"
- _genr = "N"
- _type = "K"
-
-# -----------------------------------------------------------------------------
-
-
-class OJBCollec(OJB):
- stockage = JeveuxStrAttr("STOCKAGE")
- 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
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2013 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# 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 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
-
-"""
-
-Description des types de base aster
------------------------------------
-
-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.
-
-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
-
-La classe `Type` hérite de BaseType et y associe la métaclasse MetaType.
-
-"""
-
-import cPickle
-
-__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
- """
- 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:
-
- - L'attribut _subtypes qui contient la liste des sous-structures
- 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.
-
- 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
- ont eux-meme un attribut parent qui pointe sur la classe qui les contient.
- """
- new_cls = type.__new__(mcs, name, bases, classdict)
- new_cls._subtypes = []
- for b in bases:
- 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é.
- for k, v in classdict.items():
- if not isinstance(v, BaseType):
- continue
- v.reparent(new_cls, k)
- new_cls._subtypes.append(k)
- return new_cls
-
- def dup_attr(cls, inst):
- """Duplique les attributs de la classe `cls` pour qu'ils deviennent
- des attributs de l'instance `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)
-
- 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
- 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)
- type(inst).__init__(inst, *args, **kwargs)
- return inst
-
- def mymethod(cls):
- pass
-
-
-class BaseType(object):
- # Le parent de la structure pour les sous-structures
- _parent = None
- _name = None
-
- def __init__(self, *args, **kwargs):
- self._initargs = args
- self._initkwargs = kwargs
- self._name = None
- self._parent = None
-
- 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)
-
- 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."""
- 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
- # instanciation future...
- # 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
#
# ======================================================================
+from __future__ import absolute_import
_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'etape courante.
+# Une macro se declare etape courante dans sa methode Build avant de construire
+# ses etapes filles ou dans BuildExec avant de les executer.
+# Les etapes simples le font aussi : dans Execute et BuildExec.
+# (Build ne fait rien pour une etape)
def set_current_step(step):
"""
- Fonction qui permet de changer la valeur de l'étape courante
+ Fonction qui permet de changer la valeur de l'etape 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
+ Fonction qui permet d'obtenir la valeur de l'etape courante
"""
return _root
def unset_current_step():
"""
- Fonction qui permet de remettre à None l'étape courante
+ Fonction qui permet de remettre a None l'etape courante
"""
global _root
_root = None
def unset_current_cata():
"""
- Fonction qui permet de remettre à None le catalogue courant
+ Fonction qui permet de remettre a None le catalogue courant
"""
global _cata
_cata = None
"""
# Modules Python
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import range
+except :
+ pass
import re
-import string
import linecache
from functools import partial
# Modules EFICAS
-import N_utils
-from strfunc import get_encoding
+from . import N_utils
+from .strfunc import get_encoding
+import six
+from six.moves import range
regex1 = '=?\s*%s\s*\('
# commentaire standard precede d'un nombre quelconque de blancs (pas
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())
+ filename = six.text_type(co.co_filename, get_encoding())
name = co.co_name
# pattern pour identifier le debut de la commande
pattern_oper = re.compile(regex1 % ope)
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)
+ m = evalnom(l[0].strip(), f.f_locals)
# print "NOMS ",m
if m != []:
return m[-1]
"""
# module identique à Execution/strfunc.py pour usage dans Eficas
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
import locale
+import six
_encoding = None
def to_unicode(string):
"""Try to convert string into a unicode string."""
- if type(string) is unicode:
+ if type(string) is six.text_type:
return string
elif type(string) is dict:
new = {}
- for k, v in string.items():
+ for k, v in list(string.items()):
new[k] = to_unicode(v)
return new
elif type(string) is list:
assert type(string) is str, u"unsupported object: %s" % string
for encoding in ('utf-8', 'iso-8859-15', 'cp1252'):
try:
- s = unicode(string, encoding)
+ s = six.text_type(string, encoding)
return s
except UnicodeDecodeError:
pass
- return unicode(string, 'utf-8', 'replace')
-
-
-def from_unicode(ustring, encoding, errors='replace'):
- """Try to encode a unicode string using encoding."""
- try:
- return ustring.encode(encoding)
- except UnicodeError:
- 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 = unicode(content)
- if type(content) == str:
- content = to_unicode(content)
- return from_unicode(content, encoding or get_encoding(), errors)
+ return six.text_type(string, 'utf-8', 'replace')
-def ufmt(uformat, *args):
- """Helper function to format a string by converting all its arguments to unicode"""
- if type(uformat) is not unicode:
- uformat = to_unicode(uformat)
- if len(args) == 1 and type(args[0]) is dict:
- arguments = to_unicode(args[0])
- else:
- nargs = []
- for arg in args:
- if type(arg) in (str, unicode, list, tuple, dict):
- nargs.append(to_unicode(arg))
- elif type(arg) not in (int, long, float):
- nargs.append(to_unicode(str(arg)))
- else:
- nargs.append(arg)
- arguments = tuple(nargs)
- formatted_string=""
- try:
- formatted_string = uformat % arguments
- #except UnicodeDecodeError:
- # print type(uformat), uformat
- # print type(arguments), arguments
- #raise
- except :
- pass
- return formatted_string
+#def from_unicode(ustring, encoding, errors='replace'):
+# """Try to encode a unicode string using encoding."""
+# try:
+# return ustring.encode(encoding)
+# except UnicodeError:
+# 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, six.text_type):
+# content = six.text_type(content)
+# if type(content) == str:
+# 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 six.text_type:
+# uformat = to_unicode(uformat)
+# if len(args) == 1 and type(args[0]) is dict:
+# arguments = to_unicode(args[0])
+# else:
+# nargs = []
+# for arg in args:
+# if type(arg) in (str, six.text_type, list, tuple, dict):
+# nargs.append(to_unicode(arg))
+# elif type(arg) not in (int, int, float):
+# nargs.append(to_unicode(str(arg)))
+# else:
+# nargs.append(arg)
+# arguments = tuple(nargs)
+# formatted_string=""
+# try:
+# formatted_string = uformat % arguments
+# #except UnicodeDecodeError:
+# # print type(uformat), uformat
+# # print type(arguments), arguments
+# #raise
+# except :
+# pass
+# return formatted_string
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>441</width>
+ <height>194</height>
+ </rect>
+ </property>
+ <property name="windowTitle">
+ <string>Form</string>
+ </property>
+ <widget class="QPushButton" name="pushButton_2">
+ <property name="geometry">
+ <rect>
+ <x>50</x>
+ <y>60</y>
+ <width>231</width>
+ <height>71</height>
+ </rect>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">background-color : rgb(168, 227, 142);
+/*border-style : outset;*/
+border-radius : 20px;
+border-width : 30 px;
+border-color : beige;
+text-align : left</string>
+ </property>
+ <property name="text">
+ <string>DIRECTION</string>
+ </property>
+ <property name="icon">
+ <iconset>
+ <normaloff>../monCode/images/essaiAster.png</normaloff>../monCode/images/essaiAster.png</iconset>
+ </property>
+ <property name="iconSize">
+ <size>
+ <width>48</width>
+ <height>48</height>
+ </size>
+ </property>
+ </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
</property>
<property name="icon">
<iconset theme="find">
- <normaloff/>
- </iconset>
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="iconSize">
<size>
<x>0</x>
<y>0</y>
<width>300</width>
- <height>127</height>
+ <height>125</height>
</rect>
</property>
<layout class="QGridLayout" name="gridLayout_2">
- <property name="horizontalSpacing">
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
<number>0</number>
</property>
- <property name="margin">
+ <property name="horizontalSpacing">
<number>0</number>
</property>
<item row="0" column="0">
<property name="spacing">
<number>0</number>
</property>
- <property name="margin">
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
<number>0</number>
</property>
<item>
<property name="text">
<string/>
</property>
- <property name="checked">
- <bool>true</bool>
- </property>
</widget>
</item>
<item>
desWidgetMatrice.py desWidgetParam.py desWidgetPlusieursBase.py desWidgetPlusieursInto.py \
desWidgetPlusieursIntoOrdonne.py desWidgetPlusieursTuple.py desWidgetRadioButton.py \
desWidget4a6RadioButton.py desWidgetSimpBase.py desWidgetSDCOInto.py desWidgetSimpBool.py \
- desWidgetSimpSalome.py \
+ desWidgetSimpSalome.py desPBMT.py\
desWidgetSimpComplexe.py desWidgetSimpFichier.py desWidgetSimpTxt.py desWidgetTuple2.py \
desWidgetTuple3.py desWidgetVide.py desWidgetUniqueSDCO.py desWidgetPlusieursPlie.py
<string notr="true">QComboBox{combobox-popup:0;}</string>
</property>
<layout class="QGridLayout" name="gridLayout">
- <property name="margin">
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
<number>0</number>
</property>
<item row="0" column="0">
<x>0</x>
<y>0</y>
<width>1676</width>
- <height>24</height>
+ <height>25</height>
</rect>
</property>
<widget class="QMenu" name="menuFichier">
<addaction name="separator"/>
<addaction name="actionCommentaire"/>
<addaction name="actionParametres"/>
+ <addaction name="separator"/>
+ <addaction name="actionCacher_l_Arbre"/>
+ <addaction name="actionAfficher_l_Arbre"/>
</widget>
<widget class="QMenu" name="menuAide">
<property name="title">
<action name="action_Nouveau">
<property name="icon">
<iconset theme="document-new">
- <normaloff/>
- </iconset>
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>&Nouveau</string>
<action name="actionOuvrir">
<property name="icon">
<iconset theme="document-open">
- <normaloff/>
- </iconset>
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>&Ouvrir</string>
<action name="actionEnregistrer">
<property name="icon">
<iconset theme="document-save">
- <normaloff/>
- </iconset>
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>Enregistrer</string>
<action name="actionEnregistrer_sous">
<property name="icon">
<iconset theme="document-save-as">
- <normaloff/>
- </iconset>
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>Enregistrer sous</string>
<action name="actionCouper">
<property name="icon">
<iconset theme="edit-cut">
- <normaloff/>
- </iconset>
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>Couper</string>
<action name="actionCopier">
<property name="icon">
<iconset theme="edit-copy">
- <normaloff/>
- </iconset>
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>Copier</string>
<action name="actionColler">
<property name="icon">
<iconset theme="edit-paste">
- <normaloff/>
- </iconset>
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>Coller</string>
<action name="actionSupprimer">
<property name="icon">
<iconset theme="edit-delete">
- <normaloff/>
- </iconset>
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>Supprimer</string>
<action name="actionRechercher">
<property name="icon">
<iconset theme="edit-find">
- <normaloff/>
- </iconset>
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>Rechercher</string>
<string>Régles du JdC</string>
</property>
</action>
+ <action name="actionCacher_l_Arbre">
+ <property name="text">
+ <string>Cacher l'Arbre</string>
+ </property>
+ </action>
+ <action name="actionAfficher_l_Arbre">
+ <property name="text">
+ <string>Afficher l'Arbre</string>
+ </property>
+ </action>
</widget>
<resources/>
<connections/>
# ======================================================================
-class AU_MOINS_UN:
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
+
+class AU_MOINS_UN(object):
"""
- La règle AU_MOINS_UN vérifie que l'on trouve au moins un des mots-clés
- de la règle parmi les arguments d'un OBJECT.
+ La regle AU_MOINS_UN verifie que l'on trouve au moins un des mots-cles
+ de la regle parmi les arguments d'un OBJECT.
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
+ Ces arguments sont transmis a la regle pour validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
"""
def verif(self, args):
"""
- La méthode verif vérifie que l'on trouve au moins un des mos-clés
- de la liste self.mcs parmi les éléments de args
+ La methode verif verifie que l'on trouve au moins un des mos-cles
+ de la liste self.mcs parmi les elements de args
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
"""
# on compte le nombre de mots cles presents
text = ''
count = 0
args = self.liste_to_dico(args)
for mc in self.mcs:
- if args.has_key(mc):
+ if mc in args :
count = count + 1
if count == 0:
- text = u"- Il faut au moins un mot-clé parmi : " + `self.mcs`+'\n'
+ text = "- Il faut au moins un mot-cle parmi : " + repr(self.mcs)+'\n'
return text, 0
return text, 1
# ======================================================================
-class AU_PLUS_UN:
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
+
+class AU_PLUS_UN(object):
"""
- La règle vérifie que l'on trouve 1 (au plus) des mots-clés
- de la règle parmi les arguments d'un OBJECT.
+ La regle verifie que l'on trouve 1 (au plus) des mots-cles
+ de la regle parmi les arguments d'un OBJECT.
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
+ Ces arguments sont transmis a la regle pour validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
"""
def verif(self, args):
"""
- La méthode verif vérifie que l'on trouve 1 (au plus) des mos-clés
- de la liste self.mcs parmi les éléments de args
+ La methode verif verifie que l'on trouve 1 (au plus) des mos-cles
+ de la liste self.mcs parmi les elements de args
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
"""
# on compte le nombre de mots cles presents
text = ''
for mc in self.mcs:
count = count + args.get(mc, 0)
if count > 1:
- text = u"- Il ne faut qu'un mot-clé (au plus) parmi : " + \
- `self.mcs`+'\n'
+ text = "- Il ne faut qu'un mot-cle (au plus) parmi : " + \
+ repr(self.mcs)+'\n'
return text, 0
return text, 1
dico[arg] = dico.get(arg, 0) + 1
return dico
else:
- raise Exception(
- "Erreur ce n'est ni un dictionnaire ni une liste %s" % args)
+ raise Exception( "Erreur ce n'est ni un dictionnaire ni une liste %s" % args)
#
# ======================================================================
-from Noyau.strfunc import convert, ufmt
-class A_CLASSER:
+from __future__ import print_function
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except :
+ pass
+
+class A_CLASSER(object):
"""
- La règle A_CLASSER vérifie que ...
+ La regle A_CLASSER verifie que ...
"""
def __init__(self, *args):
if len(args) > 2:
- print convert(
- ufmt(_(u"Erreur à la création de la règle A_CLASSER(%s)"),
- args))
+ print ("Erreur a la creation de la regle A_CLASSER(%s)" % str(args))
return
self.args = args
- if type(args[0]) == tuple:
- self.args0 = args[0]
- elif type(args[0]) == str:
- self.args0 = (args[0],)
+ if type(args[0]) == tuple: self.args0 = args[0]
+ elif type(args[0]) == str: self.args0 = (args[0],)
else:
- print convert(ufmt(_(u"Le premier argument de : %s doit etre un "
- u"tuple ou une chaine"), args))
+ print ( "Le premier argument de : %s doit etre un tuple ou une chaine" % str(args))
if type(args[1]) == tuple:
self.args1 = args[1]
elif type(args[1]) == str:
self.args1 = (args[1],)
else:
- print convert(ufmt(_(u"Le deuxième argument de :%s doit etre un "
- u"tuple ou une chaine"), args))
- # création de la liste des mcs
+ print ("Le deuxieme argument de : %s doit etre un tuple ou une chaine" % str(args))
+ # creation de la liste des mcs
liste = []
liste.extend(self.args0)
liste.extend(self.args1)
self.init_couples_permis()
def init_couples_permis(self):
- """ Crée la liste des couples permis parmi les self.args, càd pour chaque élément
- de self.args0 crée tous les couples possibles avec un élément de self.args1"""
+ """ Cree la liste des couples permis parmi les self.args, cad pour chaque element
+ de self.args0 cree tous les couples possibles avec un element de self.args1"""
liste = []
for arg0 in self.args0:
for arg1 in self.args1:
def verif(self, args):
"""
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
"""
- # création de la liste des couples présents dans le fichier de
+ # creation de la liste des couples presents dans le fichier de
# commandes
l_couples = []
couple = []
couple = [nom, ]
if len(couple) > 0:
l_couples.append(tuple(couple))
- # l_couples peut etre vide si l'on n'a pas réussi à trouver au moins un
- # élément de self.mcs
+ # l_couples peut etre vide si l'on n'a pas reussi a trouver au moins un
+ # element de self.mcs
if len(l_couples) == 0:
- message = ufmt(_(u"- Il faut qu'au moins un objet de la liste : %r"
- u" soit suivi d'au moins un objet de la liste : %r"),
- self.args0, self.args1)
+ message = "- Il faut qu'au moins un objet de la liste : %s soit suivi d'au moins un objet de la liste %s : " % (self.args0,self.args1)
return message, 0
- # A ce stade, on a trouvé des couples : il faut vérifier qu'ils sont
+ # A ce stade, on a trouve des couples : il faut verifier qu'ils sont
# tous licites
num = 0
for couple in l_couples:
if len(couple) == 1:
# on a un 'faux' couple
if couple[0] not in self.args1:
- text = text + ufmt(
- _(u"- L'objet : %s doit être suivi d'un objet de la liste : %r\n"),
- couple[0], self.args1)
+ text = text + "- L'objet : %s doit etre suivi d'un objet de la liste : %r\n" %(couple[0], self.args1)
test = 0
else:
if num > 1:
# ce n'est pas le seul couple --> licite
break
else:
- text = text + ufmt(
- _(u"- L'objet : %s doit être précédé d'un objet de la liste : %r\n"),
- couple[0], self.args0)
+ text = text + "- L'objet : %s doit etre precede d'un objet de la liste : %r\n" %(couple[0], self.args0)
test = 0
elif couple not in self.liste_couples:
- text = text + ufmt(
- _(u"- L'objet : %s ne peut être suivi de : %s\n"),
- couple[0], couple[1])
+ text = text + "- L'objet : %s ne peut etre suivi de : %s\n" %(couple[0], couple[1])
test = 0
return text, test
# ======================================================================
-class ENSEMBLE:
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
+
+class ENSEMBLE(object):
"""
- La règle vérifie que si un mot-clé de self.mcs est present
+ La regle verifie que si un mot-cle de self.mcs est present
parmi les elements de args tous les autres doivent etre presents.
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
+ Ces arguments sont transmis a la regle pour validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
"""
def verif(self, args):
"""
- La methode verif effectue la verification specifique à la règle.
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
+ La methode verif effectue la verification specifique a la regle.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
"""
# on compte le nombre de mots cles presents, il doit etre egal a la liste
# figurant dans la regle
args = self.liste_to_dico(args)
pivot = None
for mc in self.mcs:
- if args.has_key(mc):
+ if mc in args:
pivot = mc
break
if pivot:
for mc in self.mcs:
if mc != pivot:
- if not args.has_key(mc):
- text = text + "- " + pivot + u" étant présent, " + \
- mc + u" doit être présent" + '\n'
+ if not mc in args :
+ text = text + "- " + pivot + " etant present, " + \
+ mc + " doit etre present" + '\n'
test = 0
return text, test
# coding=utf-8
-# person_in_charge: mathieu.courtois at edf.fr
# ======================================================================
# COPYRIGHT (C) 1991 - 2015 EDF R&D WWW.CODE-ASTER.ORG
# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
"""
- Ce module contient la classe mixin ETAPE qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type ETAPE
- dérivé de OBJECT.
+ Ce module contient la classe mixin ETAPE qui porte les methodes
+ necessaires pour realiser la validation d'un objet de type ETAPE
+ derive de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisee par heritage multiple pour composer les traitements.
"""
+from __future__ import print_function
+from __future__ import absolute_import
+
# Modules Python
import types
import sys
import re
# Modules EFICAS
-import V_MCCOMPO
+from . import V_MCCOMPO
from Noyau import MAXSIZE, MAXSIZE_MSGCHK
from Noyau.N_Exception import AsException
from Noyau.N_utils import AsType
-from Noyau.strfunc import ufmt
from Extensions.i18n import tr
text_erreurs, test_regles = self.verif_regles()
if not test_regles:
if cr == 'oui':
- self.cr.fatal(
- _(u"Règle(s) non respectée(s) : %s"), text_erreurs)
+ self.cr.fatal( "Regle(s) non respectee(s) : %s" % text_erreurs)
return 0
return 1
""" Cette methode teste la validite du nom du concept produit par l'etape """
valid = 1
if self.sd.nom != None:
- if self.jdc and self.jdc.definition.code == 'ASTER' and len(self.sd.nom) > 8:
- # le nom de la sd doit avoir une longueur <= 8 caractères pour
- # ASTER
- if cr == 'oui':
- self.cr.fatal(
- _(u"Le nom de concept %s est trop long (8 caractères maxi)"),
- self.sd.nom)
- valid = 0
if self.sd.nom.find('sansnom') != -1:
# la SD est 'sansnom' : --> erreur
if cr == 'oui':
- #self.cr.fatal(_(u"Pas de nom pour le concept retourné"))
- self.cr.fatal(_("object must have a name"))
+ self.cr.fatal(("object must have a name"))
valid = 0
elif re.search('^SD_[0-9]*$', self.sd.nom):
- # la SD est 'SD_' cad son nom = son id donc pas de nom donné
+ # la SD est 'SD_' cad son nom = son id donc pas de nom donne
# par utilisateur : --> erreur
if cr == 'oui':
- self.cr.fatal(
- #_(u"Nom de concept invalide ('SD_' est réservé)"))
- _("invalid name ('SD_' is a reserved keyword)"))
+ self.cr.fatal( ("invalid name ('SD_' is a reserved keyword)"))
valid = 0
return valid
def isvalid(self, sd='oui', cr='non'):
"""
- Methode pour verifier la validité de l'objet ETAPE. Cette méthode
- peut etre appelée selon plusieurs modes en fonction de la valeur
+ Methode pour verifier la validite de l'objet ETAPE. Cette methode
+ peut etre appelee selon plusieurs modes en fonction de la valeur
de sd et de cr.
- Si cr vaut oui elle crée en plus un compte-rendu.
+ Si cr vaut oui elle cree en plus un compte-rendu.
- Cette méthode a plusieurs fonctions :
+ Cette methode a plusieurs fonctions :
- - mettre à jour l'état de self (update)
+ - mettre a jour l'etat de self (update)
- - retourner un indicateur de validité 0=non, 1=oui
+ - retourner un indicateur de validite 0=non, 1=oui
- produire un compte-rendu : self.cr
"""
if CONTEXT.debug:
- print "ETAPE.isvalid ", self.nom
+ print(("ETAPE.isvalid ", self.nom))
if self.state == 'unchanged':
return self.valid
else:
if self.reste_val != {}:
if cr == 'oui':
self.cr.fatal(
- #_(u"Mots clés inconnus : %s"), ','.join(self.reste_val.keys()))
- _("unknown keywords : %s"), ','.join(self.reste_val.keys()))
+ "unknown keywords : %s" % ','.join(list(self.reste_val.keys())))
valid = 0
if sd == "non":
- # Dans ce cas, on ne teste qu'une validité partielle (sans tests sur le concept produit)
- # Conséquence : on ne change pas l'état ni l'attribut valid, on retourne simplement
- # l'indicateur de validité valid
+ # Dans ce cas, on ne teste qu'une validite partielle (sans tests sur le concept produit)
+ # Consequence : on ne change pas l'etat ni l'attribut valid, on retourne simplement
+ # l'indicateur de validite valid
return valid
if self.definition.reentrant == 'n' and self.reuse:
# reentrant
if cr == 'oui':
self.cr.fatal(
- _(u'Opérateur non réentrant : ne pas utiliser reuse'))
+ 'Operateur non reentrant : ne pas utiliser reuse')
valid = 0
if self.sd == None:
# Le concept produit n'existe pas => erreur
if cr == 'oui':
- # self.cr.fatal(_(u"Concept retourné non défini"))
- self.cr.fatal(_("Concept is not defined"))
+ self.cr.fatal(("Concept is not defined"))
valid = 0
else:
valid = valid * self.valid_sdnom(cr)
def update_sdprod(self, cr='non'):
"""
- Cette méthode met à jour le concept produit en fonction des conditions initiales :
+ Cette methode met a jour le concept produit en fonction des conditions initiales :
- 1. Il n'y a pas de concept retourné (self.definition.sd_prod == None)
+ 1. Il n'y a pas de concept retourne (self.definition.sd_prod == None)
- 2. Le concept retourné n existait pas (self.sd == None)
+ 2. Le concept retourne n existait pas (self.sd == None)
- 3. Le concept retourné existait. On change alors son type ou on le supprime
+ 3. Le concept retourne existait. On change alors son type ou on le supprime
- En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
+ En cas d'erreur (exception) on retourne un indicateur de validite de 0 sinon de 1
"""
sd_prod = self.definition.sd_prod
- if type(sd_prod) == types.FunctionType: # Type de concept retourné calculé
+ if type(sd_prod) == types.FunctionType: # Type de concept retourne calcule
d = self.cree_dict_valeurs(self.mc_liste)
try:
- sd_prod = apply(sd_prod, (), d)
+ sd_prod = sd_prod(*(), **d)
except:
- # Erreur pendant le calcul du type retourné
+ # Erreur pendant le calcul du type retourne
if CONTEXT.debug:
traceback.print_exc()
self.sd = None
sys.exc_info()[1],
sys.exc_info()[2])
self.cr.fatal(
- #_(u'Impossible d affecter un type au résultat\n %s'), ' '.join(l[2:]))
- _('unable to affect type to concept\n %s'), ' '.join(l[2:]))
+ 'unable to affect type to concept\n %s' % ' '.join(l[2:]))
return 0
- # on teste maintenant si la SD est r\351utilis\351e ou s'il faut la
- # cr\351er
+ # on teste maintenant si la SD est reutilisee ou s'il faut la
+ # creer
valid = 1
if self.reuse:
if AsType(self.reuse) != sd_prod:
if cr == 'oui':
self.cr.fatal(
- _(u'Type de concept réutilisé incompatible avec type produit'))
+ ('Type de concept reutilise incompatible avec type produit'))
valid = 0
if self.sdnom != '':
if self.sdnom[0] != '_' and self.reuse.nom != self.sdnom:
# Le nom de la variable de retour (self.sdnom) doit etre le
# meme que celui du concept reutilise (self.reuse.nom)
if cr == 'oui':
- self.cr.fatal(_(u'Concept réutilisé : le nom de la variable de '
- u'retour devrait être %s et non %s'),
- self.reuse.nom, self.sdnom)
+ self.cr.fatal('Concept reutilise : le nom de la variable de retour devrait etre %s et non %s' % ( self.reuse.nom, self.sdnom))
valid = 0
if valid:
self.sd = self.reuse
else:
- if sd_prod == None: # Pas de concept retourné
+ if sd_prod == None: # Pas de concept retourne
# Que faut il faire de l eventuel ancien sd ?
self.sd = None
else:
if self.sd:
# Un sd existe deja, on change son type
if CONTEXT.debug:
- print "changement de type:", self.sd, sd_prod
+ print(("changement de type:", self.sd, sd_prod))
if self.sd.__class__ != sd_prod:
self.sd.change_type(sd_prod)
else:
- # Le sd n existait pas , on ne le crée pas
+ # Le sd n existait pas , on ne le cree pas
if cr == 'oui':
- self.cr.fatal(_(u"Concept retourné non défini"))
+ self.cr.fatal("Concept retourne non defini")
valid = 0
if self.definition.reentrant == 'o':
if cr == 'oui':
self.cr.fatal(
- _(u'Commande obligatoirement réentrante : spécifier reuse=concept'))
+ ('Commande obligatoirement reentrante : specifier reuse=concept'))
valid = 0
return valid
"""
Methode pour generation d un rapport de validite
"""
- #self.cr = self.CR(debut=u'Etape : ' + self.nom
- # + u' ligne : ' + `self.appel[0]`
- # + u' fichier : ' + `self.appel[1]`,
- # fin=u'Fin Etape : ' + self.nom)
- self.cr = self.CR(debut=u'Command : ' + tr(self.nom)
- + u' line : ' + `self.appel[0]`
- + u' file : ' + `self.appel[1]`,
- fin=u'End Command : ' + tr(self.nom))
+ self.cr = self.CR(debut='Command : ' + tr(self.nom)
+ + ' line : ' + repr(self.appel[0])
+ + ' file : ' + repr(self.appel[1]),
+ fin='End Command : ' + tr(self.nom))
self.state = 'modified'
try:
self.isvalid(cr='oui')
- except AsException, e:
+ except AsException as e:
if CONTEXT.debug:
traceback.print_exc()
- #self.cr.fatal(_(u'Etape : %s ligne : %r fichier : %r %s'),
- # self.nom, self.appel[0], self.appel[1], e)
- self.cr.fatal(_(u'Command : %s line : %r file : %r %s'),
- tr(self.nom), self.appel[0], self.appel[1], e)
+ self.cr.fatal('Command : %s line : %r file : %r %s' % (tr(self.nom), self.appel[0], self.appel[1], e))
i = 0
for child in self.mc_liste:
i += 1
if i > MAXSIZE:
- print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.mc_liste)))
+ print (MAXSIZE_MSGCHK.format(MAXSIZE, len(self.mc_liste)))
break
self.cr.add(child.report())
return self.cr
# ======================================================================
-class EXCLUS:
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
+
+class EXCLUS(object):
"""
- La règle vérifie qu'un seul mot-clé de self.mcs est present
+ La regle verifie qu'un seul mot-cle de self.mcs est present
parmi les elements de args.
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
+ Ces arguments sont transmis a la regle pour validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
"""
def verif(self, args):
"""
- La methode verif effectue la verification specifique à la règle.
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
+ La methode verif effectue la verification specifique a la regle.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
"""
# on compte le nombre de mots cles presents
text = ''
count = 0
args = self.liste_to_dico(args)
for mc in self.mcs:
- if args.has_key(mc):
+ if mc in args:
count = count + 1
if count > 1:
- text = u"- Il ne faut qu un mot clé parmi : " + `self.mcs`+'\n'
+ text = "- Il ne faut qu un mot cle parmi : " + repr(self.mcs)+'\n'
return text, 0
return text, 1
"""
- Ce module contient la classe mixin JDC qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type JDC
- dérivé de OBJECT.
+ Ce module contient la classe mixin JDC qui porte les methodes
+ necessaires pour realiser la validation d'un objet de type JDC
+ derive de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisee par heritage multiple pour composer les traitements.
"""
+from __future__ import absolute_import
# Modules EFICAS
-import V_MCCOMPO
+from . import V_MCCOMPO
from Noyau.N_Exception import AsException
from Noyau.N_utils import AsType
-from Noyau.strfunc import ufmt
class JDC(V_MCCOMPO.MCCOMPO):
def isvalid(self, cr='non'):
"""
- Méthode booléenne qui retourne 0 si le JDC est invalide, 1 sinon
+ Methode booleenne qui retourne 0 si le JDC est invalide, 1 sinon
"""
- # FR : on prend en compte l'état du JDC ('unchanged','modified','undetermined')
- # afin d'accélérer le test de validité du JDC
+ # FR : on prend en compte l'etat du JDC ('unchanged','modified','undetermined')
+ # afin d'accelerer le test de validite du JDC
if self.state == 'unchanged':
return self.valid
else:
def verif_regles(self):
"""
- Effectue la vérification de validité des règles du jeu de commandes
+ Effectue la verification de validite des regles du jeu de commandes
"""
noms_etapes = [etape.nom for etape in self.etapes]
texte_global = ''
"""
- Ce module contient la classe mixin MACRO_ETAPE qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type MACRO_ETAPE
- dérivé de OBJECT.
+ Ce module contient la classe mixin MACRO_ETAPE qui porte les methodes
+ necessaires pour realiser la validation d'un objet de type MACRO_ETAPE
+ derive de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisee par heritage multiple pour composer les traitements.
"""
+from __future__ import print_function
+from __future__ import absolute_import
# Modules Python
import types
import sys
import traceback
# Modules EFICAS
-import V_MCCOMPO
-import V_ETAPE
+from . import V_MCCOMPO
+from . import V_ETAPE
from Noyau.N_Exception import AsException
from Noyau.N_utils import AsType
-from Noyau.strfunc import ufmt
class MACRO_ETAPE(V_ETAPE.ETAPE):
def isvalid(self, sd='oui', cr='non'):
"""
- Methode pour verifier la validité de l'objet ETAPE. Cette méthode
- peut etre appelée selon plusieurs modes en fonction de la valeur
+ Methode pour verifier la validite de l'objet ETAPE. Cette methode
+ peut etre appelee selon plusieurs modes en fonction de la valeur
de sd et de cr.
- Si cr vaut oui elle crée en plus un compte-rendu.
+ Si cr vaut oui elle cree en plus un compte-rendu.
- Cette méthode a plusieurs fonctions :
+ Cette methode a plusieurs fonctions :
- - mettre à jour l'état de self (update)
+ - mettre a jour l'etat de self (update)
- - retourner un indicateur de validité 0=non, 1=oui
+ - retourner un indicateur de validite 0=non, 1=oui
- produire un compte-rendu : self.cr
"""
if CONTEXT.debug:
- print "ETAPE.isvalid ", self.nom
+ print(("ETAPE.isvalid ", self.nom))
if self.state == 'unchanged':
return self.valid
else:
# Pb: La macro-commande a passe le concept a une commande
# (macro ?) mal definie
if cr == 'oui':
- self.cr.fatal(_(u"Macro-commande mal définie : le concept n'a pas été typé par "
- u"un appel à type_sdprod pour %s"), c.nom)
+ self.cr.fatal("Macro-commande mal definie : le concept n'a pas ete type par un appel a type_sdprod pour %s" % c.nom)
valid = 0
valid = valid * self.valid_child()
if self.reste_val != {}:
if cr == 'oui':
self.cr.fatal(
- #_(u"Mots clés inconnus : %s"), ','.join(self.reste_val.keys()))
- _(u"unknown keyword : %s"), ','.join(self.reste_val.keys()))
+ "unknown keyword : %s" %','.join(list(self.reste_val.keys())))
valid = 0
if sd == "non":
- # Dans ce cas, on ne calcule qu'une validite partielle, on ne modifie pas l'état de self
+ # Dans ce cas, on ne calcule qu'une validite partielle, on ne modifie pas l'etat de self
# on retourne simplement l'indicateur valid
return valid
if self.definition.reentrant == 'n' and self.reuse:
# Il ne peut y avoir de concept reutilise avec une MACRO non
# reentrante
- if cr == 'oui':
- self.cr.fatal(
- _(u'Macro-commande non réentrante : ne pas utiliser reuse'))
+ if cr == 'oui': self.cr.fatal(
+ 'Macro-commande non reentrante : ne pas utiliser reuse')
valid = 0
if valid:
def update_sdprod(self, cr='non'):
"""
- Cette méthode met à jour le concept produit en fonction des conditions initiales :
+ Cette methode met a jour le concept produit en fonction des conditions initiales :
- 1. Il n'y a pas de concept retourné (self.definition.sd_prod == None)
+ 1. Il n'y a pas de concept retourne (self.definition.sd_prod == None)
- 2. Le concept retourné n existait pas (self.sd == None)
+ 2. Le concept retourne n existait pas (self.sd == None)
- 3. Le concept retourné existait. On change alors son type ou on le supprime
+ 3. Le concept retourne existait. On change alors son type ou on le supprime
- En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
+ En cas d'erreur (exception) on retourne un indicateur de validite de 0 sinon de 1
"""
sd_prod = self.definition.sd_prod
- # On memorise le type retourné dans l attribut typret
+ # On memorise le type retourne dans l attribut typret
self.typret = None
if type(sd_prod) == types.FunctionType:
- # Type de concept retourné calculé
+ # Type de concept retourne calcule
d = self.cree_dict_valeurs(self.mc_liste)
try:
# la sd_prod d'une macro a l'objet lui meme en premier argument
- # contrairement à une ETAPE ou PROC_ETAPE
- # Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
- # les concepts produits dans self.sdprods, il faut le mettre à
- # zéro
+ # contrairement a une ETAPE ou PROC_ETAPE
+ # Comme sd_prod peut invoquer la methode type_sdprod qui ajoute
+ # les concepts produits dans self.sdprods, il faut le mettre a
+ # zero
self.sdprods = []
- sd_prod = apply(sd_prod, (self,), d)
+ sd_prod = sd_prod(*(self,), **d)
except:
- # Erreur pendant le calcul du type retourné
+ # Erreur pendant le calcul du type retourne
if CONTEXT.debug:
traceback.print_exc()
self.sd = None
l = traceback.format_exception(sys.exc_info()[0],
sys.exc_info()[1],
sys.exc_info()[2])
- self.cr.fatal(
- _(u'Impossible d affecter un type au résultat\n%s'), ' '.join(l[2:]))
+ self.cr.fatal( 'Impossible d affecter un type au resultat\n%s' % ' '.join(l[2:]))
return 0
# on teste maintenant si la SD est r\351utilis\351e ou s'il faut la
# cr\351er
if AsType(self.reuse) != sd_prod:
if cr == 'oui':
self.cr.fatal(
- _(u'Type de concept réutilisé incompatible avec type produit'))
+ 'Type de concept reutilise incompatible avec type produit')
valid = 0
if self.sdnom != '':
if self.sdnom[0] != '_' and self.reuse.nom != self.sdnom:
# Le nom de la variable de retour (self.sdnom) doit etre le
# meme que celui du concept reutilise (self.reuse.nom)
if cr == 'oui':
- self.cr.fatal(_(u'Concept réutilisé : le nom de la variable de '
- u'retour devrait être %s et non %s'),
- self.reuse.nom, self.sdnom)
+ self.cr.fatal('Concept reutilise : le nom de la variable de retour devrait etre %s et non %s' % (self.reuse.nom, self.sdnom))
valid = 0
if valid:
self.sd = self.reuse
else:
# Cas d'un concept non reutilise
- if sd_prod == None: # Pas de concept retourné
+ if sd_prod == None: # Pas de concept retourne
# Que faut il faire de l eventuel ancien sd ?
self.sd = None
else:
if self.sd:
# Un sd existe deja, on change son type
if CONTEXT.debug:
- print "changement de type:", self.sd, sd_prod
+ print(("changement de type:", self.sd, sd_prod))
if self.sd.__class__ != sd_prod:
self.sd.change_type(sd_prod)
self.typret = sd_prod
else:
- # Le sd n existait pas , on ne le crée pas
+ # Le sd n existait pas , on ne le cree pas
self.typret = sd_prod
if cr == 'oui':
- self.cr.fatal(_(u"Concept retourné non défini"))
+ self.cr.fatal("Concept retourne non defini")
valid = 0
if self.definition.reentrant == 'o':
if cr == 'oui':
self.cr.fatal(
- _(u'Commande obligatoirement réentrante : spécifier reuse=concept'))
+ 'Commande obligatoirement reentrante : specifier reuse=concept')
valid = 0
return valid
"""
- Ce module contient la classe mixin MCBLOC qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type MCBLOC
- dérivé de OBJECT.
+ Ce module contient la classe mixin MCBLOC qui porte les methodes
+ necessaires pour realiser la validation d'un objet de type MCBLOC
+ derive de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisee par heritage multiple pour composer les traitements.
"""
+from __future__ import absolute_import
# Modules EFICAS
-import V_MCCOMPO
-from Noyau.strfunc import ufmt
+from . import V_MCCOMPO
class MCBLOC(V_MCCOMPO.MCCOMPO):
"""
Cette classe a un attribut de classe :
- - txt_nat qui sert pour les comptes-rendus liés à cette classe
+ - txt_nat qui sert pour les comptes-rendus lies a cette classe
"""
txt_nat = u"Bloc :"
def isvalid(self, sd='oui', cr='non'):
"""
- Methode pour verifier la validité du MCBLOC. Cette méthode
- peut etre appelée selon plusieurs modes en fonction de la valeur
+ Methode pour verifier la validite du MCBLOC. Cette methode
+ peut etre appelee selon plusieurs modes en fonction de la valeur
de sd et de cr.
- Si cr vaut oui elle crée en plus un compte-rendu
- sd est présent pour compatibilité de l'interface mais ne sert pas
+ Si cr vaut oui elle cree en plus un compte-rendu
+ sd est present pour compatibilite de l'interface mais ne sert pas
"""
if self.state == 'unchanged':
return self.valid
if not child.isvalid():
valid = 0
break
- # Après avoir vérifié la validité de tous les sous-objets, on vérifie
- # la validité des règles
+ # Apres avoir verifie la validite de tous les sous-objets, on verifie
+ # la validite des regles
text_erreurs, test_regles = self.verif_regles()
if not test_regles:
if cr == 'oui':
- self.cr.fatal(
- _(u"Règle(s) non respectée(s) : %s"), text_erreurs)
+ self.cr.fatal( "Regle(s) non respectee(s) : %s" % text_erreurs)
valid = 0
self.valid = valid
self.state = 'unchanged'
"""
- Ce module contient la classe de base MCCOMPO qui sert à factoriser
+ Ce module contient la classe de base MCCOMPO qui sert a factoriser
les traitements des objets composites de type OBJECT
"""
+from __future__ import print_function
# Modules Python
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
import os
import traceback
from Noyau import MAXSIZE, MAXSIZE_MSGCHK
from Noyau import N_CR
from Noyau.N_Exception import AsException
-from Noyau.strfunc import ufmt, to_unicode
-class MCCOMPO:
+class MCCOMPO(object):
"""
- L'attribut mc_liste a été créé par une classe dérivée de la
+ L'attribut mc_liste a ete cree par une classe derivee de la
classe MCCOMPO du Noyau
"""
def __init__(self):
self.state = 'undetermined'
- # défini dans les classes dérivées
+ # defini dans les classes derivees
self.txt_nat = ''
def init_modif_up(self):
"""
- Propage l'état modifié au parent s'il existe et n'est pas l'objet
+ Propage l'etat modifie au parent s'il existe et n'est pas l'objet
lui-meme
"""
if self.parent and self.parent != self:
def report(self):
"""
- Génère le rapport de validation de self
+ Genere le rapport de validation de self
"""
self.cr = self.CR()
self.cr.debut = self.txt_nat + self.nom
- #self.cr.fin = u"Fin " + self.txt_nat + self.nom
- self.cr.fin = u"END " + self.txt_nat + self.nom
+ self.cr.fin = "END " + self.txt_nat + self.nom
i = 0
for child in self.mc_liste:
i += 1
self.state = 'modified'
try:
self.isvalid(cr='oui')
- except AsException, e:
+ except AsException as e:
if CONTEXT.debug:
traceback.print_exc()
self.cr.fatal(' '.join((self.txt_nat, self.nom, str(e))))
def verif_regles(self):
"""
- A partir du dictionnaire des mots-clés présents, vérifie si les règles
+ A partir du dictionnaire des mots-cles presents, verifie si les regles
de self sont valides ou non.
- Retourne une chaine et un booléen :
+ Retourne une chaine et un booleen :
- - texte = la chaine contient le message d'erreur de la (les) règle(s) violée(s) ('' si aucune)
+ - texte = la chaine contient le message d'erreur de la (les) regle(s) violee(s) ('' si aucune)
- - testglob = booléen 1 si toutes les règles OK, 0 sinon
+ - testglob = booleen 1 si toutes les regles OK, 0 sinon
"""
- # On verifie les regles avec les defauts affectés
+ # On verifie les regles avec les defauts affectes
dictionnaire = self.dict_mc_presents(restreint='non')
texte = ['']
testglob = 1
erreurs, test = r.verif(dictionnaire)
testglob = testglob * test
if erreurs != '':
- texte.append(to_unicode(erreurs))
+ texte.append(str(erreurs))
texte = os.linesep.join(texte)
return texte, testglob
def dict_mc_presents(self, restreint='non'):
"""
- Retourne le dictionnaire {mocle : objet} construit à partir de self.mc_liste
- Si restreint == 'non' : on ajoute tous les mots-clés simples du catalogue qui ont
- une valeur par défaut
- Si restreint == 'oui' : on ne prend que les mots-clés effectivement entrés par
- l'utilisateur (cas de la vérification des règles)
+ Retourne le dictionnaire {mocle : objet} construit a partir de self.mc_liste
+ Si restreint == 'non' : on ajoute tous les mots-cles simples du catalogue qui ont
+ une valeur par defaut
+ Si restreint == 'oui' : on ne prend que les mots-cles effectivement entres par
+ l'utilisateur (cas de la verification des regles)
"""
dico = {}
- # on ajoute les couples {nom mot-clé:objet mot-clé} effectivement
- # présents
+ # on ajoute les couples {nom mot-cle:objet mot-cle} effectivement
+ # presents
for v in self.mc_liste:
if v == None:
continue
if restreint == 'oui':
return dico
# Si restreint != 'oui',
- # on ajoute les couples {nom mot-clé:objet mot-clé} des mots-clés simples
- # possibles pour peu qu'ils aient une valeur par défaut
- for k, v in self.definition.entites.items():
+ # on ajoute les couples {nom mot-cle:objet mot-cle} des mots-cles simples
+ # possibles pour peu qu'ils aient une valeur par defaut
+ for k, v in list(self.definition.entites.items()):
if v.label != 'SIMP':
continue
if not v.defaut:
continue
- if not dico.has_key(k):
+ if not k in dico :
dico[k] = v(nom=k, val=None, parent=self)
# on ajoute l'objet detenteur de regles pour des validations plus
# sophistiquees (a manipuler avec precaution)
"""
- Ce module contient la classe mixin MCFACT qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type MCFACT
- dérivé de OBJECT.
+ Ce module contient la classe mixin MCFACT qui porte les methodes
+ necessaires pour realiser la validation d'un objet de type MCFACT
+ derive de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisee par heritage multiple pour composer les traitements.
"""
+from __future__ import absolute_import
# Modules EFICAS
-import V_MCCOMPO
-from Noyau.strfunc import ufmt
+from . import V_MCCOMPO
class MCFACT(V_MCCOMPO.MCCOMPO):
"""
Cette classe a un attribut de classe :
- - txt_nat qui sert pour les comptes-rendus liés à cette classe
+ - txt_nat qui sert pour les comptes-rendus lies a cette classe
"""
- txt_nat = u"Mot clé Facteur :"
+ txt_nat = "Mot cle Facteur :"
def isvalid(self, sd='oui', cr='non'):
"""
- Methode pour verifier la validité du MCFACT. Cette méthode
- peut etre appelée selon plusieurs modes en fonction de la valeur
+ Methode pour verifier la validite du MCFACT. Cette methode
+ peut etre appelee selon plusieurs modes en fonction de la valeur
de sd et de cr.
- Si cr vaut oui elle crée en plus un compte-rendu
- sd est présent pour compatibilité de l'interface mais ne sert pas
+ Si cr vaut oui elle cree en plus un compte-rendu
+ sd est present pour compatibilite de l'interface mais ne sert pas
"""
if self.state == 'unchanged':
return self.valid
if not child.isvalid():
valid = 0
break
- # Après avoir vérifié la validité de tous les sous-objets, on vérifie
- # la validité des règles
+ # Apres avoir verifie la validite de tous les sous-objets, on verifie
+ # la validite des regles
text_erreurs, test_regles = self.verif_regles()
if not test_regles:
if cr == 'oui':
- self.cr.fatal(
- _(u"Règle(s) non respectée(s) : %s"), text_erreurs)
+ self.cr.fatal("Regle(s) non respectee(s) : %s" % text_erreurs)
valid = 0
#
# On verifie les validateurs s'il y en a
#
if self.definition.validators and not self.definition.validators.verif(self.valeur):
if cr == 'oui':
- #self.cr.fatal(_(u"Mot-clé : %s devrait avoir %s"),
- # self.nom, self.definition.validators.info())
- self.cr.fatal(_(u"Keyword : %s should have %s"),
- self.nom, self.definition.validators.info())
+ self.cr.fatal("Keyword : %s should have %s" %( self.nom, self.definition.validators.info()))
valid = 0
# fin des validateurs
#
if self.reste_val != {}:
if cr == 'oui':
- self.cr.fatal(
- #_(u"Mots clés inconnus : %s"), ','.join(self.reste_val.keys()))
- _(u"unknow keyword : %s"), ','.join(self.reste_val.keys()))
+ self.cr.fatal("unknow keyword : %s" % ','.join(list(self.reste_val.keys())))
valid = 0
self.valid = valid
self.state = 'unchanged'
"""
- Ce module contient la classe mixin MCList qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type MCList
- dérivé de OBJECT.
+ Ce module contient la classe mixin MCList qui porte les methodes
+ necessaires pour realiser la validation d'un objet de type MCList
+ derive de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisee par heritage multiple pour composer les traitements.
"""
# Modules Python
+from __future__ import print_function
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
+
import traceback
# Modules EFICAS
+from Extensions.i18n import tr
from Noyau import MAXSIZE, MAXSIZE_MSGCHK
from Noyau import N_CR
from Noyau.N_Exception import AsException
-from Noyau.strfunc import ufmt
-class MCList:
+class MCList(object):
"""
Cette classe a deux attributs de classe :
- - CR qui sert à construire l'objet compte-rendu
+ - CR qui sert a construire l'objet compte-rendu
- - txt_nat qui sert pour les comptes-rendus liés à cette classe
+ - txt_nat qui sert pour les comptes-rendus lies a cette classe
"""
CR = N_CR.CR
- txt_nat = u"Mot clé Facteur Multiple :"
+ txt_nat = "Mot cle Facteur Multiple :"
def isvalid(self, cr='non'):
"""
- Methode pour verifier la validité du MCList. Cette méthode
- peut etre appelée selon plusieurs modes en fonction de la valeur
+ Methode pour verifier la validite du MCList. Cette methode
+ peut etre appelee selon plusieurs modes en fonction de la valeur
de cr.
- Si cr vaut oui elle crée en plus un compte-rendu.
+ Si cr vaut oui elle cree en plus un compte-rendu.
- On n'utilise pas d'attribut pour stocker l'état et on ne remonte pas
- le changement d'état au parent (pourquoi ??)
+ On n'utilise pas d'attribut pour stocker l'etat et on ne remonte pas
+ le changement d'etat au parent (pourquoi ??)
MCLIST est une liste de MCFACT. Les MCFACT ont le meme parent
que le MCLIST qui les contient. Il n'est donc pas necessaire de
remonter le changement d'etat au parent. C'est deja fait
if definition.min is not None and len(self.data) < definition.min:
valid = 0
if cr == 'oui':
- self.cr.fatal(
- _(u"Nombre de mots clés facteurs insuffisant minimum : %s"),
- definition.min)
+ self.cr.fatal( "Nombre de mots cles facteurs insuffisant minimum : %s" % definition.min)
if definition.max is not None and len(self.data) > definition.max:
valid = 0
if cr == 'oui':
self.cr.fatal(
- _(u"Nombre de mots clés facteurs trop grand maximum : %s"),
- definition.max)
+ "Nombre de mots cles facteurs trop grand maximum : %s" % definition.max)
num = 0
for i in self.data:
num = num + 1
if not i.isvalid():
valid = 0
if cr == 'oui' and len(self) > 1:
- self.cr.fatal(
- _(u"L'occurrence numéro %d du mot-clé facteur : %s n'est pas valide"),
- num, self.nom)
+ self.cr.fatal( "L'occurrence numero %d du mot-cle facteur : %s n'est pas valide" % (num, self.nom))
return valid
def report(self):
"""
- Génère le rapport de validation de self
+ Genere le rapport de validation de self
"""
if len(self) > 1:
# Mot cle facteur multiple
- self.cr = self.CR(
- debut=u"Mot-clé facteur multiple : " + self.nom,
- fin=u"Fin Mot-clé facteur multiple : " + self.nom)
+ self.cr = self.CR( debut="Mot-cle facteur multiple : " + tr(self.nom),
+ fin="Fin Mot-cle facteur multiple : " + tr(self.nom))
j = 0
for i in self.data:
j += 1
if j > MAXSIZE:
- print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.data)))
+ print (MAXSIZE_MSGCHK.format(MAXSIZE, len(self.data)))
break
self.cr.add(i.report())
elif len(self) == 1:
# Mot cle facteur non multiple
self.cr = self.data[0].report()
else:
- self.cr = self.CR(debut=u"Mot-clé facteur : " + self.nom,
- fin=u"Fin Mot-clé facteur : " + self.nom)
+ self.cr = self.CR(debut="Mot-cle facteur : " + tr(self.nom) ,
+ fin="Fin Mot-cle facteur : " + tr(self.nom))
try:
self.isvalid(cr='oui')
- except AsException, e:
+ except AsException as e:
if CONTEXT.debug:
traceback.print_exc()
- self.cr.fatal(_(u"Mot-clé facteur multiple : %s, %s"), self.nom, e)
+ self.cr.fatal(" %s Mot-cle facteur multiple : %s" %( self.nom, e))
return self.cr
# ======================================================================
"""
- Ce module contient la classe mixin MCSIMP qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type MCSIMP
- dérivé de OBJECT.
+ Ce module contient la classe mixin MCSIMP qui porte les methodes
+ necessaires pour realiser la validation d'un objet de type MCSIMP
+ derive de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisee par heritage multiple pour composer les traitements.
"""
# Modules Python
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except : pass
import traceback
# Modules EFICAS
from Noyau.N_Exception import AsException
from Noyau.N_VALIDATOR import ValError, TypeProtocol, CardProtocol, IntoProtocol
from Noyau.N_VALIDATOR import listProto
-from Noyau.strfunc import ufmt
from Extensions.i18n import tr
-class MCSIMP:
+class MCSIMP(object):
"""
COMMENTAIRE CCAR:
- Cette classe est quasiment identique à la classe originale d'EFICAS
- a part quelques changements cosmétiques et des chagements pour la
- faire fonctionner de facon plus autonome par rapport à l'environnement
+ Cette classe est quasiment identique a la classe originale d'EFICAS
+ a part quelques changements cosmetiques et des chagements pour la
+ faire fonctionner de facon plus autonome par rapport a l'environnement
EFICAS
- A mon avis, il faudrait aller plus loin et réduire les dépendances
- amont au strict nécessaire.
+ A mon avis, il faudrait aller plus loin et reduire les dependances
+ amont au strict necessaire.
- - Est il indispensable de faire l'évaluation de la valeur dans le contexte
+ - Est il indispensable de faire l'evaluation de la valeur dans le contexte
du jdc dans cette classe.
- - Ne pourrait on pas doter les objets en présence des méthodes suffisantes
- pour éviter les tests un peu particuliers sur GEOM, PARAMETRE et autres. J'ai
- d'ailleurs modifié la classe pour éviter l'import de GEOM
+ - Ne pourrait on pas doter les objets en presence des methodes suffisantes
+ pour eviter les tests un peu particuliers sur GEOM, PARAMETRE et autres. J'ai
+ d'ailleurs modifie la classe pour eviter l'import de GEOM
"""
CR = N_CR.CR
def isvalid(self, cr='non'):
"""
- Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP
+ Cette methode retourne un indicateur de validite de l'objet de type MCSIMP
- 0 si l'objet est invalide
- 1 si l'objet est valide
- Le paramètre cr permet de paramétrer le traitement. Si cr == 'oui'
- la méthode construit également un comte-rendu de validation
- dans self.cr qui doit avoir été créé préalablement.
+ Le parametre cr permet de parametrer le traitement. Si cr == 'oui'
+ la methode construit egalement un comte-rendu de validation
+ dans self.cr qui doit avoir ete cree prealablement.
"""
if self.state == 'unchanged':
return self.valid
valid = 1
v = self.valeur
# verification presence
- if self.isoblig() and v == None:
+ if self.isoblig() and (v == None or v == "" ):
if cr == 'oui':
- self.cr.fatal(
- _(u"Mandatory keyword : %s has no value"), tr(self.nom))
- #_(u"Mot-clé : %s obligatoire non valorisé"), self.nom)
+ self.cr.fatal( "Mandatory keyword : %s has no value" % tr(self.nom))
valid = 0
lval = listProto.adapt(v)
if lval is None:
valid = 0
if cr == 'oui':
- self.cr.fatal(_(u"None is not a valid value"))
- #self.cr.fatal(_(u"None n'est pas une valeur autorisée"))
+ self.cr.fatal("None is not a valid value")
else:
# type,into ...
# typeProto=TypeProtocol("type",typ=self.definition.type)
intoProto = self.intoProto
cardProto = self.cardProto
if cr == 'oui':
- # un cr est demandé : on collecte tous les types d'erreur
+ # un cr est demande : on collecte tous les types d'erreur
try:
for val in lval:
typeProto.adapt(val)
- except ValError, e:
+ except ValError as e:
valid = 0
- self.cr.fatal(*e)
+ self.cr.fatal(str(e))
try:
for val in lval:
intoProto.adapt(val)
- except ValError, e:
+ except ValError as e:
valid = 0
- self.cr.fatal(*e)
+ self.cr.fatal(str(e))
try:
cardProto.adapt(lval)
- except ValError, e:
+ except ValError as e:
valid = 0
- self.cr.fatal(*e)
+ self.cr.fatal(str(e))
#
# On verifie les validateurs s'il y en a et si necessaire (valid == 1)
#
if valid and self.definition.validators:
try:
self.definition.validators.convert(lval)
- except ValError, e:
+ except ValError as e:
self.cr.fatal(
- #_(u"Mot-clé %s invalide : %s\nCritère de validité: %s"),
- _(u"invalid keyword %s : %s\nCriteria : %s"),
- tr(self.nom), str(e), self.definition.validators.info())
+ "invalid keyword %s : %s\nCriteria : %s" % (tr(self.nom)), str(e), self.definition.validators.info())
valid = 0
else:
# si pas de cr demande, on sort a la toute premiere erreur
if hasattr(self.definition.validators, 'set_MCSimp'):
self.definition.validators.set_MCSimp(self)
self.definition.validators.convert(lval)
- except ValError, e:
+ except ValError as e:
valid = 0
self.set_valid(valid)
return self.valid
def isoblig(self):
- """ indique si le mot-clé est obligatoire
+ """ indique si le mot-cle est obligatoire
"""
return self.definition.statut == 'o'
def init_modif_up(self):
"""
- Propage l'état modifié au parent s'il existe et n'est l'objet
+ Propage l'etat modifie au parent s'il existe et n'est l'objet
lui-meme
"""
if self.parent and self.parent != self:
self.parent.state = 'modified'
def report(self):
- """ génère le rapport de validation de self """
+ """ genere le rapport de validation de self """
self.cr = self.CR()
- #self.cr.debut = u"Mot-clé simple : " + self.nom
- self.cr.debut = u"Simple Keyword : " + tr(self.nom)
- #self.cr.fin = u"Fin Mot-clé simple : " + self.nom
- self.cr.fin = u"End Simple Keyword: " + tr(self.nom)
+ self.cr.debut = "Simple Keyword : " + tr(self.nom)
+ self.cr.fin = "End Simple Keyword: " + tr(self.nom)
self.state = 'modified'
try:
self.isvalid(cr='oui')
- except AsException, e:
+ except AsException as e:
if CONTEXT.debug:
traceback.print_exc()
- #self.cr.fatal(_(u"Mot-clé simple : %s %s"), self.nom, e)
- self.cr.fatal(_(u"Simple Keyword : %s %s"), tr(self.nom), e)
+ self.cr.fatal("Simple Keyword : %s %s" % (tr(self.nom), e))
return self.cr
# person_in_charge: mathieu.courtois at edf.fr
-class MEME_NOMBRE:
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
+
+class MEME_NOMBRE(object):
"""
- La règle MEME_NOMBRE vérifie que l'on trouve au moins un des mots-clés
- de la règle parmi les arguments d'un OBJECT.
+ La regle MEME_NOMBRE verifie que l'on trouve au moins un des mots-cles
+ de la regle parmi les arguments d'un OBJECT.
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
+ Ces arguments sont transmis a la regle pour validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
"""
def verif(self, args):
"""
- La méthode verif vérifie que l'on trouve au moins un des mos-clés
- de la liste self.mcs parmi les éléments de args
+ La methode verif verifie que l'on trouve au moins un des mos-cles
+ de la liste self.mcs parmi les elements de args
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
"""
# on compte le nombre de mots cles presents
text = ''
size = -1
for mc in self.mcs:
- if mc not in args.keys():
- text = u"Une clé dans la règle n'existe pas %s" % mc
+ if mc not in args:
+ text = "Une cle dans la regle n'existe pas %s" % mc
return text, 0
val = args[mc].valeur
if size == -1:
size = len_val
elif size != len_val:
- text = u"Pas la même longeur"
+ text = "Pas la même longeur"
return text, 0
return text, 1
# ======================================================================
-class PRESENT_ABSENT:
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
+
+class PRESENT_ABSENT(object):
"""
- La règle vérifie que si le premier mot-clé de self.mcs est present
- parmi les elements de args les autres mots clés de self.mcs
+ La regle verifie que si le premier mot-cle de self.mcs est present
+ parmi les elements de args les autres mots cles de self.mcs
doivent etre absents
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
+ Ces arguments sont transmis a la regle pour validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
"""
def verif(self, args):
"""
- La methode verif effectue la verification specifique à la règle.
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
+ La methode verif effectue la verification specifique a la regle.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
"""
# on verifie que si le premier de la liste est present,
# les autres sont absents
test = 1
args = self.liste_to_dico(args)
mc0 = self.mcs[0]
- if args.has_key(mc0):
+ if mc0 in args :
for mc in self.mcs[1:len(self.mcs)]:
- if args.has_key(mc):
- text = text + u"- Le mot clé " + `mc0`+ u" étant présent, il faut que : " +\
+ if mc in args :
+ text = text + "- Le mot cle " + repr(mc0)+ " etant present, il faut que : " +\
mc + " soit absent" + '\n'
test = 0
return text, test
# ======================================================================
-class PRESENT_PRESENT:
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
+
+class PRESENT_PRESENT(object):
"""
- La règle vérifie que si le premier mot-clé de self.mcs est present
+ La regle verifie que si le premier mot-cle de self.mcs est present
parmi les elements de args les autres doivent l'etre aussi
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
+ Ces arguments sont transmis a la regle pour validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
"""
def verif(self, args):
"""
- La methode verif effectue la verification specifique à la règle.
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
+ La methode verif effectue la verification specifique a la regle.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
"""
# on verifie que si le premier de la liste est present,
# les autres le sont aussi
text = ''
test = 1
args = self.liste_to_dico(args)
- if args.has_key(mc0):
+ if mc0 in args :
for mc in self.mcs[1:len(self.mcs)]:
- if not args.has_key(mc):
- text = text + u"- Le mot clé " + `mc0`+ \
- u" étant présent, il faut que : " + \
- mc + u" soit présent" + '\n'
+ if not mc in args :
+ text = text + "- Le mot cle " + repr(mc0)+ \
+ " etant present, il faut que : " + \
+ mc + " soit present" + '\n'
test = 0
return text, test
# ======================================================================
"""
- Ce module contient la classe mixin PROC_ETAPE qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type PROC_ETAPE
- dérivé de OBJECT.
+ Ce module contient la classe mixin PROC_ETAPE qui porte les methodes
+ necessaires pour realiser la validation d'un objet de type PROC_ETAPE
+ derive de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisee par heritage multiple pour composer les traitements.
"""
+from __future__ import print_function
+from __future__ import absolute_import
# Modules EFICAS
-import V_ETAPE
+from . import V_ETAPE
from Noyau.N_Exception import AsException
from Noyau.N_utils import AsType
-from Noyau.strfunc import ufmt
from Extensions.i18n import tr
class PROC_ETAPE(V_ETAPE.ETAPE):
"""
- On réutilise les méthodes report,verif_regles
- de ETAPE par héritage.
+ On reutilise les methodes report,verif_regles
+ de ETAPE par heritage.
"""
def isvalid(self, sd='oui', cr='non'):
"""
- Methode pour verifier la validité de l'objet PROC_ETAPE. Cette méthode
- peut etre appelée selon plusieurs modes en fonction de la valeur
- de sd et de cr (sd n'est pas utilisé).
+ Methode pour verifier la validite de l'objet PROC_ETAPE. Cette methode
+ peut etre appelee selon plusieurs modes en fonction de la valeur
+ de sd et de cr (sd n'est pas utilise).
- Si cr vaut oui elle crée en plus un compte-rendu.
+ Si cr vaut oui elle cree en plus un compte-rendu.
- Cette méthode a plusieurs fonctions :
+ Cette methode a plusieurs fonctions :
- - retourner un indicateur de validité 0=non, 1=oui
+ - retourner un indicateur de validite 0=non, 1=oui
- produire un compte-rendu : self.cr
- - propager l'éventuel changement d'état au parent
+ - propager l'eventuel changement d'etat au parent
"""
if CONTEXT.debug:
- print "ETAPE.isvalid ", self.nom
+ print(("ETAPE.isvalid ", self.nom))
if self.state == 'unchanged':
return self.valid
else:
if self.reste_val != {}:
if cr == 'oui':
self.cr.fatal(
- #_(tr(u"Mots clefs inconnus : %s")), ','.join(self.reste_val.keys()))
- _(tr(u"unknown keywords : %s")), ','.join(self.reste_val.keys()))
+ tr("unknown keywords : %s") % ','.join(list(self.reste_val.keys())))
valid = 0
self.set_valid(valid)
return self.valid
# ======================================================================
-class UN_PARMI:
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
+
+class UN_PARMI(object):
"""
- La règle vérifie que l'on trouve un des mots-clés
- de la règle parmi les arguments d'un OBJECT.
+ La regle verifie que l'on trouve un des mots-cles
+ de la regle parmi les arguments d'un OBJECT.
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
+ Ces arguments sont transmis a la regle pour validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
"""
def verif(self, args):
"""
- La méthode verif vérifie que l'on trouve un des mos-clés
- de la liste self.mcs parmi les éléments de args
+ La methode verif verifie que l'on trouve un des mos-cles
+ de la liste self.mcs parmi les elements de args
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
"""
# on compte le nombre de mots cles presents
text = ''
count = 0
args = self.liste_to_dico(args)
for mc in self.mcs:
- if args.has_key(mc):
+ if mc in args :
count = count + 1
if count != 1:
- text = u"- Il faut un et un seul mot-clé parmi : " + \
- `self.mcs`+'\n'
+ text = "- Il faut un et un seul mot-cle parmi : " + \
+ repr(self.mcs)+'\n'
return text, 0
return text, 1
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce package contient tous les convertisseurs de formats d'entrée
- en objets compréhensibles par EFICAS.
+ Ce package contient tous les convertisseurs de formats d'entree
+ en objets comprehensibles par EFICAS.
- Ces convertisseurs sont implémentés sous forme de plugins
+ Ces convertisseurs sont implementes sous forme de plugins
"""
+from __future__ import absolute_import
from Extensions import pluginloader
import convert
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import sys,string,re,tokenize
-import cStringIO
-
-
-class ENTITE_JDC :
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from future import standard_library
+ standard_library.install_aliases()
+except :
+ pass
+try :
+ from builtins import str
+except :
+ pass
+from builtins import object
+import sys,re,tokenize
+import io
+
+
+class ENTITE_JDC(object) :
def __init__(self):
self.texte = ''
def __str__(self):
"""
- Retourne une chaîne de caractères représentant self
- sous une forme interprétable par EFICAS
+ Retourne une chaine de caracteres representant self
+ sous une forme interpretable par EFICAS
"""
t=repr(self.texte)
return "COMMENTAIRE(u"+t+")\n"
def append_text(self,texte):
"""
- Ajoute texte à self.texte en enlevant le # initial
+ Ajoute texte a 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 #
+ # le diese n'est pas sur le premier caractere
+ amont,aval = texte.split('#',1) # on decoupe suivant la premiere 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
+ Ajoute texte a 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
+ Retourne une expression de l'affectation comprehensible par ACCAS
et exploitable par EFICAS
"""
#t=repr(self.texte)
def append_text(self,texte):
"""
- Ajoute texte à self.texte en enlevant les doubles commentaires
+ Ajoute texte a self.texte en enlevant les doubles commentaires
"""
- texte = string.strip(texte)
- texte = string.strip(texte[2:])
+ texte = texte.strip()
+ texte = texte[2:].strip()
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
+ Retourne une expression de la commande commentarisee comprehensible par ACCAS
et exploitable par EFICAS
"""
return "COMMANDE_COMM(texte="+repr(self.texte)+")\n"
next['end'] = ()
start = 'if', 'while', 'for', 'try', 'def', 'class'
-class PARSEUR_PYTHON:
+class PARSEUR_PYTHON(object):
"""
- Cette classe sert à créer un objet PARSEUR_PYTHON qui réalise l'analyse d'un texte
- représentant un JDC Python en distinguant :
+ Cette classe sert a creer un objet PARSEUR_PYTHON qui realise l'analyse d'un texte
+ representant un JDC Python en distinguant :
- les commentaires inter commandes
- les affectations
- les commandes
"""
- # au moins 1 caractère non blanc ou non tabulation
+ # au moins 1 caractere 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(
def __init__(self,texte):
# on verifie que le texte fourni se compile correctement
compile(texte,"<string>",'exec')
- self.texte = cStringIO.StringIO(texte)
+ self.texte = io.StringIO(texte)
self.line=''
self.out=""
self.lastcol = 0
def NL(self, tstring):
if self.affectation:
if self.paren_level == 0:
- # affectation en cours mais complète
+ # affectation en cours mais complete
self.out= self.out+ str(self.affectation_courante)
self.affectation_courante=None
self.please_indent=1
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
+ # il s'agit d'une commande commentarisee
if self.objet_courant == None:
if not self.buffer:self.buffer_indent=self.indent_list[-1]
self.objet_courant=COMMANDE_COMMENTARISEE()
else:
# On a un commentaire simple
- new_line = string.split(self.line,'#')[0]
+ new_line = self.line.split('#')[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
+ # commentaire precede de blancs
if self.objet_courant == None:
if not self.buffer:self.buffer_indent=self.indent_list[-1]
self.objet_courant=COMMENTAIRE()
return
def ERRORTOKEN(self, tstring):
- print ("ERRORTOKEN", tstring)
+ print("ERRORTOKEN", tstring)
def NAME(self, tstring):
if self.buffer:
if __name__ == "__main__" :
import sys
- import cStringIO
+ import io
text="""
#
# comment
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import re, string
+from __future__ import absolute_import
+
+
+import re
from Extensions.i18n import tr
-from convert_python import PythonParser
+from .convert_python import PythonParser
+import six
+from six.moves import range
+try:
+ basestring
+except NameError:
+ basestring = str
pattern_comment_slash = re.compile(r"^\s*/")
pattern_eta = re.compile(r".*&ETA.*")
from Extensions import localisation
-from determine import monEnvQT5
-
def entryPoint():
Return a dictionary containing the description needed to load the plugin
"""
return {
- 'name' : 'TELEMAC3',
+ 'name' : 'TELEMAC',
'factory' : TELEMACParser
}
if appli.langue=='fr' :
from enumDicoTelemac import DicoEnumCasFrToEnumCasEn
- for k in DicoEnumCasFrToEnumCasEn.keys() :
+ for k in DicoEnumCasFrToEnumCasEn :
TelemacdicoEn[k]=DicoEnumCasFrToEnumCasEn[k]
text=""
self.dictSimp={}
- l_lignes_texte_all = string.split(self.text,'\n')
+ l_lignes_texte_all = self.text.split('\n')
l_lignes_texte = []
for l in l_lignes_texte_all :
if not(pattern_comment_slash.match(l)): l_lignes_texte.append(l)
finLigne=m.group('reste')
self.dictSimp[simpCas]=valeur
- if 'TITLE' not in self.dictSimp.keys() :
+ if 'TITLE' not in self.dictSimp :
import os
#self.dictSimp['TITLE']=os.path.basename(self.filename)
dicoParMC={}
- for simp in self.dictSimp.keys():
- if simp in TELEMACParser.__dict__.keys() : apply(TELEMACParser.__dict__[simp],(self,))
+ for simp in self.dictSimp:
+ if simp in TELEMACParser.__dict__ : TELEMACParser.__dict__[simp],(self,)
- for simp in self.dictSimp.keys():
+ for simp in self.dictSimp:
if simp in ListeSupprimeCasToEficas: continue
- if simp not in self.dicoInverse.keys() :
+ if simp not in self.dicoInverse :
#print ( "************")
print ("pb avec dans dicoInverse", simp,'------')
#print ("************")
while i < len(listeGeneaReverse[0:-1]) :
mot=listeGeneaReverse[i]
i=i+1
- if mot not in dicoTravail.keys(): dicoTravail[mot]={}
+ if mot not in dicoTravail: dicoTravail[mot]={}
dicoTravail=dicoTravail[mot]
dicoTravail[simp]=self.dictSimp[simp]
self.textePy=""
- listeMC=self.tri(dicoParMC.keys())
+ listeMC=self.tri(list(dicoParMC.keys()))
for k in listeMC :
self.textePy += str(k )+ "("
self.traiteMC(dicoParMC[k])
self.textePy += ");\n"
- appli.listeTelemac=self.dictSimp.keys()
+ appli.listeTelemac=self.dictSimp
return self.textePy
def traiteMC(self,dico) :
from Accas import A_BLOC, A_FACT, A_SIMP
- for k in dico.keys() :
+ for k in dico :
valeur= dico[k]
- if k not in self.dicoMC.keys() : kA=self.dicoFrancaisAnglais[k]
+ if k not in self.dicoMC : kA=self.dicoFrancaisAnglais[k]
else : kA=k
obj=self.dicoMC[kA]
if isinstance(obj,A_FACT.FACT): self.convertFACT(obj,kA,valeur)
def convertFACT(self,obj,nom,valeur):
- if nom in TELEMACParser.__dict__.keys() :
- apply(TELEMACParser.__dict__[nom],(self,))
+ if nom in TELEMACParser.__dict__ :
+ TELEMACParser.__dict__[nom],(self,)
return
self.textePy += nom + "=_F( "
self.traiteMC(valeur)
try : valeur=eval(valeur,{})
except : pass
- if nom in TelemacdicoEn.keys():
+ if nom in TelemacdicoEn:
try :
valeur=TelemacdicoEn[nom][valeur]
self.textePy += nom + "= '" + str(valeur) +"',"
# Attention : on attend une liste mais on a une seule valeur!
try : oldValeur=eval(oldValeur,{})
except : pass
- if nom in TelemacdicoEn.keys() :
+ if nom in TelemacdicoEn :
v=TelemacdicoEn[nom][oldValeur]
self.textePy += nom + "= ('" + str(v) +"',),"
else :
for v in valeur :
try : v=eval(v,{})
except : pass
- if nom in TelemacdicoEn.keys():
+ if nom in TelemacdicoEn:
try : v=TelemacdicoEn[nom][v]
except : pass
newVal.append(v)
def LIQUID_BOUNDARIES(self):
texte_Boundaries="LIQUID_BOUNDARIES=( "
- if 'PRESCRIBED_ELEVATIONS' in self.dictSimp.keys():
+ if 'PRESCRIBED_ELEVATIONS' in self.dictSimp:
valeursPE=self.dictSimp["PRESCRIBED_ELEVATIONS"]
if not type(valeursPE)==list : valeursPE = (valeursPE,)
longueur=len(self.dictSimp["PRESCRIBED_ELEVATIONS"])
else : valeursPE=None
- if 'PRESCRIBED_FLOWRATES' in self.dictSimp.keys():
+ if 'PRESCRIBED_FLOWRATES' in self.dictSimp:
valeursPF=self.dictSimp["PRESCRIBED_FLOWRATES"]
if not type(valeursPF)==list : valeursPF = (valeursPF,)
longueur=len(self.dictSimp["PRESCRIBED_FLOWRATES"])
else : valeursPF=None
- if 'PRESCRIBED_VELOCITIES' in self.dictSimp.keys():
+ if 'PRESCRIBED_VELOCITIES' in self.dictSimp:
valeursPV=self.dictSimp["PRESCRIBED_VELOCITIES"]
if not type(valeursPV)==list : valeursPV = (valeursPV,)
longueur=len(self.dictSimp["PRESCRIBED_VELOCITIES"])
"""
"""
-import parseur_python
-from convert_python import *
+from __future__ import absolute_import
+from .convert_python import PythonParser
def entryPoint():
"""
Ce convertisseur supporte le format de sortie dict
"""
-import sys,string,traceback
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except :
+ pass
+
+import sys,traceback
from Noyau import N_CR
from Extensions.i18n import tr
}
-class PythParser:
+class PythParser(object):
"""
Ce convertisseur lit un fichier au format pyth avec la
methode readfile : convertisseur.readfile(nom_fichier)
return
self.g={}
try:
- exec self.text in self.g
+ exec(self.text, self.g)
except EficasException as e:
l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
- s= string.join(l[2:])
- s= string.replace(s,'"<string>"','"<%s>"'%self.filename)
+ s= ''.join(l[2:])
+ s= s.replace('"<string>"','"<%s>"'%self.filename)
self.cr.fatal(tr("Erreur a l'evaluation :\n %s", s))
def convert(self,outformat,appli=None):
def getdict(self):
d={}
- for k,v in self.g.items():
+ for k,v in list(self.g.items()):
if k[0] != '_':d[k]=v
return d
Ce convertisseur supporte le format de sortie exec
"""
-import sys,string,traceback
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except :
+ pass
+import sys,traceback
-import parseur_python
+from .parseur_python import PARSEUR_PYTHON
from Noyau import N_CR
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
}
-class PythonParser:
+class PythonParser(object):
"""
Ce convertisseur lit un fichier au format python avec la
methode readfile : convertisseur.readfile(nom_fichier)
def convert(self,outformat,appli=None):
if outformat == 'exec':
try:
- return parseur_python.PARSEUR_PYTHON(self.text).get_texte(appli)
+ #return parseur_python.PARSEUR_PYTHON(self.text).get_texte(appli)
+ return PARSEUR_PYTHON(self.text).get_texte(appli)
except EficasException:
# Erreur lors de la conversion
l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],
sys.exc_info()[2])
self.cr.exception(tr("Impossible de convertir le fichier Python qui doit contenir des erreurs.\n\
- On retourne le fichier non converti. Prevenir la maintenance.\n\n %s", string.join(l)))
+ On retourne le fichier non converti. Prevenir la maintenance.\n\n %s", ''.join(l)))
# On retourne neanmoins le source initial non converti (au cas ou)
return self.text
elif outformat == 'execnoparseur':
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+ from builtins import object
+except :
+ pass
import sys,string,re
import traceback
from Extensions.i18n import tr
+from six.moves import range
escapedQuotesRE = re.compile(r"(\\\\|\\\"|\\\')")
stringsAndCommentsRE = \
re.compile(u"(\"\"\".*?\"\"\"|'''.*?'''|\"[^\"]*\"|\'[^\']*\'|#.*?\n)", re.DOTALL)
#stringsAndCommentsRE = \
# re.compile(u"(\"\"\".*\"\"\"|'''.*'''|\"[^\"]*\"|\'[^\']*\'|#.*\n)", re.DOTALL)
-allchars = string.maketrans(u"", "")
-allcharsExceptNewline = allchars[: allchars.index('\n')]+allchars[allchars.index('\n')+1:]
-allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))
+import six
+if six.PY2 :
+ allchars = string.maketrans(u"", "")
+ allcharsExceptNewline = allchars[: allchars.index('\n')]+allchars[allchars.index('\n')+1:]
+ allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))
+else :
+ allchars=bytes.maketrans(b"",b"")
+ allcharsExceptNewline = allchars[: allchars.index(b'\n')]+allchars[allchars.index(b'\n')+1:]
+ allcharsExceptNewlineTranstable = bytes.maketrans(allcharsExceptNewline, b'*'*len(allcharsExceptNewline))
#if sys.platform[0:5]=="linux" :
# allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))
# supprime toutes les chaines ou commentaires ,y compris multiligne i
# entre 3 ou 1 simples ou doubles quotes (ouvrantes fermantes) ou #
# laisse les non fermantes ou non ouvrantes
- #src = escapedQuotesRE.sub(u"**", src)
- # le u met le bazar dans le translate
+# on prend 1 sur 2 en raison du split qui donne python, commentaire, python, commentaire...
+
src = escapedQuotesRE.sub("**", src)
allstrings = stringsAndCommentsRE.split(src)
- # every odd element is a string or comment
- for i in xrange(1, len(allstrings), 2):
+
+ # on a une liste d elements constituee successivement de (string, comment)
+ for i in range(1, len(allstrings), 2):
if allstrings[i].startswith(u"'''")or allstrings[i].startswith('"""'):
allstrings[i] = allstrings[i][:3]+ \
allstrings[i][3:-3].translate(allcharsExceptNewlineTranstable)+ \
return d
-class ENTITE_JDC :
- """Classe de base pour tous les objets créés lors de la conversion
- Tout objet dérivé est enregistré aupres de son pere a sa création
+class ENTITE_JDC(object) :
+ """Classe de base pour tous les objets crees lors de la conversion
+ Tout objet derive est enregistre aupres de son pere a sa creation
"""
def __init__(self,pere):
self.texte = ''
def __str__(self):
"""
- Retourne une chaine de caracteres représentants self
- sous une forme interprétable par EFICAS
+ Retourne une chaine de caracteres representants self
+ sous une forme interpretable par EFICAS
"""
t=repr(self.texte)
return "COMMENTAIRE(u"+t+")\n"
self.texte = self.texte+texte[1:]
else:
# le diese n'est pas sur le premier caractere
- amont,aval = string.split(texte,'#',1) # on découpe suivant la premiere occurrence de #
+ amont,aval = texte.split('#',1) # on decoupe suivant la premiere occurrence de #
self.texte = self.texte +amont + aval
class COMMANDE(ENTITE_JDC):
def get_nb_par(self):
"""
- Retourne la différence entre le nombre de parentheses ouvrantes
- et le nombre de parentheses fermantes présentes dans self.texte
- Peut donc retourner un entier négatif
+ Retourne la difference entre le nombre de parentheses ouvrantes
+ et le nombre de parentheses fermantes presentes dans self.texte
+ Peut donc retourner un entier negatif
"""
# faire attention aux commentaires contenus dans self.texte
# qui peuvent eux-memes contenir des parentheses !!!!
- l_lignes = string.split(self.texte,'\n')
+ l_lignes = self.texte.split('\n')
nb = 0
for ligne in l_lignes:
- ligne = string.split(ligne,'#')[0]
- nb = nb + (string.count(ligne,'(')-string.count(ligne,')'))
+ ligne = ligne.split('#')[0]
+ #nb = nb + (string.count(ligne,'(')-string.count(ligne,')'))
+
+ nb = nb + ( ligne.count('(') - ligne.count(')') )
return nb
class AFFECTATION(ENTITE_JDC):
Ajoute texte a self.texte en enlevant tout retour chariot et tout point virgule
PN et tout commentaire
"""
- if texte[-1] == '\n' : texte = string.rstrip(texte[0:-1])
- if texte[-1] == ';' : texte = string.rstrip(texte[0:-1])
+ if texte[-1] == '\n' : texte = texte[0:-1].rstrip()
+ if texte[-1] == ';' : texte = texte[0:-1].rstrip()
self.texte = self.texte+texte+'\n'
def __str__(self):
"""
- Retourne une expression de l'affectation compréhensible par ACCAS
+ Retourne une expression de l'affectation comprehensible par ACCAS
et exploitable par EFICAS
"""
- nom,valeur = string.split(self.texte,'=',1)
- n = string.rstrip(nom)
- nom = string.lstrip(n)
+ nom,valeur = self.texte.split('=',1)
+ n = nom.rstrip()
+ nom = n.lstrip()
if valeur[-1] == '\n': valeur = valeur[:-1]
return n + ' = PARAMETRE(nom=\''+nom+'\',valeur='+valeur+')\n'
"""
Ajoute texte a self.texte en enlevant les doubles commentaires
"""
- texte = string.strip(texte)
- texte = string.strip(texte[2:])
+ texte = texte.strip()
+ texte = texte[2:].strip()
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
+ Retourne une expression de la commande commentarisee comprehensible par ACCAS
et exploitable par EFICAS
"""
return "COMMANDE_COMM(texte="+repr(self.texte)+")\n"
def __str__(self):
"""
- Retourne une expression du parametre EVAL compréhensible par ACCAS
+ Retourne une expression du parametre EVAL comprehensible par ACCAS
et exploitable par EFICAS
"""
- nom,valeur = string.split(self.texte,'=',1)
- nom = string.strip(nom)
+ nom,valeur = self.texte.split('=',1)
+ nom = nom.strip()
if valeur[-1] == '\n': valeur = valeur[:-1]
- valeur = string.strip(valeur)
+ valeur = valeur.strip()
return nom+' = PARAMETRE_EVAL(nom=\''+nom+'\',valeur=\''+valeur+'\')\n\n'
-class PARSEUR_PYTHON:
+class PARSEUR_PYTHON(object):
"""
- Cette classe sert a générer un objet PARSEUR_PYTHON qui réalise l'analyse d'un texte
- représentant un JDC Python en distinguant :
+ Cette classe sert a generer un objet PARSEUR_PYTHON qui realise l'analyse d'un texte
+ representant un JDC Python en distinguant :
- les commentaires inter commandes
- les affectations
- les commandes
def is_affectation(self,texte):
"""
- Méthode booléenne qui retourne 1 si le texte est celui d'une affectation dans un jeu de commandes
+ Methode booleenne qui retourne 1 si le texte est celui d'une affectation dans un jeu de commandes
Aster, 0 sinon
"""
if '=' not in texte : return 0
if self.pattern_commande.match(texte):
- # cas d'une procédure ...
+ # cas d'une procedure ...
return 0
- amont,aval = string.split(texte,'=',1)
- aval = string.strip(aval)
+ amont,aval = texte.split('=',1)
+ aval = aval.strip()
+
+
if self.pattern_commande.match(aval):
return 0
else:
- s= string.strip(amont)
+ s= amont.strip()
m= self.pattern_name.match(s)
if m is None : return 0
if m.start() != 0 :return 0
def is_eval(self,texte):
"""
- Méthode booléenne qui retourne 1 si le texte est celui d'une affectation de type EVAL
+ Methode booleenne qui retourne 1 si le texte est celui d'une affectation de type EVAL
dans un jeu de commandes Aster, 0 sinon
"""
if '=' not in texte : return 0
if self.pattern_commande.match(texte):
- # cas d'une procédure ...
+ # cas d'une procedure ...
return 0
- amont,aval = string.split(texte,'=',1)
- aval = string.strip(aval)
+ amont,aval = texte.split('=',1)
+ aval = aval.strip()
if not self.pattern_commande.match(aval) : return 0
if self.pattern_eval.match(aval):
return 1
def is_commande(self,texte):
"""
- Méthode booléenne qui retourne 1 si le texte est celui d'une commande dans un jeu de commandes
+ Methode booleenne qui retourne 1 si le texte est celui d'une commande dans un jeu de commandes
Aster, 0 sinon
"""
if self.pattern_commande.match(texte):
- # cas d'une procédure ...
+ # cas d'une procedure ...
return 1
# A ce stade il faut avoir un OPER ou une MACRO, bref un '=' !
if '=' not in texte : return 0
# on a un texte de la forme xxxx = yyyyy
# --> reste a analyser yyyy
- amont,aval = string.split(texte,'=',1)
- aval = string.strip(aval)
+ amont,aval = texte.split('=',1)
+ aval = aval.strip()
if self.pattern_commande.match(aval):
return 1
else:
def analyse(self):
"""
Eclate la chaine self.texte en self.l_objets une liste lignes d'instructions
- et de commentaires (parmi lesquels des instructions "commentarisées").
+ et de commentaires (parmi lesquels des instructions "commentarisees").
"""
- l_lignes = string.split(self.texte,'\n')
+ l_lignes = self.texte.split('\n')
commentaire_courant = None
commande_courante = None
affectation_courante = None
if hangingBraces[0] < 0 or hangingBraces[1] < 0 or hangingBraces[2] < 0:
raise ParserException()
- if string.strip(ligne) == '':
+ if ligne.strip() == '':
# il s'agit d'un saut de ligne
# --> on l'ignore
continue
if pattern_2comments.match(ligne):
- #on a trouvé une commande commentarisée : double commentaire sans rien devant a part des blancs
+ #on a trouve une commande commentarisee : double commentaire sans rien devant a part des blancs
if commentaire_courant:
#Si un commentaire ordinaire est en cours on le termine
commentaire_courant = None
if commande_courante :
- # on a un objet commentarisé a l'intérieur d'une commande
- # --> non traité pour l'instant : on l'ajoute simplement a la commande courante comme
+ # on a un objet commentarise a l'interieur d'une commande
+ # --> non traite pour l'instant : on l'ajoute simplement a la commande courante comme
# un commentaire ordinaire
commande_courante.append_text(ligne)
elif commande_commentarisee_courante :
# commande_commentarisee en cours : on ajoute la ligne
commande_commentarisee_courante.append_text(ligne)
- # on a 2 commandes commentarisées de suite
+ # on a 2 commandes commentarisees de suite
if pattern_finComments.match(ligne) :
commande_commentarisee_courante = None
else:
- # debut de commande commentarisée : on crée un objet commande_commentarisee_courante
+ # debut de commande commentarisee : on cree un objet commande_commentarisee_courante
commande_commentarisee_courante = COMMANDE_COMMENTARISEE(self)
commande_commentarisee_courante.append_text(ligne)
commande_commentarisee_courante = None
if commande_courante :
- # il s'agit d'un commentaire a l'intérieur d'une commande --> on ne fait rien de special
+ # il s'agit d'un commentaire a l'interieur d'une commande --> on ne fait rien de special
#on l'ajoute au texte de la commande
commande_courante.append_text(ligne)
elif commentaire_courant :
commentaire_courant.append_text(ligne)
else :
# il s'agit d'un nouveau commentaire entre deux commandes
- # --> on le crée et il devient le commentaire courant
+ # --> on le cree et il devient le commentaire courant
commentaire_courant = COMMENTAIRE(self)
commentaire_courant.append_text(ligne)
#on passe a la ligne suivante
continue
- # la ligne contient des données autre qu'un éventuel commentaire
+ # la ligne contient des donnees autre qu'un eventuel commentaire
if commentaire_courant :
- # on clot un éventuel commentaire courant
+ # on clot un eventuel commentaire courant
commentaire_courant = None
if commande_commentarisee_courante :
- # on clot une éventuelle commande commentarisee courante
+ # on clot une eventuelle commande commentarisee courante
commande_commentarisee_courante = None
if commande_courante :
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
- #la commande est terminée
+ #la commande est terminee
self.analyse_reel(commande_courante.texte)
commande_courante = None
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
- #L'affectation est terminée
+ #L'affectation est terminee
affectation_courante=None
#on passe a la ligne suivante
continue
continue
if self.is_affectation(ligne):
- # --> affectation
+ #print( '--> affectation')
text=ligne
#traitement des commentaires en fin de ligne
compos=line.find(u"#")
if inspos > 2:
#on garde seulement la premiere partie de la ligne
#si on a que des blancs apres le point virgule
- if string.strip(text[inspos:]) == ";":
+ if text[inspos:].strip() == ";":
text=text[:inspos]
else:
raise FatalError(tr("Eficas ne peut pas traiter plusieurs instructions \
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
- #L'affectation est terminée
+ #L'affectation est terminee
affectation_courante=None
#on passe a la ligne suivante
continue
if self.is_commande(ligne):
# --> nouvelle commande
+ #print ('nouvelle commande')
affectation_courante = None
commande_courante = COMMANDE(self)
commande_courante.append_text(ligne)
return txt
def test():
- import parseur_python
+ #import parseur_python
import doctest
doctest.testmod(parseur_python)
if __name__ == "__main__" :
import time
#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/forma12c.comm'
- fichier = 'titi.comm'
- fichier = '../Aster/sdls300a.comm'
- fichier = '../Aster/az.comm'
+ #fichier = 'U:/Eficas_dev/Tests/test_eval.comm'
texte = open(fichier,'r').read()
- class appli:
+ class appli(object):
dict_reels={}
liste_simp_reel=["VALE","VALE_C","GROUP_MA","RAYON"]
a=appli()
compile(txt, '<string>', 'exec')
- print (a.dict_reels)
+ print((a.dict_reels))
liste de chaines de caractères dans une syntaxe représentative d'un
jeu de commandes en un texte présentable
"""
-import types,string,re
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import object
+except : pass
+import types,re
from Extensions.i18n import tr
filePattern="'[^\(\)]([^\(\)]*\([^\(\)]*\))*[^\(\)]*'"
filePattern2='"[^\(\)]([^\(\)]*\([^\(\)]*\))*[^\(\)]*"'
-class Formatage :
+class Formatage (object):
"""
Cette classe contient toutes les méthodes nécessaires au formatage
de la chaine de caracteres issue d'un generator en un fichier
for etape in self.l_jdc:
self.count = self.count+1
self.texte_etape = ''
- if type(etape)==types.ListType:
+ #if type(etape)==types.ListType:
+ if type(etape)==list:
# L'etape est sous la forme d'une liste dont le premier element est une chaine
self.indent=[]
self.indent.append(len(etape[0]))
self.indent_courant = self.indent[length]
# on écrit ses fils
self.formate_etape(element[1:])
- elif type(element) == types.StringType:
+ #elif type(element) == types.StringType:
+ elif type(element) == bytes:
# il s'agit d'un mot-clé simple ou de ')' ou ');' ou '),' ou ');\n'
self.indent_courant=self.indent[length-2]
else :
self.indent_courant=self.indent[0]
- self.texte_etape = self.texte_etape + string.strip(s_etape)
+ self.texte_etape = self.texte_etape + s_etape.strip()
def traite_mcfact(self,s_mcfact,ind) :
"""
L'attribut self.indent est modifié par le traitement
L'attribut self.indent_courant est modifié par le traitement
"""
- self.texte_etape = self.texte_etape + string.strip(s_mcfact)
+ self.texte_etape = self.texte_etape + s_mcfact.strip()
length = len(self.indent)
if length > 1:
last = self.indent[length-1]
else :
bool_fonction=0
longueur = self.longueur(self.texte_etape)
- increment = len((u'\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp))
+ increment = len((u'\n'+self.indent_courant*' ')*ind + s_mcsimp.strip())
if (bool_fonction == 1 ) :
self.texte_etape = self.texte_etape+'\n'+self.indent_courant*' ' +s_mcsimp
elif ( ((1-ind)*longueur+increment) <= self.l_max ) :
- self.texte_etape = self.texte_etape + ('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp)
+ self.texte_etape = self.texte_etape + ('\n'+self.indent_courant*' ')*ind +s_mcsimp.strip()
else :
# il faut couper ...
- nom,valeur = string.split(s_mcsimp,self.sep,1)
+ #nom,valeur = string.split(s_mcsimp,self.sep,1)
+ nom,valeur = str.split(s_mcsimp,self.sep,1)
chaine = self.creer_chaine(nom,valeur,'\n'+self.indent_courant*' ',ind)
- #self.jdc_fini = self.jdc_fini + ('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp)
+ #self.jdc_fini = self.jdc_fini + ('\n'+self.indent_courant*' ')*ind + s_mcsimp.strip()
self.texte_etape = self.texte_etape + chaine
return
texte est une string qui peut contenir des retours chariots
Cette méthode retourne la longueur de la dernière ligne de texte
"""
- liste = string.split(texte,'\n')
+ liste = texte.split('\n')
return len(liste[-1])
def creer_chaine(self,nom,valeur,increment,ind):
s=s+valeur
return s
# il s'agit d'une liste
- liste = string.split(valeur,',')
+ liste = valeur.split(',')
i=0
for arg in liste :
- ajout = string.strip(arg)
+ ajout = arg.strip()
if len(ajout) == 0 : continue
longueur = self.longueur(texte = (texte + label)) + len(ajout +',') + (1-i)*len(increment)
if longueur <= self.l_max:
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce package contient tous les générateurs de formats de sortie
- à partir des objets d' EFICAS.
+ Ce package contient tous les generateurs de formats de sortie
+ a partir des objets d' EFICAS.
- Ces générateurs sont implémentés sous forme de plugins
+ Ces generateurs sont implementes sous forme de plugins
"""
+from __future__ import absolute_import
from Extensions import pluginloader
import generator
"""
Ce module contient le plugin generateur d une liste des GroupNo et GroupMA
"""
+from __future__ import absolute_import
import traceback
-import types,string,re
+import types,re
-from generator_python import PythonGenerator
+from .generator_python import PythonGenerator
def entryPoint():
"""
- Retourne les informations nécessaires pour le chargeur de plugins
+ Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournées dans un dictionnaire
+ Ces informations sont retournees dans un dictionnaire
"""
return {
# Le nom du plugin
'name' : 'GroupMA',
- # La factory pour créer une instance du plugin
+ # La factory pour creer une instance du plugin
'factory' : GroupMAGenerator,
}
un texte au format homard
"""
- # Les extensions de fichier préconisées
+ # Les extensions de fichier preconisees
extensions=('.comm',)
def __init__(self):
if not type(obj.valeur) in (list, tuple):
aTraiter=(obj.valeur,)
else :
- aTraiter=obj.valeur
+ aTraiter=obj.valeur
for group in aTraiter :
if group not in self.listeMA :
self.listeMA.append(group)
if not type(obj.valeur) in (list, tuple):
aTraiter=(obj.valeur,)
else :
- aTraiter=obj.valeur
+ aTraiter=obj.valeur
for group in aTraiter :
if group not in self.listeNO :
self.listeNO.append(group)
"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
"""
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
texte_debut="int main() \n{ \n init_var();\n"
texte_debut+=' format="med";\n'
import traceback
-import types,string,re,os
+import types,re,os
from Extensions.i18n import tr
-from generator_dicoImbrique import DicoImbriqueGenerator
+from .generator_dicoImbrique import DicoImbriqueGenerator
import pdb
-from numpy import zeros
def entryPoint():
"""
"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
"""
-import types,string,re,os
+from __future__ import absolute_import
+import types,re,os
from Extensions.i18n import tr
-from generator_python import PythonGenerator
-from generator_modification import ModificationGenerator
-from numpy import zeros
+from .generator_python import PythonGenerator
+from .generator_modification import ModificationGenerator
def entryPoint():
"""
"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
"""
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except : pass
+
import traceback
-import types,string,re,os
+import types,re,os
from Extensions.i18n import tr
-from generator_python import PythonGenerator
+from .generator_python import PythonGenerator
extensions=('.comm',)
#if 1:
try :
from enumDicoTelemac import TelemacdicoEn
DicoEnumCasEnInverse={}
- for motClef in TelemacdicoEn.keys():
+ for motClef in TelemacdicoEn():
d={}
- for valTelemac in TelemacdicoEn[motClef].keys():
+ for valTelemac in TelemacdicoEn[motClef]:
valEficas= TelemacdicoEn[motClef][valTelemac]
d[valEficas]=valTelemac
DicoEnumCasEnInverse[motClef]=d
self.dicoCataToCas={}
self.dicoCasToCata=appli.readercata.dicoCasToCata
- for motClef in self.dicoCasToCata.keys():
+ for motClef in self.dicoCasToCata:
self.dicoCataToCas[self.dicoCasToCata[motClef]]=motClef
if self.statut == 'Leger' : extension = ".Lcas"
else : extension = ".cas"
fileDico = fn[:fn.rfind(".")] + extension
- f = open( str(fileDico), 'wb')
+ f = open( str(fileDico), 'w')
f.write( self.texteDico )
f.close()
self.texteDico += '/\t\t\t'+obj.nom +'\n'
self.texteDico += '/------------------------------------------------------/\n'
s=PythonGenerator.generPROC_ETAPE(self,obj)
- if obj.nom in TELEMACGenerator.__dict__.keys() : apply(TELEMACGenerator.__dict__[obj.nom],(self,obj))
+ if obj.nom in TELEMACGenerator.__dict__ : TELEMACGenerator.__dict__[obj.nom](*(self,obj))
return s
# ajouter le statut ?
if self.statut == 'Leger' :
if hasattr(obj.definition,'defaut') and (obj.definition.defaut == obj.valeur) and (obj.nom not in self.listeTelemac) : return s
- if hasattr(obj.definition,'defaut') and obj.definition.defaut != None and (type(obj.valeur) == types.TupleType or type(obj.valeur) == types.ListType) and (tuple(obj.definition.defaut) == tuple(obj.valeur)) and (obj.nom not in self.listeTelemac) : return s
+ if hasattr(obj.definition,'defaut') and obj.definition.defaut != None and (type(obj.valeur) == tuple or type(obj.valeur) == list) and (tuple(obj.definition.defaut) == tuple(obj.valeur)) and (obj.nom not in self.listeTelemac) : return s
#nomMajuscule=obj.nom.upper()
sTelemac=s[0:-1]
- if not( type(obj.valeur) in (types.TupleType,types.ListType) ):
- if obj.nom in DicoEnumCasEnInverse.keys():
+ if not( type(obj.valeur) in (tuple,list) ):
+ if obj.nom in DicoEnumCasEnInverse:
try : sTelemac=str(DicoEnumCasEnInverse[obj.nom][obj.valeur])
- except : print ("generMCSIMP Pb valeur avec ", obj.nom, obj.valeur)
- if type(obj.valeur) in (types.TupleType,types.ListType) :
- if obj.nom in DicoEnumCasEnInverse.keys():
+ except : print(("generMCSIMP Pb valeur avec ", obj.nom, obj.valeur))
+ if type(obj.valeur) in (tuple,list) :
+ if obj.nom in DicoEnumCasEnInverse:
#sT = "'"
sT=''
for v in obj.valeur:
try : sT +=str(DicoEnumCasEnInverse[obj.nom][v]) +";"
- except : print ("generMCSIMP Pb Tuple avec ", obj.nom, v, obj.valeur)
+ except : print(("generMCSIMP Pb Tuple avec ", obj.nom, v, obj.valeur))
#sTelemac=sT[0:-1]+"'"
sTelemac=sT[0:-1]
else :
"""
"""
s=PythonGenerator.generMCFACT(self,obj)
- if obj.nom in TELEMACGenerator.__dict__.keys() : apply(TELEMACGenerator.__dict__[obj.nom],(self,obj))
+ if obj.nom in TELEMACGenerator.__dict__ : TELEMACGenerator.__dict__[obj.nom],(self,obj)
return s
def NAME_OF_TRACER(self,obj):
- print (dir(obj) )
- print (obj.get_genealogie_precise())
+ print((dir(obj) ))
+ print((obj.get_genealogie_precise()))
def Validation(self,obj):
self.texteDico += "VALIDATION : True \n"
#
"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
"""
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except : pass
+
import pickle
texte_debut="#include <Zcracks_base.z7p> \n int main() \n{ \n init_var();\n"
texte_debut+=' format="med";\n'
import traceback
-import types,string,re,os
+import types,re,os
from Extensions.i18n import tr
-from generator_python import PythonGenerator
+from .generator_python import PythonGenerator
#ListeConcatene=('ridge_names','topo_names','geom_names','elset_names','faset_names','liset_names','nset_names','center','normal','dir')
ListeConcatene=('ridge_names','topo_names','geom_names','elset_names','faset_names','liset_names','nset_names')
ListeConcatene2=('center','normal','dir')
def writeDefault(self,fn) :
fileZcrack = fn[:fn.rfind(".")] + '.z7p'
f = open( str(fileZcrack), 'wb')
- print (self.textePourRun)
+ print((self.textePourRun))
self.ajoutRun()
self.textePourRunAvecDouble=self.textePourRun.replace("'",'"')
aplat pour EFICAS.
"""
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
import traceback
-import types,string,re
+import types,re
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
def entryPoint():
"""
- Retourne les informations nécessaires pour le chargeur de plugins
+ Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournées dans un dictionnaire
+ Ces informations sont retournees dans un dictionnaire
"""
return {
# Le nom du plugin
'name' : 'aplat',
- # La factory pour créer une instance du plugin
+ # La factory pour creer une instance du plugin
'factory' : AplatGenerator,
}
-class AplatGenerator:
+class AplatGenerator(object):
"""
Ce generateur parcourt un objet de type JDC et produit
un fichier au format aplat
- L'acquisition et le parcours sont réalisés par la méthode
+ L'acquisition et le parcours sont realises par la methode
generator.gener(objet_jdc,format)
- L'écriture du fichier au format ini par appel de la méthode
+ L'ecriture du fichier au format ini par appel de la methode
generator.writefile(nom_fichier)
- Ses caractéristiques principales sont exposées dans des attributs
+ Ses caracteristiques principales sont exposees dans des attributs
de classe :
- - extensions : qui donne une liste d'extensions de fichier préconisées
+ - extensions : qui donne une liste d'extensions de fichier preconisees
"""
- # Les extensions de fichier préconisées
+ # Les extensions de fichier preconisees
extensions=('.*',)
def __init__(self,cr=None):
self.cr=N_CR.CR(debut='CR generateur format aplat pour eficas',
fin='fin CR format aplat pour eficas')
self.init=''
- # Le séparateur utiisé
+ # Le separateur utiise
self.sep='//'
- # Le texte au format aplat est stocké dans l'attribut text
+ # Le texte au format aplat est stocke dans l'attribut text
self.text=''
def writefile(self,filename):
def gener(self,obj,format='brut',config=None,appli=None):
"""
- Retourne une représentation du JDC obj sous une forme qui est paramétrée par format.
+ Retourne une representation du JDC obj sous une forme qui est parametree par format.
Si format vaut 'brut', 'standard' ou 'beautifie', retourne le texte issu de generator
"""
liste= self.generator(obj)
def generator(self,obj):
"""
Cette methode joue un role d'aiguillage en fonction du type de obj
- On pourrait utiliser les méthodes accept et visitxxx à la
- place (dépend des gouts !!!)
+ On pourrait utiliser les methodes accept et visitxxx a la
+ place (depend des gouts !!!)
"""
- # ATTENTION a l'ordre des tests : il peut avoir de l'importance (héritage)
+ # ATTENTION a l'ordre des tests : il peut avoir de l'importance (heritage)
if isinstance(obj,PROC_ETAPE):
return self.generPROC_ETAPE(obj)
elif isinstance(obj,MACRO_ETAPE):
return self.generETAPE_NIVEAU(obj)
elif isinstance(obj,COMMENTAIRE):
return self.generCOMMENTAIRE(obj)
- # Attention doit etre placé avant PARAMETRE (raison : héritage)
+ # Attention doit etre place avant PARAMETRE (raison : heritage)
elif isinstance(obj,PARAMETRE_EVAL):
return self.generPARAMETRE_EVAL(obj)
elif isinstance(obj,PARAMETRE):
def generJDC(self,obj):
"""
- Cette méthode convertit un objet JDC en une chaine de
- caractères à la syntaxe aplat
+ Cette methode convertit un objet JDC en une chaine de
+ caracteres a la syntaxe aplat
"""
text=''
if obj.definition.l_niveaux == ():
def generCOMMANDE_COMM(self,obj):
"""
- Cette méthode convertit un COMMANDE_COMM
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit un COMMANDE_COMM
+ en une chaine de caracteres a la syntaxe aplat
"""
- l_lignes = string.split(obj.valeur,'\n')
+ l_lignes = obj.valeur.split('\n')
txt=''
for ligne in l_lignes:
txt = txt + '##'+ligne+'\n'
def generEVAL(self,obj):
"""
- Cette méthode convertit un EVAL
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit un EVAL
+ en une chaine de caracteres a la syntaxe aplat
"""
return 'EVAL("""'+ obj.valeur +'""")'
def generCOMMENTAIRE(self,obj):
"""
- Cette méthode convertit un COMMENTAIRE
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit un COMMENTAIRE
+ en une chaine de caracteres a la syntaxe aplat
"""
- l_lignes = string.split(obj.valeur,'\n')
+ l_lignes = obj.valeur.split('\n')
txt=''
for ligne in l_lignes:
txt = txt + '#'+ligne+'\n'
def generPARAMETRE_EVAL(self,obj):
"""
- Cette méthode convertit un PARAMETRE_EVAL
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit un PARAMETRE_EVAL
+ en une chaine de caracteres a la syntaxe aplat
"""
if obj.valeur == None:
return obj.nom + ' = None ;\n'
def generPARAMETRE(self,obj):
"""
- Cette méthode convertit un PARAMETRE
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit un PARAMETRE
+ en une chaine de caracteres a la syntaxe aplat
"""
- if type(obj.valeur) == types.StringType:
+ if type(obj.valeur) == bytes:
# 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"
def generETAPE_NIVEAU(self,obj):
"""
- Cette méthode convertit une étape niveau
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit une etape niveau
+ en une chaine de caracteres a la syntaxe aplat
"""
text=''
if obj.etapes_niveaux == []:
def gener_etape(self,obj):
"""
- Cette méthode est utilisé pour convertir les objets etape
- en une chaine de caractères à la syntaxe aplat
+ Cette methode est utilise pour convertir les objets etape
+ en une chaine de caracteres a la syntaxe aplat
"""
text=''
for v in obj.mc_liste:
def generETAPE(self,obj):
"""
- Cette méthode convertit une étape
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit une etape
+ en une chaine de caracteres a la syntaxe aplat
"""
try:
sdname= self.generator(obj.sd)
def generMACRO_ETAPE(self,obj):
"""
- Cette méthode convertit une macro-étape
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit une macro-etape
+ en une chaine de caracteres a la syntaxe aplat
"""
try:
if obj.sd == None:
def generASSD(self,obj):
"""
- Convertit un objet dérivé d'ASSD en une chaine de caractères à la
+ Convertit un objet derive d'ASSD en une chaine de caracteres a la
syntaxe aplat
"""
return obj.get_name()
def generMCList(self,obj):
"""
- Convertit un objet MCList en une chaine de caractères à la
+ Convertit un objet MCList en une chaine de caracteres a la
syntaxe aplat
"""
i=0
old_init=self.init
for data in obj.data :
i=i+1
- self.init = init + self.sep + "occurrence n°"+`i`
+ self.init = init + self.sep + "occurrence n"+repr(i)
text = text + self.generator(data)
self.init=old_init
return text
def generMCSIMP(self,obj) :
"""
- Convertit un objet MCSIMP en une chaine de caractères à la
+ Convertit un objet MCSIMP en une chaine de caracteres a la
syntaxe aplat
"""
- if type(obj.valeur) in (types.TupleType,types.ListType) :
- # On est en présence d'une liste de valeur
+ if type(obj.valeur) in (tuple,list) :
+ # On est en presence d'une liste de valeur
rep = '('
for val in obj.valeur:
if type(val) == types.InstanceType :
rep = rep + self.generator(val) +','
else:
- rep = rep + `val`+','
+ rep = rep + repr(val)+','
rep = rep + ')'
elif type(obj.valeur) == types.InstanceType :
- # On est en présence d'une valeur unique de type instance
+ # On est en presence d'une valeur unique de type instance
rep = self.generator(obj.valeur)
else :
- # On est en présence d'une valeur unique
- rep = `obj.valeur`
+ # On est en presence d'une valeur unique
+ rep = repr(obj.valeur)
return self.init + self.sep + obj.nom + ' :' + rep + '\n'
def generMCCOMPO(self,obj):
"""
- Convertit un objet MCCOMPO en une chaine de caractères à la
+ Convertit un objet MCCOMPO en une chaine de caracteres a la
syntaxe aplat
"""
text = ''
"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
"""
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except : pass
+
import traceback
-import types,string,re,os
+import types,re,os
from Extensions.i18n import tr
-from generator_python import PythonGenerator
+from .generator_python import PythonGenerator
def entryPoint():
"""
fileDico = fn[:fn.rfind(".")] + '.py'
f = open( str(fileDico), 'wb')
f.write( self.texteDico )
- print (self.texteDico)
+ print((self.texteDico))
f.close()
#----------------------------------------------------------------------------------------
"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
"""
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
import traceback
-import types,string,re,os
+import types,re,os
from Extensions.i18n import tr
-from generator_python import PythonGenerator
+from .generator_python import PythonGenerator
def entryPoint():
"""
if hasattr(obj.etape,'sdnom') and obj.etape.sdnom != None and obj.etape.sdnom != "" :
nom = nom+ obj.etape.sdnom
- if not(self.Dico.has_key(nom)) : dicoCourant={}
+ if not(nom in self.Dico) : dicoCourant={}
else : dicoCourant=self.Dico [nom]
nomFeuille=liste[-1]
- if dicoCourant.has_key(nomFeuille) or self.DicoDejaLa.has_key(nomFeuille) :
- if self.DicoDejaLa.has_key(nomFeuille):
+ if nomFeuille in dicoCourant or nomFeuille in self.DicoDejaLa:
+ if nomFeuille in self.DicoDejaLa:
nomTravail= nomFeuille +'_'+str(self.DicoDejaLa[nomFeuille])
self.DicoDejaLa[nomFeuille]=self.DicoDejaLa[nomFeuille]+1
nomFeuille=nomTravail
if hasattr(obj.valeur,'nom'): dicoCourant[nomFeuille]=obj.valeur.nom
else :
- if type(obj.valeur) in (types.ListType,types.TupleType):
+ if type(obj.valeur) in (list,tuple):
try :
#PNPNPN a remplacer par plus propre
if obj.definition.validators.typeDesTuples[0] !='R' :
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
import os
+
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
-from generator_python import PythonGenerator
+from .generator_python import PythonGenerator
+import six
def entryPoint():
"""
if not os.path.isfile(templateFileName):
raise EficasException(tr("Fichier patron %s n'existe pas.",
str( templateFileName)))
- f = file(templateFileName, "r")
+ f = open(templateFileName, "r")
template = f.read()
f.close()
self.output_text = self.replace_keywords(template)
def replace_keywords(self, template_string):
result = template_string
- for item in self.kw_dict.iteritems():
+ for item in six.iteritems(self.kw_dict):
replace_str = "%" + item[0] + "%"
result = result.replace(replace_str, str(item[1]))
return result
"""
Ce module contient le plugin generateur de fichier
au format ini pour EFICAS.
-
-
"""
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
import traceback
-import types,string
+import types
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
def entryPoint():
"""
- Retourne les informations nécessaires pour le chargeur de plugins
- Ces informations sont retournées dans un dictionnaire
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
"""
return {
# Le nom du plugin
'name' : 'ini',
- # La factory pour créer une instance du plugin
+ # La factory pour creer une instance du plugin
'factory' : IniGenerator,
}
-class IniGenerator:
+class IniGenerator(object):
"""
Ce generateur parcourt un objet de type MCFACT et produit
un fichier au format ini
- L'acquisition et le parcours sont réalisés par le méthode
+ L'acquisition et le parcours sont realises par le methode
generator.gener(objet_mcfact)
- L'écriture du fichier au format ini par appel de la méthode
+ L'ecriture du fichier au format ini par appel de la methode
generator.writefile(nom_fichier)
- Ses caractéristiques principales sont exposées dans des attributs
+ Ses caracteristiques principales sont exposees dans des attributs
de classe :
- - extensions : qui donne une liste d'extensions de fichier préconisées
+ - extensions : qui donne une liste d'extensions de fichier preconisees
"""
- # Les extensions de fichier préconisées
+ # Les extensions de fichier preconisees
extensions=('.ini','.conf')
def __init__(self,cr=None):
else:
self.cr=N_CR.CR(debut='CR generateur format ini',
fin='fin CR format ini')
- # Le texte au format ini est stocké dans l'attribut text
+ # Le texte au format ini est stocke dans l'attribut text
self.text=''
def writefile(self,filename):
def gener(self,obj,config=None):
"""
- Tous les mots-clés simples du niveau haut sont mis dans la section DEFAUT
- Tous les mots-clés facteurs sont convertis en sections
- Un mot-clé facteur ne peut contenir que des mots-clés simples. Sinon => erreur
+ Tous les mots-cles simples du niveau haut sont mis dans la section DEFAUT
+ Tous les mots-cles facteurs sont convertis en sections
+ Un mot-cle facteur ne peut contenir que des mots-cles simples. Sinon => erreur
"""
liste_mcfact=[]
sect_defaut=''
elif isinstance(mocle,MCSIMP):
sect_defaut=sect_defaut+self.generMCSIMP(mocle)
else:
- self.cr.fatal(tr("Entite inconnue ou interdite :%s",`mocle`))
+ self.cr.fatal(tr("Entite inconnue ou interdite :%s",repr(mocle)))
self.text=''
if sect_defaut != '':
self.text="[DEFAULT]\n"+sect_defaut
- self.text=self.text + string.join(liste_mcfact,'\n')
+ self.text=self.text + ''.join(liste_mcfact,'\n')
return self.text
def generMCFACT(self,obj):
"""
- Cette méthode convertit un mot-clé facteur ne contenant que des mots-clés
- simples en une chaine de caractères
+ Cette methode convertit un mot-cle facteur ne contenant que des mots-cles
+ simples en une chaine de caracteres
"""
sect_text='[%s]\n' % obj.nom
for mocle in obj.mc_liste:
if isinstance(mocle,MCSIMP):
sect_text=sect_text+self.generMCSIMP(mocle)
else:
- self.cr.fatal(tr("Entite inconnue ou interdite :%s. Elle est ignoree",`mocle`))
+ self.cr.fatal(tr("Entite inconnue ou interdite :%s. Elle est ignoree",repr(mocle)))
return sect_text
def generMCSIMP(self,obj):
"""
- Cette méthode convertit un mot-clé simple en une chaine de caractères
+ Cette methode convertit un mot-cle simple en une chaine de caracteres
au format ini
"""
s=''
- if type(obj.valeur) == types.TupleType :
+ if type(obj.valeur) == tuple :
self.cr.fatal(tr("Les tuples ne sont pas supportes pour le format ini :%s ", obj.nom))
s="%s = %s\n" % (obj.nom,"ERREUR")
else :
CARMEL3D pour EFICAS.
"""
+from __future__ import print_function
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
import traceback
-import types,string,re,os
+import types,re,os
import Accas
-from generator_python import PythonGenerator
+from .generator_python import PythonGenerator
def entryPoint():
"""
-# -*- coding: utf-8 -*-\r
-# Copyright (C) 2007-2013 EDF R&D\r
-#\r
-# This library is free software; you can redistribute it and/or\r
-# modify it under the terms of the GNU Lesser General Public\r
-# License as published by the Free Software Foundation; either\r
-# version 2.1 of the License.\r
-#\r
-# This library is distributed in the hope that it will be useful,\r
-# but WITHOUT ANY WARRANTY; without even the implied warranty of\r
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
-# Lesser General Public License for more details.\r
-#\r
-# You should have received a copy of the GNU Lesser General Public\r
-# License along with this library; if not, write to the Free Software\r
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
-#\r
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com\r
-#\r
-"""\r
- Ce module sert pour charger les parametres de configuration d'EFICAS\r
-"""\r
-# Modules Python\r
-import os, sys, string, types, re\r
-from Extensions.i18n import tr\r
-\r
-class ModificationGenerator:\r
- def generTexteModif(self,obj):\r
- texteModification=""\r
- for t in obj.editor.dicoNouveauxMC.keys() :\r
- # 'ajoutDefinitionMC',etape,listeAvant,nomDuMC,typ,args\r
- fonction,Etape,Genea,nomSIMP,typeSIMP,arguments = obj.editor.dicoNouveauxMC[t]\r
- texteModification += "MODIFICATION_CATALOGUE(Fonction = '" + str(fonction)+ "',\n"\r
- texteModification += " Etape = '" + str(Etape) + "',\n"\r
- texteModification += " Genea = " + str(Genea) + ",\n" \r
- texteModification += " NomSIMP = '" + str(nomSIMP) + "',\n"\r
- texteModification += " TypeSIMP = '" + str(typeSIMP)+ "',\n"\r
- texteModification += " PhraseArguments = " +'"' + str(arguments)+ '"'+ ",);\n"\r
- \r
-\r
- return texteModification\r
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2013 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# 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 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
+#
+"""
+ Ce module sert pour charger les parametres de configuration d'EFICAS
+"""
+# Modules Python
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
+import os, sys, types, re
+from Extensions.i18n import tr
+
+class ModificationGenerator(object):
+ def generTexteModif(self,obj):
+ texteModification=""
+ for t in list(obj.editor.dicoNouveauxMC.keys()) :
+ # 'ajoutDefinitionMC',etape,listeAvant,nomDuMC,typ,args
+ fonction,Etape,Genea,nomSIMP,typeSIMP,arguments = obj.editor.dicoNouveauxMC[t]
+ texteModification += "MODIFICATION_CATALOGUE(Fonction = '" + str(fonction)+ "',\n"
+ texteModification += " Etape = '" + str(Etape) + "',\n"
+ texteModification += " Genea = " + str(Genea) + ",\n"
+ texteModification += " NomSIMP = '" + str(nomSIMP) + "',\n"
+ texteModification += " TypeSIMP = '" + str(typeSIMP)+ "',\n"
+ texteModification += " PhraseArguments = " +'"' + str(arguments)+ '"'+ ",);\n"
+
+
+ return texteModification
"""
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
import traceback
-import types,string
+import types
from Noyau import N_CR
from Accas import MCSIMP,MCFACT,MCList
def entryPoint():
"""
- Retourne les informations nécessaires pour le chargeur de plugins
+ Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournées dans un dictionnaire
+ Ces informations sont retournees dans un dictionnaire
"""
return {
# Le nom du plugin
'name' : 'pyth',
- # La factory pour créer une instance du plugin
+ # La factory pour creer une instance du plugin
'factory' : PythGenerator,
}
-class PythGenerator:
+class PythGenerator(object):
"""
Ce generateur parcourt un objet de type MCFACT et produit
un fichier au format pyth
- L'acquisition et le parcours sont réalisés par la méthode
+ L'acquisition et le parcours sont realises par la methode
generator.gener(objet_mcfact)
- L'écriture du fichier au format ini par appel de la méthode
+ L'ecriture du fichier au format ini par appel de la methode
generator.writefile(nom_fichier)
- Ses caractéristiques principales sont exposées dans des attributs
+ Ses caracteristiques principales sont exposees dans des attributs
de classe :
- - extensions : qui donne une liste d'extensions de fichier préconisées
+ - extensions : qui donne une liste d'extensions de fichier preconisees
"""
- # Les extensions de fichier préconisées
+ # Les extensions de fichier preconisees
extensions=('.py','.comm')
def __init__(self,cr=None):
else:
self.cr=N_CR.CR(debut='CR generateur format ini',
fin='fin CR format ini')
- # Le texte au format pyth est stocké dans l'attribut text
+ # Le texte au format pyth est stocke dans l'attribut text
self.text=''
def writefile(self,filename):
def gener(self,obj,format='standard',config=None):
"""
- Tous les mots-clés simples du niveau haut sont transformés en variables
+ Tous les mots-cles simples du niveau haut sont transformes en variables
- Tous les mots-clés facteurs sont convertis en dictionnaires
+ Tous les mots-cles facteurs sont convertis en dictionnaires
- Les mots-clés multiples ne sont pas traités
+ Les mots-cles multiples ne sont pas traites
"""
s=''
if isinstance(obj,MCList):
valeur = self.generMCSIMP(mocle)
s=s+"%s = %s\n" % (mocle.nom,valeur)
else:
- self.cr.fatal("Entite inconnue ou interdite : "+`mocle`)
+ self.cr.fatal("Entite inconnue ou interdite : "+repr(mocle))
self.text=s
return self.text
def generMCFACT(self,obj):
"""
- Cette méthode convertit un mot-clé facteur
- en une chaine de caractères représentative d'un dictionnaire
+ Cette methode convertit un mot-cle facteur
+ en une chaine de caracteres representative d'un dictionnaire
"""
s = '{'
for mocle in obj.mc_liste:
valeur=self.generMCFACT(mocle)
s=s+"'%s' : %s,\n" % (mocle.nom,valeur)
else:
- self.cr.fatal(tr("Entite inconnue ou interdite : %s. Elle est ignoree", `mocle`))
+ self.cr.fatal(tr("Entite inconnue ou interdite : %s. Elle est ignoree", repr(mocle)))
s=s+'}'
return s
def generMCSIMP(self,obj):
"""
- Cette méthode convertit un mot-clé simple en une chaine de caractères
+ Cette methode convertit un mot-cle simple en une chaine de caracteres
au format pyth
"""
try:
s="%s" % obj.valeur
except Exception as e :
self.cr.fatal(tr("Type de valeur non supporte par le format pyth : n %(exception)s", \
- {'nom': obj.nom, 'exception': unicode(e)}))
+ {'nom': obj.nom, 'exception': str(e)}))
s="ERREUR"
python pour EFICAS.
"""
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+ from builtins import range
+except : pass
+
import traceback
-import types,string,re
+import types,re
from Noyau import N_CR
from Noyau.N_utils import repr_float
import Accas
import Extensions
from Extensions.parametre import ITEM_PARAMETRE
-from Formatage import Formatage
-from Formatage import FormatageLigne
+from .Formatage import Formatage
+from .Formatage import FormatageLigne
from Extensions.param2 import Formula
from Extensions.eficas_exception import EficasException
from Extensions.i18n import tr
}
-class PythonGenerator:
+class PythonGenerator(object):
"""
Ce generateur parcourt un objet de type JDC et produit
un fichier au format python
if format == 'brut':
self.text=liste
elif format == 'standard':
- self.text=string.join(liste)
+ self.text=''.join(liste)
elif format == 'beautifie':
jdc_formate = Formatage(liste,mode='.py')
self.text=jdc_formate.formate_jdc()
l.extend(self.generator(etape_niveau))
if l != [] :
# Si au moins une etape, on ajoute le retour chariot sur la derniere etape
- if type(l[-1])==types.ListType:
+ if type(l[-1])==list:
l[-1][-1] = l[-1][-1]+'\n'
- elif type(l[-1])==types.StringType:
+ elif type(l[-1])==bytes:
l[-1] = l[-1]+'\n'
return l
Cette methode convertit un COMMANDE_COMM
en une liste de chaines de caracteres a la syntaxe python
"""
- l_lignes = string.split(obj.valeur,'\n')
+ l_lignes = obj.valeur.split('\n')
txt=''
for ligne in l_lignes:
txt = txt + '##'+ligne+'\n'
# Dans la chaine de caracteres obj.valeur, on supprime le dernier
# saut de ligne
sans_saut = re.sub("\n$","",obj.valeur)
- l_lignes = string.split(sans_saut,'\n')
+ l_lignes = sans_saut.split('\n')
txt=''
i=1
for ligne in l_lignes:
"""
try:
sdname= self.generator(obj.sd)
- if string.find(sdname,'SD_') != -1: sdname='sansnom'
+ if sdname.find('SD_') != -1: sdname='sansnom'
except:
sdname='sansnom'
l=[]
l.append(mocle)
elif isinstance(v,Accas.MCSIMP) :
text=self.generator(v)
+ if text==None : text= ""
l.append(v.nom+'='+text)
else:
# MCFACT ou MCList
else:
# on est en presence d'un MCSIMP : on recupere une string
text =self.generator(v)
+ if text== None : text =""
if v.nom != "Consigne" : l.append(v.nom+'='+text)
# il faut etre plus subtil dans l'ajout de la virgule en differenciant
# le cas ou elle est obligatoire (si self a des freres cadets
l.append(mocle)
else:
data=self.generator(v)
- if type(data) == types.ListType:
+ if data==None : data= ""
+ if type(data) == list:
data[0]=v.nom+'='+data[0]
else:
data=v.nom+'='+data
def format_item(self,valeur,etape,obj,vientDeListe=0):
- if (type(valeur) == types.FloatType or 'R' in obj.definition.type) and not(isinstance(valeur,Accas.PARAMETRE)) :
+ if (type(valeur) == float or 'R' in obj.definition.type) and not(isinstance(valeur,Accas.PARAMETRE)) :
# Pour un flottant on utilise str ou repr si on vient d une liste
# ou la notation scientifique
# On ajoute un . si il n y en a pas dans la valeur
if vientDeListe and repr(valeur) != str(valeur) : s=repr(valeur)
if (s.find('.')== -1 and s.find('e')== -1 and s.find('E')==-1) : s=s+'.0'
clefobj=etape.get_sdname()
- if self.appli.appliEficas and self.appli.appliEficas.dict_reels.has_key(clefobj):
- if self.appli.appliEficas.dict_reels[clefobj].has_key(valeur):
+ if self.appli.appliEficas and clefobj in self.appli.appliEficas.dict_reels:
+ if valeur in self.appli.appliEficas.dict_reels[clefobj]:
s=self.appli.appliEficas.dict_reels[clefobj][valeur]
- elif type(valeur) == types.StringType :
+ elif type(valeur) == bytes :
if valeur.find('\n') == -1:
# pas de retour chariot, on utilise repr
s = repr(valeur)
syntaxe python
"""
waitTuple=0
- if type(obj.valeur) in (types.TupleType,types.ListType) :
+ if type(obj.valeur) in (tuple,list) :
s = ''
for ss_type in obj.definition.type:
if repr(ss_type).find('Tuple') != -1 :
PN
"""
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+try :
+ from builtins import range
+except :
+ pass
import traceback
-import types,string,re
+import types,re
import math
from Noyau import N_CR
import Accas
import Extensions
from Extensions.parametre import ITEM_PARAMETRE
-from Formatage import Formatage
-from generator_python import PythonGenerator
+from .Formatage import Formatage
+from .generator_python import PythonGenerator
+from six.moves import range
#from Editeur.widgets import showerror
def entryPoint():
self.list_commandes.append((self.commande,self.dict_attributs))
else :
#showerror("Elements ne portant pas sur un Groupe de Maille","Salome ne sait pas montrer ce type d' element")
- print ("Elements ne portant pas sur un Groupe de Maille","Salome ne sait pas montrer ce type d' element")
+ print(("Elements ne portant pas sur un Groupe de Maille","Salome ne sait pas montrer ce type d' element"))
pass
def generMCList(self,obj):
def CARA(self,obj) :
self.clefs=obj.val
- if type(self.clefs) == types.StringType :
+ if type(self.clefs) == bytes :
self.clefs=(obj.val,)
def VALE(self,obj) :
for k in range(len(atraiter)) :
clef=self.clefs[k]
val =atraiter[k]
- if isinstance(val, (types.TupleType, types.ListType)) and len(val) == 1:
+ if isinstance(val, (tuple, list)) and len(val) == 1:
val = val[0]
if isinstance (val, Extensions.parametre.PARAMETRE):
val=val.valeur
- print ( val.__class)
+ print(( val.__class))
context={}
if type(val) == type("aaa") :
for p in self.jdc.params:
context[p.nom]=eval(p.val,self.jdc.const_context, context)
- print (context[p.nom])
+ print((context[p.nom]))
res=eval(val,self.jdc.const_context, context)
val=res
self.dict_attributs[clef]=val
