eric: comparison Utilities/binplistlib.py

-:6a6a53f2d086
+:96f5a76e1845
 To generate plists with NSData/CFData values, wrap the values with the
 Data object. The value must be a bytes object.
 Date values can only be datetime.datetime objects.
 The exceptions InvalidPlistException and NotBinaryPlistException may be
 thrown to indicate that the data cannot be serialized or deserialized as
 a binary plist.
 Plist generation example:
 <pre>
 #      this list of conditions and the following disclaimer.
 #    * Redistributions in binary form must reproduce the above copyright
 #      notice, this list of conditions and the following disclaimer in the
 #      documentation and/or other materials provided with the distribution.
 #    * Neither the name of biplist nor the names of its contributors may be
 #      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
 raise InvalidPlistException(e)
 if didOpen:
 pathOrFile.close()
 return result
 def writePlist(rootObject, pathOrFile, binary=True):
 """
 Module function to write a plist file.
 @param rootObject reference to the object to be written
 writer.writeRoot(rootObject)
 if didOpen:
 pathOrFile.close()
 return
 def readPlistFromBytes(data):
 """
 Module function to read from a plist bytes object.
 @param data plist data (bytes)
 @return reference to the read object
 @exception InvalidPlistException raised to signal an invalid plist file
 """
 return readPlist(BytesIO(data))
 def writePlistToBytes(rootObject, binary=True):
 """
 Module function to write a plist bytes object.
 io = BytesIO()
 writer = PlistWriter(io)
 writer.writeRoot(rootObject)
 return io.getvalue()
 def is_stream_binary_plist(stream):
 """
 Module function to check, if the stream is a binary plist.
 @param stream plist stream (file object)
 PlistTrailer = namedtuple('PlistTrailer',
 'offsetSize, objectRefSize, offsetCount, topLevelObjectNumber, offsetTableOffset')
 PlistByteCounts = namedtuple('PlistByteCounts',
 'nullBytes, boolBytes, intBytes, realBytes, dateBytes, dataBytes, stringBytes, '
 'uidBytes, arrayBytes, setBytes, dictBytes')
 class PlistReader(object):
 """
 Class implementing the plist reader.
 """
 trailerContents = self.contents[-32:]
 try:
 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_contents = self.contents[offset:offset + offset_size]
 offset_i = 0
 while offset_i < self.trailer.offsetCount:
-begin = self.trailer.offsetSize*offset_i
+begin = self.trailer.offsetSize * offset_i
-tmp_contents = offset_contents[begin:begin+self.trailer.offsetSize]
+tmp_contents = offset_contents[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)
 result = self.readObject()
 Private method to read the object data.
 @return unpickled object
 """
 result = None
-tmp_byte = self.contents[self.currentOffset:self.currentOffset+1]
+tmp_byte = self.contents[self.currentOffset:self.currentOffset + 1]
 marker_byte = unpack("!B", tmp_byte)[0]
 format = (marker_byte >> 4) & 0x0f
 extra = marker_byte & 0x0f
 self.currentOffset += 1
 elif extra == 0b1000:
 result = False
 elif extra == 0b1001:
 result = True
 elif extra == 0b1111:
-pass # fill byte
+pass  # fill byte
 else:
 raise InvalidPlistException(
 "Invalid object found at offset: {0}".format(self.currentOffset - 1))
 # int
 elif format == 0b0001:
 result = set(self.readArray(extra))
 # dict
 elif format == 0b1101:
 extra = proc_extra(extra)
 result = self.readDict(extra)
 else:
 raise InvalidPlistException(
 "Invalid object found: {{format: {0}, extra: {1}}}".format(
 bin(format), bin(extra)))
 return result
 @param bytes length of the object (integer)
 @return integer object
 """
 result = 0
 original_offset = self.currentOffset
-data = self.contents[self.currentOffset:self.currentOffset+bytes]
+data = self.contents[self.currentOffset:self.currentOffset + bytes]
 result = self.getSizedInteger(data, bytes)
 self.currentOffset = original_offset + bytes
 return result
 def readReal(self, length):
 @param length length of the object (integer)
 @return float object
 """
 result = 0.0
 to_read = pow(2, length)
-data = self.contents[self.currentOffset:self.currentOffset+to_read]
+data = self.contents[self.currentOffset:self.currentOffset + to_read]
-if length == 2: # 4 bytes
+if length == 2:  # 4 bytes
 result = unpack('>f', data)[0]
-elif length == 3: # 8 bytes
+elif length == 3:  # 8 bytes
 result = unpack('>d', data)[0]
 else:
 raise InvalidPlistException(
 "Unknown real of length {0} bytes".format(to_read))
 return result
 def readRefs(self, count):
 """
 Private method to read References.
 @param count amount of the references (integer)
 @return list of references (list of integers)
 """
 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 ASCII encoded string
 """
 result = str(unpack("!{0}s".format(length),
-self.contents[self.currentOffset:self.currentOffset+length])[0],
+self.contents[self.currentOffset:self.currentOffset + length])[0],
 encoding="ascii")
 self.currentOffset += length
 return result
 def readUnicode(self, length):
 Private method to read an Unicode encoded string.
 @param length length of the string (integer)
 @return unicode encoded string
 """
-actual_length = length*2
+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", 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):
 Private method to read some bytes.
 @param length number of bytes to read (integer)
 @return Data object
 """
-result = self.contents[self.currentOffset:self.currentOffset+length]
+result = self.contents[self.currentOffset:self.currentOffset + length]
 self.currentOffset += length
 return Data(result)
 def readUid(self, length):
 """
 Private method to read a UID.
 @param length length of the UID (integer)
 @return Uid object
 """
-return Uid(self.readInteger(length+1))
+return Uid(self.readInteger(length + 1))
 def getSizedInteger(self, data, bytes):
 """
 Private method to read an integer of a specific size.
 result = unpack('>q', data)[0]
 else:
 raise InvalidPlistException("Encountered integer longer than 8 bytes.")
 return result
 class HashableWrapper(object):
 """
 Class wrapping a hashable value.
 """
 def __init__(self, value):
 self.value = value
 def __repr__(self):
 return "<HashableWrapper: %s>" % [self.value]
 class BoolWrapper(object):
 """
 Class wrapping a boolean value.
 """
 def __init__(self, value):
 self.value = value
 def __repr__(self):
 return "<BoolWrapper: %s>" % self.value
 class PlistWriter(object):
 """
 Class implementing the plist writer.
 """
 @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  # not isinstance(wrapped_root, HashableWrapper)
 self.computeOffsets(wrapped_root, asReference=should_reference_root, isRoot=True)
 self.trailer = self.trailer._replace(
-**{'objectRefSize':self.intSize(len(self.computedUniques))})
+**{'objectRefSize': self.intSize(len(self.computedUniques))})
 (_, output) = self.writeObjectReference(wrapped_root, output)
 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)),
+'offsetSize': self.intSize(len(output)),
-'offsetCount':len(self.computedUniques),
+'offsetCount': len(self.computedUniques),
-'offsetTableOffset':len(output),
+'offsetTableOffset': len(output),
-'topLevelObjectNumber':0
+'topLevelObjectNumber': 0
 })
 output = self.writeOffsetTable(output)
 output += pack('!xxxxxxBBQQQ', *self.trailer)
 self.file.write(output)
 else:
 return root
 def incrementByteCount(self, field, incr=1):
 self.byteCounts = self.byteCounts._replace(
-**{field:self.byteCounts.__getattribute__(field) + incr})
+**{field: self.byteCounts.__getattribute__(field) + incr})
 def computeOffsets(self, obj, asReference=False, isRoot=False):
 def check_key(key):
 if key is None:
 raise InvalidPlistException('Dictionary keys cannot be null in plists.')
 self.incrementByteCount('nullBytes')
 elif isinstance(obj, BoolWrapper):
 self.incrementByteCount('boolBytes')
 elif isinstance(obj, Uid):
 size = self.intSize(obj)
-self.incrementByteCount('uidBytes', incr=1+size)
+self.incrementByteCount('uidBytes', incr=1 + size)
 elif isinstance(obj, int):
 size = self.intSize(obj)
-self.incrementByteCount('intBytes', incr=1+size)
+self.incrementByteCount('intBytes', incr=1 + size)
 elif isinstance(obj, (float)):
 size = self.realSize(obj)
-self.incrementByteCount('realBytes', incr=1+size)
+self.incrementByteCount('realBytes', incr=1 + size)
 elif isinstance(obj, datetime.datetime):
 self.incrementByteCount('dateBytes', incr=2)
 elif isinstance(obj, Data):
 size = proc_size(len(obj))
-self.incrementByteCount('dataBytes', incr=1+size)
+self.incrementByteCount('dataBytes', incr=1 + size)
 elif isinstance(obj, str):
 size = proc_size(len(obj))
-self.incrementByteCount('stringBytes', incr=1+size)
+self.incrementByteCount('stringBytes', incr=1 + size)
 elif isinstance(obj, HashableWrapper):
 obj = obj.value
 if isinstance(obj, set):
 size = proc_size(len(obj))
-self.incrementByteCount('setBytes', incr=1+size)
+self.incrementByteCount('setBytes', incr=1 + size)
 for value in obj:
 self.computeOffsets(value, asReference=True)
 elif isinstance(obj, (list, tuple)):
 size = proc_size(len(obj))
-self.incrementByteCount('arrayBytes', incr=1+size)
+self.incrementByteCount('arrayBytes', incr=1 + size)
 for value in obj:
 self.computeOffsets(value, asReference=True)
 elif isinstance(obj, dict):
 size = proc_size(len(obj))
-self.incrementByteCount('dictBytes', incr=1+size)
+self.incrementByteCount('dictBytes', incr=1 + size)
 for key, value in obj.items():
 check_key(key)
 self.computeOffsets(key, asReference=True)
 self.computeOffsets(value, asReference=True)
 else:
 output += proc_variable_length(0b0100, len(obj))
 output += obj
 elif isinstance(obj, str):
 # Python 3 uses unicode strings only
 bytes = obj.encode('utf_16_be')
-output += proc_variable_length(0b0110, len(bytes)/2)
+output += proc_variable_length(0b0110, len(bytes) / 2)
 output += bytes
 elif isinstance(obj, HashableWrapper):
 obj = obj.value
 if isinstance(obj, (set, list, tuple)):
 if isinstance(obj, set):
 @return new output (bytes)
 """
 all_positions = []
 writtenReferences = list(self.writtenReferences.items())
 writtenReferences.sort(key=lambda x: x[1])
-for obj,order in writtenReferences:
+for obj, order in writtenReferences:
 position = self.referencePositions.get(obj)
 if position is None:
 raise InvalidPlistException(
 "Error while writing offsets table. Object not found. {0}"
 .format(obj))
 @param obj integer object
 @return number of bytes required (integer)
 """
 # SIGNED
-if obj < 0: # Signed integer, always 8 bytes
+if obj < 0:  # Signed integer, always 8 bytes
 return 8
 # UNSIGNED
-elif obj <= 0xFF: # 1 byte
+elif obj <= 0xFF:  # 1 byte
 return 1
-elif obj <= 0xFFFF: # 2 bytes
+elif obj <= 0xFFFF:  # 2 bytes
 return 2
-elif obj <= 0xFFFFFFFF: # 4 bytes
+elif obj <= 0xFFFFFFFF:  # 4 bytes
 return 4
 # SIGNED
 # 0x7FFFFFFFFFFFFFFF is the max.
-elif obj <= 0x7FFFFFFFFFFFFFFF: # 8 bytes
+elif obj <= 0x7FFFFFFFFFFFFFFF:  # 8 bytes
 return 8
 else:
 raise InvalidPlistException(
 "Core Foundation can't handle integers with size greater than 8 bytes.")

Mercurial Repositories > eric / file comparison

comparison: Utilities/binplistlib.py

Utilities/binplistlib.py