supprimer un element !

supprimer un element ! - Python - Programmation

Marsh Posté le 05-06-2004 à 19:46:42    

Bonjour,  
 
dans le cadre de mes etudes en IUT infi a la rochelle, nous avons a elaborer un projet en Python + Glade , seulement k'ai un problème, une structure nous a été fournie par le professeur pour faciliter la partie Base de Données mais j'ai un problème avec celle çi.
E, fait je peut ajouter des eleves mais lorsque je souhaite en supprimer un j'ai le droit à  cette erreur :
 

Code :
  1. Traceback (most recent call last):
  2.   File "inscription.py", line 172, in on_Valider_clicked
  3.     self.controleur.suppression()
  4.   File "inscription.py", line 66, in suppression
  5.     self.supprimerEleve(self.fenetreSuppr.saisieIdent.get_text())
  6.   File "inscription.py", line 122, in supprimerEleve
  7.     lib.remove(EleveAVirer)
  8.   File "lib.py", line 137, in remove
  9.     raise 'panic : object "%s" can not be removed' % repr(obj)
  10. panic : object "('Jonathan Blanchet', '01/10/1985', '0251976039', '24 rue de Gaulle', 'jblanche')" can not be removed


Voila maintenant le code :  
Structures fournies :
entites.py :  

Code :
  1. import lib
  3. class Eleve(lib.Entity) :
  4. def __init__(self, ident ,  nom, date, tel, adr) :
  5.  lib.Entity.__init__(self)
  6.  self.ident = ident
  7.  self.nom = nom
  8.  self.date = date
  9.  self.tel = tel
  10.  self.adr = adr


 
 
lib.py :  

Code :
  1. # -*- coding: latin-1 -*-
  2. # Cette version de lib est prévue pour python 2.3
  3. # et gtk 2
  5. # Mini bibliothèque pour de petits prototypes dans le style de OOSE.
  6. # -----------------------------------------------------------------
  7. #
  8. # G.Louis - I.U.T. de La Rochelle - 2002, 2003, 2004
  9. #
  10. # (C) G. LOUIS - 2002, 2003, 2004
  11. #
  12. # Cette bibliothèque fournit des objets persistents pour les entités UML
  13. # (entités au sens de OOSE de Jacobson).
  14. # Cette bibliothèque fournit une super-classe pour les controleurs et les interfaces
  15. # au sens de OOSE.
  16. # Les fenêtres sont définies par glade, et implantées par libglade.
  17. # La connexion automatique des "handlers" aux "signals" est assurée.
  18. #
  19. # PERSISTENCE
  20. # -----------
  21. # Il faut initialiser la connexion à la "base de données" par
  22. #  lib.connect(<nom-du-fichier> ).
  23. #
  24. # A la fin du programme, il faut fermer la connexion par lib.commit() pour
  25. # assurer la persistence.
  26. #
  27. # Toutes les classes qui correspondent à des entités doivent :
  28. #  1. Etre des sous classes de Entity
  29. #  2. Invoquer le constructeur de cette classe : lib.Entity.__init__(self)
  30. #
  31. # Toutes les entités ont un "oid" accessible par l'attribut _oid, qu'il ne faut
  32. # évidemment jamais modifier.
  33. #
  34. # lib.instances(P) fournit la liste des instances de la classe P (à condition qu'il
  35. # s'agisse bien d'une classe qui respecte les règles ci-dessus).
  36. #
  37. # lib.remove(p) supprime l'objet persistent p de la base de données proprement dite.
  38. # p n'est plus accessible grâce à lib.instances(P) (où P est la classe de P), mais
  39. # peut rester accessible à partir d'autres objets persistents. Une exception est levée
  40. # si l'objet n'est pas dans la base.
  41. #
  42. #
  43. # CONTROLEURS.
  44. # -----------
  45. #
  46. # Les sous-classes de Controller doivent appeler le constructeur de la classe :
  47. #  lib.Controller.__init__(self, <nom du fichier glade> )
  48. #
  49. # Le controleur possède un attribut pour chaque Interface qui a été construite
  50. # pour lui (qui lui a été attachée). Voir ci-dessous, la documentation des Interfaces.
  51. #
  52. #
  53. # INTERFACES.
  54. # ----------
  55. #
  56. # Les sous-classes de Interface doivent appeler le constructeur de la classe :
  57. #  lib.Interface.__init__(self, nom_fenetre, contrôleur)
  58. # où nom_fenetre est le nom de la fenêtre, tel qu'on l'a fixé dans glade.
  59. #
  60. # Donc, chaque Interface (plus précisément chaque instance d'une sous-classe d'interface)
  61. # correspond à une fenêtre créée avec glade.
  62. #
  63. # Pour chacun des widgets de la fenêtre -- y compris la fenêtre elle même -- l'interface
  64. # possède un attribut. Le nom de cet attribut est le nom du widget dans glade. La
  65. # valeur de cet attribut est un objet gtk, auquel on peut envoyer les messages
  66. # définis par le module gtk.
  67. #
  68. # Une interface doit posséder une méthode pour chaque "signal handler" défini par glade,
  69. # pour sa fenêtre et pour les widgets que contient cette fenêtre. Par exemple
  70. #  def on_accept-clicked(self, widget) : ...
  71. # Toutefois, en l'absence de cette méthode, on connecte un "handler" par défaut,
  72. # qui imprime un message de rappel. Ceci permet un dévelopement incrémental du code.
  73. #
  74. # Chaque interface est "attachée" au controleur pour lequel elle a été construite.
  75. # L'interface possède l'attribut "controleur", pour enregistrer ce controleur.
  76. # A son tour, le contrôleur possédera un attribut qui porte le nom de la fenêtre glade
  77. # et qui enregistre l'interface créée pour cette fenêtre.
  78. #
  79. # Donc, si un controleur doit faire apparaître la fenêtre win2 à l'écran, on écrira :
  80. #  self.win2.win2.show()
  81. # dans une méthode du contrôleur. Car dans le contrôleur, self.win2 désigne l'interface
  82. # attachée au contrôleur pour gérer la fenêtre win2. Dans cette interface, win2 désigne
  83. # l'objet fenêtre gtk lui-même.
  84. #
  86. import pickle
  87. import os
  89. __trace__ = 4
  90. __DBRoot__ = None
  92. def connect(filePath) :
  93. global __DBRoot__, __filePath__, statusMsg
  94. __filePath__ = filePath
  95. if os.path.isfile(filePath) and os.access(filePath, os.R_OK) :
  96.  file = open(filePath)
  97.  __DBRoot__ = pickle.load(file)
  98.  file.close()
  99.  statusMsg = "existing database %s open." % filePath
  100. else : # file will be opened for writing by "commit"
  101.  __DBRoot__ = { }
  102.  statusMsg = "new database %s open." % filePath
  104. def commit() :
  105. if __DBRoot__ == None :
  106.  raise "panic : no file opened"
  107. file = open(__filePath__, "w" )
  108. pickle.dump(__DBRoot__, file)
  109. file.close()
  110. statusMsg = "database %s committed." % __filePath__
  112. class Entity :
  113. # Les sous-classes d'entity DOIVENT appeler Entity.__init__(self)
  114.    def __init__(self) :
  115.    # A database must be open
  116.       if __DBRoot__ == None :
  117.          raise "panic : no database opened."
  118.       k = self.__class__.__name__
  119.       if not __DBRoot__.has_key(k) : __DBRoot__[k] = [ 0 ]
  120.       self._oid = k + "#" + repr(__DBRoot__[k][0])
  121.       __DBRoot__[k][0] = __DBRoot__[k][0] + 1
  122.       __DBRoot__[k].append(self)
  124. def instances(_class) : # méthode qui rend la liste des instances
  125.    if __DBRoot__.has_key(_class.__name__) :
  126.       return __DBRoot__[_class.__name__][1:]
  127.    else :
  128.       return [ ] # no instances yet or user error ?
  130. def remove(obj) :
  131.    if __DBRoot__.has_key(obj.__class__.__name__) \
  132.          and obj in __DBRoot__[obj.__class__.__name__] :
  133.       __DBRoot__[obj.__class__.__name__].remove(obj)
  134.    elif __DBRoot__.has_key(obj.__class__.__name__) :
  135.       raise 'panic : object with oid "%s" can not be found to be removed' % obj._oid
  136.    else :
  137.       raise 'panic : object "%s" can not be removed' % repr(obj)
  139. #
  140. # CONTROLEURS.
  141. # -----------
  142. #
  144. import xml.parsers.expat
  146. # Constants for the states on the stack for the SAX parser.
  147. neutral = "neutral"
  148. window = "window"
  150. # The stack items are 3-uples.
  151. # The first element of these tuples are one of the constants above. 
  152. # The second element is a dictionnary where widgets should be added
  153. # The third element is a dictionary where signals should be added
  154. # (or None, if no window has been encounered, yet)
  155. # (See below, the structure of sig_dico)
  157. class DefaultHandler : # A default handler that prints a warning message
  158.    def __init__(self, win_name, handler_name) :
  159.       self.win_name = win_name
  160.       self.handler_name = handler_name
  161.    def handler(self, widget, * rest) :
  162.       print "WARNING : %s should define handler %s(self, widget)."\
  163.                                            % (self.win_name, self.handler_name)
  165. class Controller :
  166.    def __init__(self, gladefilename) :
  167.       self.gladefilename = gladefilename
  168.       ifile = open(gladefilename)
  169.       # sig_dico is a 3 level deep tree of dictionaries
  170.       # The first level associates each window name to a dictionary, which
  171.       # at the second level associates each widget name to a dictionary which
  172.       # at the third level associates each signal name to a handler name.
  173.       # See also method "tree" above.
  174.       self.sig_dico = { }
  175.       # stack of states to handle elements'nesting
  176.       self.states = [ ] ; self.states.append( (neutral, self.sig_dico, None) )
  177.       p = xml.parsers.expat.ParserCreate("ISO-8859-1" ) # "ISO-8859-1" ?
  178.       p.StartElementHandler = self.start_element
  179.       p.EndElementHandler = self.end_element
  180.       # p.CharacterDataHandler = self.char_data
  181.       p.ParseFile(ifile)
  182.       ifile.close()
  183.       if __trace__ >= 3 : self.tree()
  184.       # Dynamic attributes for windows. Will get an interface on attachment.
  185.       for w in self.sig_dico.keys() :
  186.          self.__dict__[w] = None # Dynamic attr definition
  187.    def tree(self) : # trace of the tree in self.sig_dico
  188.       for win in self.sig_dico.keys() :
  189.          print "Window", win
  190.          for wid in self.sig_dico[win].keys() :
  191.             print "   Widget", wid
  192.             for s in self.sig_dico[win][wid].keys() :
  193.                print "      Signal", s, "-> method", self.sig_dico[win][wid][s]
  194.    def start_element(self, xml_elt, attrs) :
  195.       if __trace__ >= 5 : print 'Start element:', xml_elt, attrs
  196.       state, widgets, signals = self.states[ -1 ]
  197.       if state == neutral and xml_elt == u"widget" :
  198.          if attrs[u"class"] == u"GtkWindow" :
  199.             winName = attrs[u"id"].encode()
  200.             widgets[winName] = { } # For the widgets
  201.             widgets[winName][winName] = { } # For the signals of the window itself
  202.             self.states.append( (window, widgets[winName], widgets[winName][winName]) )
  203.             if __trace__ >= 4 : print "push :", repr(xml_elt), repr(attrs[u"id"]), len(self.states)
  204.          else :
  205.             raise "Panic : Non-window widget %s at top-level of glade file" \
  206.                   % (attrs[u"id"].encode() , )
  207.       elif state == window and xml_elt == u"widget" :
  208.          widName = attrs[u"id"].encode()
  209.          if widName in widgets.keys() :
  210.             print " *** Panic : 2 widgets nommés <<%s>> dans la fenetre" % ( widName, )
  211.             import sys
  212.             sys.exit(1)
  213.          widgets[widName] = { } # For the signals of the widget
  214.          self.states.append( (window, widgets, widgets[widName]) )
  215.          if __trace__ >= 4 : print "push :", repr(xml_elt), repr(attrs[u"id"]), len(self.states)
  216.       elif state == window and xml_elt == u"signal" :
  217.          signals[ attrs[u"name"].encode() ] = attrs[u"handler"].encode()
  218.       if __trace__ >= 5 : print " >state :", self.states[-1]
  219.    def end_element(self, xml_elt) :
  220.       if __trace__ >= 5 : print "End element", repr(xml_elt)
  221.       if xml_elt == u"widget" :
  222.          self.states.pop()
  223.          if __trace__ >= 4 : print "pop :", repr(xml_elt), len(self.states)
  224.       if __trace__ >= 5 :
  225.          if len(self.states) > 0 :
  226.             print " < state :", self.states[-1]
  227.          else :
  228.             print " ** Stack empty."
  229.    def attach(self, itrf, win_name, glade_win) :
  230.       # self.tree()
  231.       # print self.sig_dico.keys()
  232.       if __trace__ >= 2 : print "Attaching :", win_name
  233.       if not self.sig_dico.has_key(win_name) :
  234.          raise "panic : controller has no %s window (%s)." \
  235.                                  % (win_name, repr(self.sig_dico.keys()))
  236.       win_dico = self.sig_dico[win_name]
  237.       self.__dict__[win_name] = itrf # Dynamic attr definition
  238.       for widget in win_dico.keys() :
  239.          if __trace__ >= 2 : print "   Defining :", widget
  240.          itrf.__dict__[widget] = glade_win.get_widget(widget) # Again
  241.          h_dico = win_dico[widget]
  242.          for signal_name in h_dico.keys() :
  243.             handler_name = h_dico[signal_name]
  244.             if __trace__ >= 2 : print "      handler for", signal_name, "is", handler_name,
  245.             if hasattr(itrf, handler_name) :
  246.                method = eval("itrf." + handler_name)
  247.                if __trace__ >= 2 : print ". It was connected."
  248.             else :
  249.                method = DefaultHandler(win_name, handler_name).handler
  250.                if __trace__ >= 2 : print ". A dummy handler was created."             
  251.             # print handler_name, '->', method
  252.             glade_win.signal_connect(handler_name, method)
  254. #
  255. # INTERFACES.
  256. # ----------
  257. #
  258. import gtk
  259. import gtk.glade
  261. class Interface :
  262.    def __init__(self, window_name, controleur) :
  263.       self.controleur = controleur
  264.       self.glade_win = gtk.glade.XML(controleur.gladefilename, window_name)
  265.       controleur.attach(self, window_name, self.glade_win)
  266.       # print dir(self)
  267.    def gtk_main_quit(self, widget) :
  268.       if __trace__ >= 3 : print "Std gtk_main_quit was called."
  269.       gtk.mainquit()


De nous :  
inscription.py

Code :
  1. import lib
  2. import gtk
  3. import entites
  5. class Controleur(lib.Controller):
  7. def __init__(self):
  8.  lib.Controller.__init__(self, "ecole_de_music.glade" )
  9.  self.execute()
  11. def execute(self):
  12.  lib.connect("bdEleves" )
  13.  self.fenetreMenu = ItrfMenu(self)
  14.  gtk.mainloop()
  15.  lib.commit()
  16.  print "Bye..."
  18. def afficherErreur(self, typeErreur, champVide):
  19.  self.uneErreur  = ItrfErreur(self,typeErreur, champVide)
  21. def fermerErreur(self):
  22.  self.erreur.erreur.hide()
  24. def verifierChamps(self):
  25.  global typeErreur
  26.  global champVide
  27.  if (self.fenetreInscription.entry1.get_text() == "" ) :
  28.   typeErreur = "Veuillez remplir le champ : "
  29.   champVide = "Nom et prenom"
  30.   self.afficherErreur(typeErreur, champVide)
  32.  elif (self.fenetreInscription.entry2.get_text() == "" ):
  33.   typeErreur = "Veuillez remplir le champ : "
  34.   champVide = "Date de naissance"
  35.   self.afficherErreur(typeErreur, champVide)
  37.  elif (self.fenetreInscription.entry3.get_text() == "" ):
  38.   typeErreur = "Veuillez remplir le champ : "
  39.   champVide = "Numero de telephone"
  40.   self.afficherErreur(typeErreur, champVide)
  42.  elif (self.fenetreInscription.entry4.get_text() == "" ):
  43.   typeErreur = "Veuillez remplir le champ : "
  44.   champVide = "Adresse"
  45.   self.afficherErreur(typeErreur, champVide)
  47.  elif (self.fenetreInscription.entry5.get_text() == "" ):
  48.   typeErreur = "Veuillez remplir le champ : "
  49.   champVide = "Identifiant"
  50.   self.afficherErreur(typeErreur, champVide)
  52.  else :
  53.   print("Ca marche" )
  54.   self.ajouterEleve(self.fenetreInscription.entry1.get_text(),\
  55.      self.fenetreInscription.entry2.get_text(),\
  56.      self.fenetreInscription.entry3.get_text(),\
  57.      self.fenetreInscription.entry4.get_text(),\
  58.      self.fenetreInscription.entry5.get_text())
  60. def suppression(self) :
  61.  if(self.fenetreSuppr.saisieIdent.get_text() == "" ) :
  62.   typeErreur = "Veuillez remplir le champ : "
  63.   champVide = "Identifiant"
  64.   self.afficherErreur(typeErreur, champVide)
  65.  else :
  66.   self.supprimerEleve(self.fenetreSuppr.saisieIdent.get_text())
  70. def retourMenu(self, str):
  71.  if (str == "suppr" ):
  72.   self.fenetreSuppr.fenetreSuppr.hide()
  73.  elif (str == "insc" ) :
  74.   self.fenetreInscription.fenetreInscription.hide()
  75.  elif (str == "modif" ) :
  76.   self.fenetreModif.fenetreModif.hide()
  77.  self.menu.menu.show()
  79. def ajout(self):
  80.  self.fenetreInscription = ItrfInscription(self)
  82. def modif(self):
  83.  self.fenetreModif = ItrfModif(self)
  85. def suppr(self):
  86.  self.fenetreSuppr = ItrfSuppr(self)
  88. def ajouterEleve(self, nom, date, tel, adr, ident):
  89.  Eleves = map(lambda e : e.ident, lib.instances(entites.Eleve))
  90.  if ident in Eleves :
  91.   typeErreur = "L'identifiant "+ident
  92.   champVide = "existe deja"
  93.   self.afficherErreur(typeErreur, champVide)
  94.   self.fenetreInscription.entry5.set_text("" )
  95.  else :
  96.   entites.Eleve(nom, date, tel, adr, ident)
  97.   typeErreur = "L'identifiant "+ident
  98.   champVide = "a ete ajoute."
  99.   self.afficherErreur(typeErreur, champVide)
  100.   self.fenetreInscription.entry1.set_text("" )
  101.   self.fenetreInscription.entry2.set_text("" )
  102.   self.fenetreInscription.entry3.set_text("" )
  103.   self.fenetreInscription.entry4.set_text("" )
  104.   self.fenetreInscription.entry5.set_text("" )
  106. def supprimerEleve(self , identifiant ):
  107.  Eleves = map(lambda e : [e.nom, e.date ,e.tel ,e.adr, e.ident], lib.instances(entites.Eleve))
  108.  print Eleves
  109.  i = 0
  110.  a=0
  111.  while i < len(Eleves):
  112.   idEleve = Eleves[i]
  113.   identElevASupr = idEleve [4]
  114.   if (identElevASupr == identifiant ):
  115.    print "je rentre dans le while"
  116.    nomElevASupr   = idEleve [0]
  117.    dateElevASupr  = idEleve [1]
  118.    telElevASupr   = idEleve [2]
  119.    adrElevASupr   = idEleve [3]
  120.    identElevASupr = idEleve [4]
  121.    EleveAVirer = (nomElevASupr,dateElevASupr,telElevASupr,adrElevASupr,identElevASupr)
  122.    lib.remove(EleveAVirer)
  123.    typeErreur = "L'identifiant : " + identifiant
  124.    champVide = "a ete supprime "
  125.    self.afficherErreur(typeErreur, champVide)
  126.    a=1
  127.   i+=1
  128.  if a == 0 :
  129.   typeErreur = "L'identifiant : " + identifiant
  130.   champVide = "n'existe pas "
  131.   self.afficherErreur(typeErreur, champVide)
  134. class ItrfMenu(lib.Interface):
  135. def __init__(self, ctrl):
  136.  lib.Interface.__init__(self, "menu", ctrl)
  138. def on_Ajout_clicked(self, widget):
  139.  self.controleur.ajout()
  141. def on_Modif_clicked(self, widget):
  142.  self.controleur.modif()
  144. def on_Suppr_clicked(self, widget):
  145.  self.controleur.suppr()
  147. class ItrfInscription(lib.Interface):
  149. def __init__(self, ctrl):
  150.  lib.Interface.__init__(self, "fenetreInscription", ctrl)
  152. def boutonValider_clicked(self, widget):
  153.  self.controleur.verifierChamps()
  155. def boutonPrecedent_clicked(self, widget):
  156.  self.controleur.retourMenu("insc" )
  158. def fenetreInscriptionDestroy(self, widget) :
  159.  gtk.mainquit()
  161. class ItrfModif(lib.Interface):
  163. def __init__(self, ctrl):
  164.  lib.Interface.__init__(self, "fenetreModif", ctrl)
  166. class ItrfSuppr(lib.Interface):
  168. def __init__(self, ctrl):
  169.  lib.Interface.__init__(self, "fenetreSuppr", ctrl)
  171. def on_Valider_clicked(self, widget):
  172.  self.controleur.suppression()
  174. def on_Precedent_clicked(self, widget):
  175.  self.controleur.retourMenu("suppr" )
  177. def fenetreInscriptionDestroy(self, widget) :
  178.  gtk.mainquit()
  180. class ItrfErreur(lib.Interface):
  182. def __init__(self, ctrl, typeErreur, champVide):
  183.  lib.Interface.__init__(self, "erreur", ctrl)
  184.  self.typeErreur.set_text(typeErreur)
  185.  self.champVide.set_text(champVide)
  187. def fermerErreurClicked(self, widget):
  188.  self.controleur.fermerErreur()
  190. def fenetreErreurDestroy(self) :
  191.  self.controleur.fermerErreur()
  196. Controleur()


 
Mon problème : Dans la fonction supprimerEleve je recrée l'élève mais pas comme il faut apparement le type de l'objet ne correspond pas c'est ça non ?
 
Voila je compte sur vous pour regler ce problème et m'aider a poursuivre mon apprentissage Merci !


Message édité par john8585 le 05-06-2004 à 20:00:28
Reply

Marsh Posté le 05-06-2004 à 19:46:42   

Reply

Marsh Posté le 05-06-2004 à 21:53:11    

UP

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed