home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_670 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  15.0 KB  |  459 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = [
  5.     'readPlist',
  6.     'writePlist',
  7.     'readPlistFromString',
  8.     'writePlistToString',
  9.     'readPlistFromResource',
  10.     'writePlistToResource',
  11.     'Plist',
  12.     'Data',
  13.     'Dict']
  14. import binascii
  15. import datetime
  16. from cStringIO import StringIO
  17. import re
  18. import warnings
  19.  
  20. def readPlist(pathOrFile):
  21.     didOpen = 0
  22.     if isinstance(pathOrFile, (str, unicode)):
  23.         pathOrFile = open(pathOrFile)
  24.         didOpen = 1
  25.     
  26.     p = PlistParser()
  27.     rootObject = p.parse(pathOrFile)
  28.     if didOpen:
  29.         pathOrFile.close()
  30.     
  31.     return rootObject
  32.  
  33.  
  34. def writePlist(rootObject, pathOrFile):
  35.     didOpen = 0
  36.     if isinstance(pathOrFile, (str, unicode)):
  37.         pathOrFile = open(pathOrFile, 'w')
  38.         didOpen = 1
  39.     
  40.     writer = PlistWriter(pathOrFile)
  41.     writer.writeln('<plist version="1.0">')
  42.     writer.writeValue(rootObject)
  43.     writer.writeln('</plist>')
  44.     if didOpen:
  45.         pathOrFile.close()
  46.     
  47.  
  48.  
  49. def readPlistFromString(data):
  50.     return readPlist(StringIO(data))
  51.  
  52.  
  53. def writePlistToString(rootObject):
  54.     f = StringIO()
  55.     writePlist(rootObject, f)
  56.     return f.getvalue()
  57.  
  58.  
  59. def readPlistFromResource(path, restype = 'plst', resid = 0):
  60.     warnings.warnpy3k('In 3.x, readPlistFromResource is removed.', stacklevel = 2)
  61.     FSRef = FSRef
  62.     FSGetResourceForkName = FSGetResourceForkName
  63.     import Carbon.File
  64.     fsRdPerm = fsRdPerm
  65.     import Carbon.Files
  66.     Res = Res
  67.     import Carbon
  68.     fsRef = FSRef(path)
  69.     resNum = Res.FSOpenResourceFile(fsRef, FSGetResourceForkName(), fsRdPerm)
  70.     Res.UseResFile(resNum)
  71.     plistData = Res.Get1Resource(restype, resid).data
  72.     Res.CloseResFile(resNum)
  73.     return readPlistFromString(plistData)
  74.  
  75.  
  76. def writePlistToResource(rootObject, path, restype = 'plst', resid = 0):
  77.     warnings.warnpy3k('In 3.x, writePlistToResource is removed.', stacklevel = 2)
  78.     FSRef = FSRef
  79.     FSGetResourceForkName = FSGetResourceForkName
  80.     import Carbon.File
  81.     fsRdWrPerm = fsRdWrPerm
  82.     import Carbon.Files
  83.     Res = Res
  84.     import Carbon
  85.     plistData = writePlistToString(rootObject)
  86.     fsRef = FSRef(path)
  87.     resNum = Res.FSOpenResourceFile(fsRef, FSGetResourceForkName(), fsRdWrPerm)
  88.     Res.UseResFile(resNum)
  89.     
  90.     try:
  91.         Res.Get1Resource(restype, resid).RemoveResource()
  92.     except Res.Error:
  93.         pass
  94.  
  95.     res = Res.Resource(plistData)
  96.     res.AddResource(restype, resid, '')
  97.     res.WriteResource()
  98.     Res.CloseResFile(resNum)
  99.  
  100.  
  101. class DumbXMLWriter:
  102.     
  103.     def __init__(self, file, indentLevel = 0, indent = '\t'):
  104.         self.file = file
  105.         self.stack = []
  106.         self.indentLevel = indentLevel
  107.         self.indent = indent
  108.  
  109.     
  110.     def beginElement(self, element):
  111.         self.stack.append(element)
  112.         self.writeln('<%s>' % element)
  113.         self.indentLevel += 1
  114.  
  115.     
  116.     def endElement(self, element):
  117.         self.indentLevel -= 1
  118.         self.writeln('</%s>' % element)
  119.  
  120.     
  121.     def simpleElement(self, element, value = None):
  122.         if value is not None:
  123.             value = _escapeAndEncode(value)
  124.             self.writeln('<%s>%s</%s>' % (element, value, element))
  125.         else:
  126.             self.writeln('<%s/>' % element)
  127.  
  128.     
  129.     def writeln(self, line):
  130.         if line:
  131.             self.file.write(self.indentLevel * self.indent + line + '\n')
  132.         else:
  133.             self.file.write('\n')
  134.  
  135.  
  136. _dateParser = re.compile('(?P<year>\\d\\d\\d\\d)(?:-(?P<month>\\d\\d)(?:-(?P<day>\\d\\d)(?:T(?P<hour>\\d\\d)(?::(?P<minute>\\d\\d)(?::(?P<second>\\d\\d))?)?)?)?)?Z')
  137.  
  138. def _dateFromString(s):
  139.     order = ('year', 'month', 'day', 'hour', 'minute', 'second')
  140.     gd = _dateParser.match(s).groupdict()
  141.     lst = []
  142.     for key in order:
  143.         val = gd[key]
  144.         if val is None:
  145.             break
  146.         
  147.         lst.append(int(val))
  148.     
  149.     return datetime.datetime(*lst)
  150.  
  151.  
  152. def _dateToString(d):
  153.     return '%04d-%02d-%02dT%02d:%02d:%02dZ' % (d.year, d.month, d.day, d.hour, d.minute, d.second)
  154.  
  155. _controlCharPat = re.compile('[\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x0b\\x0c\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f]')
  156.  
  157. def _escapeAndEncode(text):
  158.     m = _controlCharPat.search(text)
  159.     if m is not None:
  160.         raise ValueError("strings can't contains control characters; use plistlib.Data instead")
  161.     m is not None
  162.     text = text.replace('\r\n', '\n')
  163.     text = text.replace('\r', '\n')
  164.     text = text.replace('&', '&')
  165.     text = text.replace('<', '<')
  166.     text = text.replace('>', '>')
  167.     return text.encode('utf-8')
  168.  
  169. PLISTHEADER = '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n'
  170.  
  171. class PlistWriter(DumbXMLWriter):
  172.     
  173.     def __init__(self, file, indentLevel = 0, indent = '\t', writeHeader = 1):
  174.         if writeHeader:
  175.             file.write(PLISTHEADER)
  176.         
  177.         DumbXMLWriter.__init__(self, file, indentLevel, indent)
  178.  
  179.     
  180.     def writeValue(self, value):
  181.         if isinstance(value, (str, unicode)):
  182.             self.simpleElement('string', value)
  183.         elif isinstance(value, bool):
  184.             if value:
  185.                 self.simpleElement('true')
  186.             else:
  187.                 self.simpleElement('false')
  188.         elif isinstance(value, (int, long)):
  189.             self.simpleElement('integer', '%d' % value)
  190.         elif isinstance(value, float):
  191.             self.simpleElement('real', repr(value))
  192.         elif isinstance(value, dict):
  193.             self.writeDict(value)
  194.         elif isinstance(value, Data):
  195.             self.writeData(value)
  196.         elif isinstance(value, datetime.datetime):
  197.             self.simpleElement('date', _dateToString(value))
  198.         elif isinstance(value, (tuple, list)):
  199.             self.writeArray(value)
  200.         else:
  201.             raise TypeError('unsuported type: %s' % type(value))
  202.         return isinstance(value, (str, unicode))
  203.  
  204.     
  205.     def writeData(self, data):
  206.         self.beginElement('data')
  207.         self.indentLevel -= 1
  208.         maxlinelength = 76 - len(self.indent.replace('\t', '        ') * self.indentLevel)
  209.         for line in data.asBase64(maxlinelength).split('\n'):
  210.             if line:
  211.                 self.writeln(line)
  212.                 continue
  213.             self
  214.         
  215.         self.indentLevel += 1
  216.         self.endElement('data')
  217.  
  218.     
  219.     def writeDict(self, d):
  220.         self.beginElement('dict')
  221.         items = d.items()
  222.         items.sort()
  223.         for key, value in items:
  224.             if not isinstance(key, (str, unicode)):
  225.                 raise TypeError('keys must be strings')
  226.             isinstance(key, (str, unicode))
  227.             self.simpleElement('key', key)
  228.             self.writeValue(value)
  229.         
  230.         self.endElement('dict')
  231.  
  232.     
  233.     def writeArray(self, array):
  234.         self.beginElement('array')
  235.         for value in array:
  236.             self.writeValue(value)
  237.         
  238.         self.endElement('array')
  239.  
  240.  
  241.  
  242. class _InternalDict(dict):
  243.     
  244.     def __getattr__(self, attr):
  245.         
  246.         try:
  247.             value = self[attr]
  248.         except KeyError:
  249.             raise AttributeError, attr
  250.  
  251.         warn = warn
  252.         import warnings
  253.         warn('Attribute access from plist dicts is deprecated, use d[key] notation instead', PendingDeprecationWarning, 2)
  254.         return value
  255.  
  256.     
  257.     def __setattr__(self, attr, value):
  258.         warn = warn
  259.         import warnings
  260.         warn('Attribute access from plist dicts is deprecated, use d[key] notation instead', PendingDeprecationWarning, 2)
  261.         self[attr] = value
  262.  
  263.     
  264.     def __delattr__(self, attr):
  265.         
  266.         try:
  267.             del self[attr]
  268.         except KeyError:
  269.             raise AttributeError, attr
  270.  
  271.         warn = warn
  272.         import warnings
  273.         warn('Attribute access from plist dicts is deprecated, use d[key] notation instead', PendingDeprecationWarning, 2)
  274.  
  275.  
  276.  
  277. class Dict(_InternalDict):
  278.     
  279.     def __init__(self, **kwargs):
  280.         warn = warn
  281.         import warnings
  282.         warn('The plistlib.Dict class is deprecated, use builtin dict instead', PendingDeprecationWarning, 2)
  283.         super(Dict, self).__init__(**kwargs)
  284.  
  285.  
  286.  
  287. class Plist(_InternalDict):
  288.     
  289.     def __init__(self, **kwargs):
  290.         warn = warn
  291.         import warnings
  292.         warn('The Plist class is deprecated, use the readPlist() and writePlist() functions instead', PendingDeprecationWarning, 2)
  293.         super(Plist, self).__init__(**kwargs)
  294.  
  295.     
  296.     def fromFile(cls, pathOrFile):
  297.         rootObject = readPlist(pathOrFile)
  298.         plist = cls()
  299.         plist.update(rootObject)
  300.         return plist
  301.  
  302.     fromFile = classmethod(fromFile)
  303.     
  304.     def write(self, pathOrFile):
  305.         writePlist(self, pathOrFile)
  306.  
  307.  
  308.  
  309. def _encodeBase64(s, maxlinelength = 76):
  310.     maxbinsize = (maxlinelength // 4) * 3
  311.     pieces = []
  312.     for i in range(0, len(s), maxbinsize):
  313.         chunk = s[i:i + maxbinsize]
  314.         pieces.append(binascii.b2a_base64(chunk))
  315.     
  316.     return ''.join(pieces)
  317.  
  318.  
  319. class Data:
  320.     
  321.     def __init__(self, data):
  322.         self.data = data
  323.  
  324.     
  325.     def fromBase64(cls, data):
  326.         return cls(binascii.a2b_base64(data))
  327.  
  328.     fromBase64 = classmethod(fromBase64)
  329.     
  330.     def asBase64(self, maxlinelength = 76):
  331.         return _encodeBase64(self.data, maxlinelength)
  332.  
  333.     
  334.     def __cmp__(self, other):
  335.         if isinstance(other, self.__class__):
  336.             return cmp(self.data, other.data)
  337.         if isinstance(other, str):
  338.             return cmp(self.data, other)
  339.         return cmp(id(self), id(other))
  340.  
  341.     
  342.     def __repr__(self):
  343.         return '%s(%s)' % (self.__class__.__name__, repr(self.data))
  344.  
  345.  
  346.  
  347. class PlistParser:
  348.     
  349.     def __init__(self):
  350.         self.stack = []
  351.         self.currentKey = None
  352.         self.root = None
  353.  
  354.     
  355.     def parse(self, fileobj):
  356.         ParserCreate = ParserCreate
  357.         import xml.parsers.expat
  358.         parser = ParserCreate()
  359.         parser.StartElementHandler = self.handleBeginElement
  360.         parser.EndElementHandler = self.handleEndElement
  361.         parser.CharacterDataHandler = self.handleData
  362.         parser.ParseFile(fileobj)
  363.         return self.root
  364.  
  365.     
  366.     def handleBeginElement(self, element, attrs):
  367.         self.data = []
  368.         handler = getattr(self, 'begin_' + element, None)
  369.         if handler is not None:
  370.             handler(attrs)
  371.         
  372.  
  373.     
  374.     def handleEndElement(self, element):
  375.         handler = getattr(self, 'end_' + element, None)
  376.         if handler is not None:
  377.             handler()
  378.         
  379.  
  380.     
  381.     def handleData(self, data):
  382.         self.data.append(data)
  383.  
  384.     
  385.     def addObject(self, value):
  386.         if self.currentKey is not None:
  387.             self.stack[-1][self.currentKey] = value
  388.             self.currentKey = None
  389.         elif not self.stack:
  390.             self.root = value
  391.         else:
  392.             self.stack[-1].append(value)
  393.  
  394.     
  395.     def getData(self):
  396.         data = ''.join(self.data)
  397.         
  398.         try:
  399.             data = data.encode('ascii')
  400.         except UnicodeError:
  401.             pass
  402.  
  403.         self.data = []
  404.         return data
  405.  
  406.     
  407.     def begin_dict(self, attrs):
  408.         d = _InternalDict()
  409.         self.addObject(d)
  410.         self.stack.append(d)
  411.  
  412.     
  413.     def end_dict(self):
  414.         self.stack.pop()
  415.  
  416.     
  417.     def end_key(self):
  418.         self.currentKey = self.getData()
  419.  
  420.     
  421.     def begin_array(self, attrs):
  422.         a = []
  423.         self.addObject(a)
  424.         self.stack.append(a)
  425.  
  426.     
  427.     def end_array(self):
  428.         self.stack.pop()
  429.  
  430.     
  431.     def end_true(self):
  432.         self.addObject(True)
  433.  
  434.     
  435.     def end_false(self):
  436.         self.addObject(False)
  437.  
  438.     
  439.     def end_integer(self):
  440.         self.addObject(int(self.getData()))
  441.  
  442.     
  443.     def end_real(self):
  444.         self.addObject(float(self.getData()))
  445.  
  446.     
  447.     def end_string(self):
  448.         self.addObject(self.getData())
  449.  
  450.     
  451.     def end_data(self):
  452.         self.addObject(Data.fromBase64(self.getData()))
  453.  
  454.     
  455.     def end_date(self):
  456.         self.addObject(_dateFromString(self.getData()))
  457.  
  458.  
  459.