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