Fin de vie d'une classe

Bonsoir,

A la relecture de mon code, je tombe sur des points que j'avais laissé
à l'état flou en première intention, mais qui toutefois fonctionnent.
J'isole ce qui concerne la finalisation d'une instance de classe.

Premier cas, une interface Tkinter, le code (piqué quelque part sans
doute) me semble convenable (je simplifie):

class RepFTPApp(Tk):
def __init__(self):
Tk.__init__(self)
self.protocol("WM_DELETE_WINDOW", self.quit)
#etc.

def quit(self):
#sauvegardes diverses
Tk.destroy(self)


C'est le second cas qui me chagrine. Une classe client FTP:

class SourceSyncByFTP(ftplib.FTP):
def __init__(self, cl_options):
#etc.
if 'action' in self.dicodata and self.dicodata['action'] in
self.actions_dict:
self.actions_dict[self.dicodata['action']]()
self.__del__()

def __del__(self):
try:
ftplib.FTP.quit(self)
except:
ftplib.FTP.close(self)


Dans l'application actuelle, la classe est instanciée - plusieurs fois
- en 'one-shot', c'est à dire que l'instance meurt à la fin de
l'__init__(). Mais elle est utilisable en instanciation persistante,
avec gestion des reconnexions.
Il est clair dans ces conditions que le code du __del__() est
nécessaire, j'ai fait des tests sur un serveur limité à 1 ou 2
connexions entrantes qui le confirment.
Il est également évident que ce code ne détruit pas l'instance. Donc
c'est certainement idiot d'avoir nommé la méthode __del__. Ce serait
mieux de ne pas faire de méthode, ou de la nommer quelque chose comme
disconnect(), n'est-ce pas ?

Moi, ou plutôt le singe tenant la souris, sommes susceptibles
d'instancier frénétiquement. Passer en persistant serait lourd, je n'y
tiens pas. Je crois qu'il n'est pas possible de forcer la destruction
d'une instance à partir d'elle même, et que ce n'est ni joli ni
pratique de le faire depuis la classe cliente. Est-ce que, comme je le
crois, je m'inquiète inutilement, à partir du moment où je facilite le
travail de l'interprêteur (et du GC) en ne récupérant même pas
l'instance ? Ça ressemble à ça:

def doaction(self, action, noif=True):
#bla
try:
repftp.SourceSyncByFTP(options)
except repftp.ExpectedException, e:
if e.code is str and e.code[:5] == 'owned':
print '\nOWNED ! \n', e.message, '\n', e.cause
else:
print e.code, '\n', e.message, '\n', e.cause
except Exception, e:
print 'Unexpected Exception in '
print sys.exc_info()
#bla



Question subsidiaire: au départ, j'avais écrit:

def __del__(self):
try:
self.quit()
except:
self.close()

J'ai préféré modifier, pour qu'il soit clair à la lecture du code que
quit() et close() sont bien les méthodes de l'objet FTP. Est-ce
judicieux ?

Merci à tous, bonne soirée...

--
Pierre Maurette