home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / python2.4 / site-packages / serpentine / xspf.pyo (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  4.5 KB  |  142 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. """
  5. This is a very simple utility module for retrieving basic XSPF playlist data.
  6. Basically it retrieves the playlist tracks' title, artist, location and duration.
  7. """
  8. from xml.dom import minidom
  9. from xml.xpath import Evaluate
  10. from xml.dom.minidom import getDOMImplementation
  11.  
  12. class _Field(object):
  13.     
  14.     def __init__(self, id = None, convert = None):
  15.         self.id = id
  16.         self.convert = convert
  17.  
  18.     data = None
  19.     
  20.     def toxml(self, doc, root):
  21.         if self.data is not None:
  22.             node = doc.createElement(self.id)
  23.             node.appendChild(doc.createTextNode(str(self.data)))
  24.             root.appendChild(node)
  25.         
  26.  
  27.  
  28.  
  29. class _Struct(object):
  30.     _fields = { }
  31.     
  32.     def __init__(self, **kw):
  33.         for key in kw:
  34.             self._fields[key].data = kw[key]
  35.         
  36.  
  37.     
  38.     def __setattr__(self, attr, value):
  39.         if attr in self._fields:
  40.             self._fields[attr].data = value
  41.         else:
  42.             self.__dict__[attr] = value
  43.  
  44.     
  45.     def __getattr__(self, attr):
  46.         if attr in self._fields:
  47.             return self._fields[attr].data
  48.         else:
  49.             raise AttributeError, "Instance has no attribute '%s'" % attr
  50.  
  51.     
  52.     def toxml(self, doc, root):
  53.         for key in self._fields:
  54.             self._fields[key].toxml(doc, root)
  55.         
  56.  
  57.     
  58.     def _parse_node(self, node):
  59.         for field in self._fields:
  60.             
  61.             try:
  62.                 avail_fields = Evaluate('%s' % field, node)
  63.                 if len(avail_fields) == 0:
  64.                     continue
  65.                 
  66.                 field_node = avail_fields[0]
  67.                 val = Evaluate('string()', field_node).strip()
  68.                 convert = self._fields[field].convert
  69.                 if convert:
  70.                     val = convert(val)
  71.                 
  72.                 self._fields[field].data = val
  73.             continue
  74.             except ValueError:
  75.                 continue
  76.             
  77.  
  78.         
  79.  
  80.  
  81.  
  82. class Track(_Struct):
  83.     
  84.     def __init__(self, **kw):
  85.         self._fields = {
  86.             'title': _Field('title'),
  87.             'creator': _Field('creator'),
  88.             'duration': _Field('duration', int),
  89.             'location': _Field('location') }
  90.         _Struct.__init__(self, **kw)
  91.  
  92.     
  93.     def toxml(self, doc, root):
  94.         node = doc.createElement('track')
  95.         root.appendChild(node)
  96.         return _Struct.toxml(self, doc, node)
  97.  
  98.  
  99.  
  100. class Playlist(_Struct):
  101.     
  102.     def __init__(self, **kw):
  103.         self._fields = {
  104.             'title': _Field('title'),
  105.             'creator': _Field('creator'),
  106.             'duration': _Field('duration', int),
  107.             'location': _Field('location') }
  108.         _Struct.__init__(self, **kw)
  109.         self.tracks = []
  110.  
  111.     
  112.     def toxml(self):
  113.         '''Returns a xml.dom.Document representing the XSPF playlist'''
  114.         DOM = getDOMImplementation()
  115.         doc = DOM.createDocument(None, 'playlist', None)
  116.         root = doc.documentElement
  117.         root.setAttribute('version', '0')
  118.         trackList = doc.createElement('trackList')
  119.         root.appendChild(trackList)
  120.         for t in self.tracks:
  121.             t.toxml(doc, trackList)
  122.         
  123.         return doc
  124.  
  125.     
  126.     def parse(self, file_or_filename):
  127.         root = minidom.parse(file_or_filename)
  128.         for track_node in Evaluate('/playlist/trackList/track', root):
  129.             t = Track()
  130.             t._parse_node(track_node)
  131.             self.tracks.append(t)
  132.         
  133.  
  134.  
  135. if __name__ == '__main__':
  136.     import sys
  137.     p = Playlist()
  138.     for arg in sys.argv[1:]:
  139.         print to_xml_string(p.parse_filename(arg))
  140.     
  141.  
  142.