Lines Matching refs:self

78     def __init__(self, data):
85 self.data = data
87 def __index__(self):
88 return self.data
90 def __repr__(self):
91 return "%s(%s)" % (self.__class__.__name__, repr(self.data))
93 def __reduce__(self):
94 return self.__class__, (self.data,)
96 def __eq__(self, other):
99 return self.data == other.data
101 def __hash__(self):
102 return hash(self.data)
174 def __init__(self, dict_type):
175 self.stack = []
176 self.current_key = None
177 self.root = None
178 self._dict_type = dict_type
180 def parse(self, fileobj):
181 self.parser = ParserCreate()
182 self.parser.StartElementHandler = self.handle_begin_element
183 self.parser.EndElementHandler = self.handle_end_element
184 self.parser.CharacterDataHandler = self.handle_data
185 self.parser.EntityDeclHandler = self.handle_entity_decl
186 self.parser.ParseFile(fileobj)
187 return self.root
189 def handle_entity_decl(self, entity_name, is_parameter_entity, value, base, system_id, public_id, notation_name):
195 def handle_begin_element(self, element, attrs):
196 self.data = []
197 handler = getattr(self, "begin_" + element, None)
201 def handle_end_element(self, element):
202 handler = getattr(self, "end_" + element, None)
206 def handle_data(self, data):
207 self.data.append(data)
209 def add_object(self, value):
210 if self.current_key is not None:
211 if not isinstance(self.stack[-1], type({})):
213 self.parser.CurrentLineNumber)
214 self.stack[-1][self.current_key] = value
215 self.current_key = None
216 elif not self.stack:
218 self.root = value
220 if not isinstance(self.stack[-1], type([])):
222 self.parser.CurrentLineNumber)
223 self.stack[-1].append(value)
225 def get_data(self):
226 data = ''.join(self.data)
227 self.data = []
232 def begin_dict(self, attrs):
233 d = self._dict_type()
234 self.add_object(d)
235 self.stack.append(d)
237 def end_dict(self):
238 if self.current_key:
240 (self.current_key,self.parser.CurrentLineNumber))
241 self.stack.pop()
243 def end_key(self):
244 if self.current_key or not isinstance(self.stack[-1], type({})):
246 self.parser.CurrentLineNumber)
247 self.current_key = self.get_data()
249 def begin_array(self, attrs):
251 self.add_object(a)
252 self.stack.append(a)
254 def end_array(self):
255 self.stack.pop()
257 def end_true(self):
258 self.add_object(True)
260 def end_false(self):
261 self.add_object(False)
263 def end_integer(self):
264 raw = self.get_data()
266 self.add_object(int(raw, 16))
268 self.add_object(int(raw))
270 def end_real(self):
271 self.add_object(float(self.get_data()))
273 def end_string(self):
274 self.add_object(self.get_data())
276 def end_data(self):
277 self.add_object(_decode_base64(self.get_data()))
279 def end_date(self):
280 self.add_object(_date_from_string(self.get_data()))
284 def __init__(self, file, indent_level=0, indent="\t"):
285 self.file = file
286 self.stack = []
287 self._indent_level = indent_level
288 self.indent = indent
290 def begin_element(self, element):
291 self.stack.append(element)
292 self.writeln("<%s>" % element)
293 self._indent_level += 1
295 def end_element(self, element):
296 assert self._indent_level > 0
297 assert self.stack.pop() == element
298 self._indent_level -= 1
299 self.writeln("</%s>" % element)
301 def simple_element(self, element, value=None):
304 self.writeln("<%s>%s</%s>" % (element, value, element))
307 self.writeln("<%s/>" % element)
309 def writeln(self, line):
316 self.file.write(self._indent_level * self.indent)
317 self.file.write(line)
318 self.file.write(b'\n')
323 self, file, indent_level=0, indent=b"\t", writeHeader=1,
328 _DumbXMLWriter.__init__(self, file, indent_level, indent)
329 self._sort_keys = sort_keys
330 self._skipkeys = skipkeys
332 def write(self, value):
333 self.writeln("<plist version=\"1.0\">")
334 self.write_value(value)
335 self.writeln("</plist>")
337 def write_value(self, value):
339 self.simple_element("string", value)
342 self.simple_element("true")
345 self.simple_element("false")
349 self.simple_element("integer", "%d" % value)
354 self.simple_element("real", repr(value))
357 self.write_dict(value)
360 self.write_bytes(value)
363 self.simple_element("date", _date_to_string(value))
366 self.write_array(value)
371 def write_bytes(self, data):
372 self.begin_element("data")
373 self._indent_level -= 1
376 76 - len(self.indent.replace(b"\t", b" " * 8) * self._indent_level))
380 self.writeln(line)
381 self._indent_level += 1
382 self.end_element("data")
384 def write_dict(self, d):
386 self.begin_element("dict")
387 if self._sort_keys:
394 if self._skipkeys:
397 self.simple_element("key", key)
398 self.write_value(value)
399 self.end_element("dict")
402 self.simple_element("dict")
404 def write_array(self, array):
406 self.begin_element("array")
408 self.write_value(value)
409 self.end_element("array")
412 self.simple_element("array")
449 def __init__(self, message="Invalid file"):
450 ValueError.__init__(self, message)
464 def __init__(self, dict_type):
465 self._dict_type = dict_type
467 def parse(self, fp):
474 self._fp = fp
475 self._fp.seek(-32, os.SEEK_END)
476 trailer = self._fp.read(32)
480 offset_size, self._ref_size, num_objects, top_object,
483 self._fp.seek(offset_table_offset)
484 self._object_offsets = self._read_ints(num_objects, offset_size)
485 self._objects = [_undefined] * num_objects
486 return self._read_object(top_object)
492 def _get_size(self, tokenL):
495 m = self._fp.read(1)[0] & 0x3
498 return struct.unpack(f, self._fp.read(s))[0]
502 def _read_ints(self, n, size):
503 data = self._fp.read(size * n)
512 def _read_refs(self, n):
513 return self._read_ints(n, self._ref_size)
515 def _read_object(self, ref):
521 result = self._objects[ref]
525 offset = self._object_offsets[ref]
526 self._fp.seek(offset)
527 token = self._fp.read(1)[0]
546 result = int.from_bytes(self._fp.read(1 << tokenL),
550 result = struct.unpack('>f', self._fp.read(4))[0]
553 result = struct.unpack('>d', self._fp.read(8))[0]
556 f = struct.unpack('>d', self._fp.read(8))[0]
563 s = self._get_size(tokenL)
564 result = self._fp.read(s)
569 s = self._get_size(tokenL)
570 data = self._fp.read(s)
576 s = self._get_size(tokenL) * 2
577 data = self._fp.read(s)
584 result = UID(int.from_bytes(self._fp.read(1 + tokenL), 'big'))
587 s = self._get_size(tokenL)
588 obj_refs = self._read_refs(s)
590 self._objects[ref] = result
591 result.extend(self._read_object(x) for x in obj_refs)
600 s = self._get_size(tokenL)
601 key_refs = self._read_refs(s)
602 obj_refs = self._read_refs(s)
603 result = self._dict_type()
604 self._objects[ref] = result
607 result[self._read_object(k)] = self._read_object(o)
613 self._objects[ref] = result
632 def __init__(self, fp, sort_keys, skipkeys):
633 self._fp = fp
634 self._sort_keys = sort_keys
635 self._skipkeys = skipkeys
637 def write(self, value):
640 self._objlist = []
646 self._objtable = {}
647 self._objidtable = {}
650 self._flatten(value)
654 num_objects = len(self._objlist)
655 self._object_offsets = [0]*num_objects
656 self._ref_size = _count_to_size(num_objects)
658 self._ref_format = _BINARY_FORMAT[self._ref_size]
661 self._fp.write(b'bplist00')
664 for obj in self._objlist:
665 self._write_object(obj)
668 top_object = self._getrefnum(value)
669 offset_table_offset = self._fp.tell()
672 self._fp.write(struct.pack(offset_format, *self._object_offsets))
677 sort_version, offset_size, self._ref_size, num_objects,
680 self._fp.write(struct.pack('>5xBBBQQQ', *trailer))
682 def _flatten(self, value):
687 if (type(value), value) in self._objtable:
690 elif id(value) in self._objidtable:
694 refnum = len(self._objlist)
695 self._objlist.append(value)
697 self._objtable[(type(value), value)] = refnum
699 self._objidtable[id(value)] = refnum
706 if self._sort_keys:
711 if self._skipkeys:
718 self._flatten(o)
722 self._flatten(o)
724 def _getrefnum(self, value):
726 return self._objtable[(type(value), value)]
728 return self._objidtable[id(value)]
730 def _write_size(self, token, size):
732 self._fp.write(struct.pack('>B', token | size))
735 self._fp.write(struct.pack('>BBB', token | 0xF, 0x10, size))
738 self._fp.write(struct.pack('>BBH', token | 0xF, 0x11, size))
741 self._fp.write(struct.pack('>BBL', token | 0xF, 0x12, size))
744 self._fp.write(struct.pack('>BBQ', token | 0xF, 0x13, size))
746 def _write_object(self, value):
747 ref = self._getrefnum(value)
748 self._object_offsets[ref] = self._fp.tell()
750 self._fp.write(b'\x00')
753 self._fp.write(b'\x08')
756 self._fp.write(b'\x09')
761 self._fp.write(struct.pack('>Bq', 0x13, value))
765 self._fp.write(struct.pack('>BB', 0x10, value))
767 self._fp.write(struct.pack('>BH', 0x11, value))
769 self._fp.write(struct.pack('>BL', 0x12, value))
771 self._fp.write(struct.pack('>BQ', 0x13, value))
773 self._fp.write(b'\x14' + value.to_bytes(16, 'big', signed=True))
778 self._fp.write(struct.pack('>Bd', 0x23, value))
782 self._fp.write(struct.pack('>Bd', 0x33, f))
785 self._write_size(0x40, len(value))
786 self._fp.write(value)
791 self._write_size(0x50, len(value))
794 self._write_size(0x60, len(t) // 2)
796 self._fp.write(t)
802 self._fp.write(struct.pack('>BB', 0x80, value))
804 self._fp.write(struct.pack('>BH', 0x81, value))
806 self._fp.write(struct.pack('>BL', 0x83, value))
808 self._fp.write(struct.pack('>BQ', 0x87, value))
813 refs = [self._getrefnum(o) for o in value]
815 self._write_size(0xA0, s)
816 self._fp.write(struct.pack('>' + self._ref_format * s, *refs))
821 if self._sort_keys:
828 if self._skipkeys:
831 keyRefs.append(self._getrefnum(k))
832 valRefs.append(self._getrefnum(v))
835 self._write_size(0xD0, s)
836 self._fp.write(struct.pack('>' + self._ref_format * s, *keyRefs))
837 self._fp.write(struct.pack('>' + self._ref_format * s, *valRefs))