LIRE ET PARSER UN FICHIER NZB ( XML AVEC SAX)

# -*- coding: utf-8	  -*-

#-#####################################################
#- Classe permetant de gerer les fichiers Nzb						#
#-
#-  Ce code n'est que la partie d'un projet plus vaste dans le but est de réaliser un client usenet
#- en python ou en C++
#- Ce code doit etre amélioré notament en geran au mieu les exceptions et en ajputant d'autres fonctionnalite
#- temps passe a coder et valider = 2H 
#- Coded by azalsup@free.fr
#- Code ouvert sans conditions
#-
#-#####################################################

__revision__ = 0.1

# Les includes se font par ici
from xml.sax import make_parser
from xml.sax.handler import ContentHandler 


#Les fonctions elementaires necessaires au bon fonctionnement du programme
def END() :
	"""Areter le programme"""
	sys.exit()

def ERROR(msg):
	"""Affiche un message d'erreur"""
	
	print '#'*len(msg)
	print msg
	print '#'*len(msg)
	END()

def WARNING(msg):
	"""Affiche un message de prevention"""
	
	print '*'*len(msg)
	print msg
	print '*'*len(msg)
	
def INFO(msg):
	"""Affiche un message d'information"""
	
	print '@'*len(msg)
	print msg
	print '@'*len(msg)

#Classe pour gerer un segment de fichier
class NzbSegment :
	"""Classe pour refferencer un segment d'un fichier"""
		
	def __init__(self, bytes , number , content = ''):
		"""Constructeur de la classe"""
		self.bytes = bytes
		self.number = number
		self.content = content
	
	def addContent(self, content):
		"""Modifier la valeur de self.content"""
		self.content += content
		
	def getContent(self):
		"""Retourne la valeur de self.content"""
		return self.content
		
#Classe pour stocker les ref. d'un fichier du Nzb
class NzbFile:
	"""Les ref. d'un fichier refference dans le Nzb"""
		
	def __init__(self, subject, date , poster):
		"""Constructeur de la classe"""
		self.subject = subject
		self.date = date
		self.poster = poster
		
		self.groups = []
		self.segments = []
		
		
	def addGroup(self, group):
		"""Ajouter un groupe"""
		self.groups.append(group)
	
	def addGroups(self, groups) :
		"""Ajouter plusieurs groupes a la fois"""
		self.groups += groups
		
	def addSegment(self, segment):
		"""Ajouter un segment"""
		self.segments.append(segment)
	
	
	
#Classe pour parser le fichier Nzb
class NzbHandler(ContentHandler) :
	'''Classe pour parser le fichier nzb'''
		
	def __init__(self):
		"""initialisation"""
		self.files = []
		self.nbNzb = 0
		
		#Si cette valeur est a True on est dans une balise nzb
		self.e_nzb = False
		self.tmpFile = None
		self.tmpGroups = None
		self.tmpGroup = None
		self.tmpSegments = None
		self.tmpSegment = None
	
	def addFile(self, file):
		""" Ajouter un fichier"""
		self.files.append(file)
		
		
	def startDocument(self):
		"""fonction appelée lorsque le parser rencontre le premier élement"""
		pass
	
	def startElement(self, name, attrs):
		"""fonction appelée lorsque le parser rencontre une balise ouvrante"""
		if name == "nzb" :
			self.nbNzb += 1
			self.e_nzb = True
		
		elif name == "file" and self.e_nzb:
			self.tmpFile = NzbFile(attrs.getValue('subject'), attrs.getValue('date') , attrs.getValue('poster'))
			
		elif name == 'groups' and self.tmpFile != None :
			self.tmpGroups = []
	
		elif name == 'group' and self.tmpGroups != None :
			self.tmpGroup = ''	
			
		elif name == 'segments' and self.tmpFile != None :
			self.tmpSegments = []
	
		elif name == 'segment' and self.tmpSegments != None :
			self.tmpSegment = NzbSegment(attrs.getValue('bytes') , attrs.getValue('number') )
			
	def endElement(self, name):
		"""fonction appelée lorsque le parser rencontre une balise fermante"""
		if name == "nzb" :
			self.e_nzb = False
		
		elif name == "file" and self.e_nzb:
			self.files.append(self.tmpFile)
			self.tmpFile = None
			
		elif name == 'groups' and self.tmpFile != None :
			self.tmpFile.addGroups(self.tmpGroups)
			self.tmpGroups = None
	
		elif name == 'group' and self.tmpGroups != None :
			self.tmpGroups.append(self.tmpGroup)
			self.tmpGroup = None
			
		elif name == 'segments' and self.tmpFile != None :
			self.tmpSegments = None
	
		elif name == 'segment' and self.tmpSegments != None :
			self.tmpFile.addSegment(self.tmpSegment)
			self.tmpSegment = None
			
	def characters(self, chrs):
		"""fonction appelée lorsque le parser rencontre des données dans un élement"""
		if self.tmpGroup != None :
			self.tmpGroup += chrs
			
		elif self.tmpSegment != None :
			self.tmpSegment.addContent(chrs)
			
	def endDocument(self):
		"""fonction appelée lorsque le parser rencontre le dernier élement"""
		pass
	
# Entree principale du programme	
if __name__ == "__main__" :
	
	_doc = NzbHandler()
	_saxparser = make_parser()
	_saxparser.setContentHandler(_doc)

	_datasource = open("test.nzb","r")
	_saxparser.parse(_datasource)
	
	for _f in _doc.files :
		print "#"*8
		
		print "Sujet :",_f.subject
		print "Date :",_f.date
		print "Poster :",_f.poster
		
		print "Liste des groupes :"
		print "___________________"
		for _g in _f.groups :
			print " -", _g
		
		print "Liste des segments :"
		print "____________________"
		for _s in _f.segments :
			print _s.bytes,'-', _s.bytes, '-', _s.number, '-', _s.content