eric: comparison Utilities/binplistlib.py

-:c6f16f1b9958
+:7f0ef975da9e
 # Copyright (c) 2012 - 2013 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
-Module implementing a library for reading and writing binary property list files.
+Module implementing a library for reading and writing binary property list
+files.
 Binary Property List (plist) files provide a faster and smaller serialization
 format for property lists on OS X. This is a library for generating binary
 plists which can be read by OS X, iOS, or other clients.
 #      used to endorse or promote products derived from this software without
 #      specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
 #
 from collections import namedtuple
 from io import BytesIO
 import calendar
 return "Uid(%d)" % self
 class Data(bytes):
 """
-Class implementing a wrapper around bytes types for representing Data values.
+Class implementing a wrapper around bytes types for representing Data
+values.
 """
 pass
 class InvalidPlistException(Exception):
 def readPlist(pathOrFile):
 """
 Module function to read a plist file.
-@param pathOrFile name of the plist file (string) or an open file (file object)
+@param pathOrFile name of the plist file (string) or an open file
+(file object)
 @return reference to the read object
 @exception InvalidPlistException raised to signal an invalid plist file
 """
 didOpen = False
 result = None
 def writePlist(rootObject, pathOrFile, binary=True):
 """
 Module function to write a plist file.
 @param rootObject reference to the object to be written
-@param pathOrFile name of the plist file (string) or an open file (file object)
+@param pathOrFile name of the plist file (string) or an open file
-@param binary flag indicating the generation of a binary plist file (boolean)
+(file object)
+@param binary flag indicating the generation of a binary plist file
+(boolean)
 """
 if not binary:
 plistlib.writePlist(rootObject, pathOrFile)
 return
 else:
 return True
 else:
 return False
 PlistTrailer = namedtuple('PlistTrailer',
-'offsetSize, objectRefSize, offsetCount, topLevelObjectNumber, offsetTableOffset')
+'offsetSize, objectRefSize, offsetCount, topLevelObjectNumber,'
+' offsetTableOffset')
 PlistByteCounts = namedtuple('PlistByteCounts',
-'nullBytes, boolBytes, intBytes, realBytes, dateBytes, dataBytes, stringBytes, '
+'nullBytes, boolBytes, intBytes, realBytes, dateBytes, dataBytes,'
-'uidBytes, arrayBytes, setBytes, dictBytes')
+' stringBytes, uidBytes, arrayBytes, setBytes, dictBytes')
 class PlistReader(object):
 """
 Class implementing the plist reader.
 self.contents = self.file.read()
 if len(self.contents) < 32:
 raise InvalidPlistException("File is too short.")
 trailerContents = self.contents[-32:]
 try:
-self.trailer = PlistTrailer._make(unpack("!xxxxxxBBQQQ", trailerContents))
+self.trailer = PlistTrailer._make(
+unpack("!xxxxxxBBQQQ", trailerContents))
 offset_size = self.trailer.offsetSize * self.trailer.offsetCount
 offset = self.trailer.offsetTableOffset
 offset_contents = self.contents[offset:offset + offset_size]
 offset_i = 0
 while offset_i < self.trailer.offsetCount:
 begin = self.trailer.offsetSize * offset_i
-tmp_contents = offset_contents[begin:begin + self.trailer.offsetSize]
+tmp_contents = offset_contents[
-tmp_sized = self.getSizedInteger(tmp_contents, self.trailer.offsetSize)
+begin:begin + self.trailer.offsetSize]
+tmp_sized = self.getSizedInteger(
+tmp_contents, self.trailer.offsetSize)
 self.offsets.append(tmp_sized)
 offset_i += 1
-self.setCurrentOffsetToObjectNumber(self.trailer.topLevelObjectNumber)
+self.setCurrentOffsetToObjectNumber(
+self.trailer.topLevelObjectNumber)
 result = self.readObject()
 except TypeError as e:
 raise InvalidPlistException(e)
 return result
 result = True
 elif extra == 0b1111:
 pass  # fill byte
 else:
 raise InvalidPlistException(
-"Invalid object found at offset: {0}".format(self.currentOffset - 1))
+"Invalid object found at offset: {0}".format(
+self.currentOffset - 1))
 # int
 elif format == 0b0001:
 extra = proc_extra(extra)
 result = self.readInteger(pow(2, extra))
 # real
 """
 refs = []
 i = 0
 while i < count:
 fragment = self.contents[
-self.currentOffset:self.currentOffset + self.trailer.objectRefSize]
+self.currentOffset:
+self.currentOffset + self.trailer.objectRefSize]
 ref = self.getSizedInteger(fragment, len(fragment))
 refs.append(ref)
 self.currentOffset += self.trailer.objectRefSize
 i += 1
 return refs
 @param length length of the string (integer)
 @return unicode encoded string
 """
 actual_length = length * 2
-data = self.contents[self.currentOffset:self.currentOffset + actual_length]
+data = self.contents[
+self.currentOffset:self.currentOffset + actual_length]
 # unpack not needed?!! data = unpack(">%ds" % (actual_length), data)[0]
 self.currentOffset += actual_length
 return data.decode('utf_16_be')
 def readDate(self):
 Private method to read a date.
 @return date object (datetime.datetime)
 """
 global apple_reference_date_offset
-result = unpack(">d", self.contents[self.currentOffset:self.currentOffset + 8])[0]
+result = unpack(">d",
-result = datetime.datetime.utcfromtimestamp(result + apple_reference_date_offset)
+self.contents[self.currentOffset:self.currentOffset + 8])[0]
+result = datetime.datetime.utcfromtimestamp(
+result + apple_reference_date_offset)
 self.currentOffset += 8
 return result
 def readData(self, length):
 """
 elif bytes == 4:
 result = unpack('>L', data)[0]
 elif bytes == 8:
 result = unpack('>q', data)[0]
 else:
-raise InvalidPlistException("Encountered integer longer than 8 bytes.")
+raise InvalidPlistException(
+"Encountered integer longer than 8 bytes.")
 return result
 class HashableWrapper(object):
 """
 @param root reference to the object to be written
 """
 output = self.header
 wrapped_root = self.wrapRoot(root)
-should_reference_root = True  # not isinstance(wrapped_root, HashableWrapper)
+should_reference_root = True
-self.computeOffsets(wrapped_root, asReference=should_reference_root, isRoot=True)
+self.computeOffsets(
+wrapped_root, asReference=should_reference_root, isRoot=True)
 self.trailer = self.trailer._replace(
 **{'objectRefSize': self.intSize(len(self.computedUniques))})
 (_, output) = self.writeObjectReference(wrapped_root, output)
-output = self.writeObject(wrapped_root, output, setReferencePosition=True)
+output = self.writeObject(
+wrapped_root, output, setReferencePosition=True)
 # output size at this point is an upper bound on how big the
 # object reference offsets need to be.
 self.trailer = self.trailer._replace(**{
 'offsetSize': self.intSize(len(output)),
 @exception InvalidPlistException raised to indicate an invalid
 plist file
 """                                             # __IGNORE_WARNING__
 def check_key(key):
 if key is None:
-raise InvalidPlistException('Dictionary keys cannot be null in plists.')
+raise InvalidPlistException(
+'Dictionary keys cannot be null in plists.')
 elif isinstance(key, Data):
-raise InvalidPlistException('Data cannot be dictionary keys in plists.')
+raise InvalidPlistException(
+'Data cannot be dictionary keys in plists.')
 elif not isinstance(key, str):
 raise InvalidPlistException('Keys must be strings.')
 def proc_size(size):
 if size > 0b1110:
 self.writtenReferences[obj] = len(self.writtenReferences)
 output += self.binaryInt(len(self.writtenReferences) - 1,
 bytes=self.trailer.objectRefSize)
 return (True, output)
 else:
-output += self.binaryInt(position, bytes=self.trailer.objectRefSize)
+output += self.binaryInt(
+position, bytes=self.trailer.objectRefSize)
 return (False, output)
 def writeObject(self, obj, output, setReferencePosition=False):
 """
 Private method to serialize the given object to the output.
 for objRef in obj:
 (isNew, output) = self.writeObjectReference(objRef, output)
 if isNew:
 objectsToWrite.append(objRef)
 for objRef in objectsToWrite:
-output = self.writeObject(objRef, output, setReferencePosition=True)
+output = self.writeObject(
+objRef, output, setReferencePosition=True)
 elif isinstance(obj, dict):
 output += proc_variable_length(0b1101, len(obj))
 keys = []
 values = []
 objectsToWrite = []
 for value in values:
 (isNew, output) = self.writeObjectReference(value, output)
 if isNew:
 objectsToWrite.append(value)
 for objRef in objectsToWrite:
-output = self.writeObject(objRef, output, setReferencePosition=True)
+output = self.writeObject(
+objRef, output, setReferencePosition=True)
 return output
 def writeOffsetTable(self, output):
 """
 Private method to write all of the object reference offsets.
 result += pack('>L', obj)
 elif bytes == 8:
 result += pack('>q', obj)
 else:
 raise InvalidPlistException(
-"Core Foundation can't handle integers with size greater than 8 bytes.")
+"Core Foundation can't handle integers with size greater"
+" than 8 bytes.")
 return result
 def intSize(self, obj):
 """
 Private method to determine the number of bytes necessary to store the
 # 0x7FFFFFFFFFFFFFFF is the max.
 elif obj <= 0x7FFFFFFFFFFFFFFF:  # 8 bytes
 return 8
 else:
 raise InvalidPlistException(
-"Core Foundation can't handle integers with size greater than 8 bytes.")
+"Core Foundation can't handle integers with size greater"
+" than 8 bytes.")
 def realSize(self, obj):
 """
 Private method to determine the number of bytes necessary to store the
 given real.

Mercurial Repositories > eric / file comparison

comparison: Utilities/binplistlib.py

Utilities/binplistlib.py