Lines Matching full:self
26 def default(self, obj): argument
30 return json.JSONEncoder.default(self, obj)
35 def __init__(self, value): argument
36 self.value = value
38 def __str__(self): argument
39 return str(self.value)
44 def __str__(self): argument
47 if self.value & (1 << bit):
59 def __str__(self): argument
62 flag = self.value & (1 << bit)
64 bits.append(self.flags.get(flag, f'bit-{bit}'))
65 return f'{self.value:#x} ({bits})'
70 def __str__(self): argument
71 return f'{self.value:#x} ({self.mapping.get(self.value, "<unknown>")})'
84 def __init__(self, name, bases, attrs): argument
86 self.fmt = '>' + ''.join(self.ctypes[f[0]] for f in self.fields)
101 def __init__(self, fd=None, offset=None, data=None): argument
110 buf_size = struct.calcsize(self.fmt)
117 values = struct.unpack(self.fmt, data)
118 self.__dict__ = dict((field[2], values[i])
119 for i, field in enumerate(self.fields))
121 def dump(self, is_json=False): argument
123 print(json.dumps(self.to_json(), indent=4, cls=ComplexEncoder))
126 for f in self.fields:
127 value = self.__dict__[f[2]]
135 def to_json(self): argument
136 return dict((f[2], self.__dict__[f[2]]) for f in self.fields)
148 def __init__(self, fd, cluster_size): argument
150 tail = struct.calcsize(self.fmt) % 8
154 self.cluster_size = cluster_size
155 self.read_bitmap_directory(fd)
158 def read_bitmap_directory(self, fd): argument
159 fd.seek(self.bitmap_directory_offset)
160 self.bitmap_directory = \
161 [Qcow2BitmapDirEntry(fd, cluster_size=self.cluster_size)
162 for _ in range(self.nb_bitmaps)]
164 def dump(self): argument
166 for entry in self.bitmap_directory:
170 def to_json(self): argument
172 fields_dict['bitmap_directory'] = self.bitmap_directory
188 def __init__(self, fd, cluster_size): argument
190 self.cluster_size = cluster_size
192 fd.seek(self.extra_data_size, 1)
193 bitmap_name = fd.read(self.name_size)
194 self.name = bitmap_name.decode('ascii')
196 entry_raw_size = self.bitmap_dir_entry_raw_size()
199 self.bitmap_table = Qcow2BitmapTable(fd=fd,
200 offset=self.bitmap_table_offset,
201 nb_entries=self.bitmap_table_size,
202 cluster_size=self.cluster_size)
204 def bitmap_dir_entry_raw_size(self): argument
205 return struct.calcsize(self.fmt) + self.name_size + \
206 self.extra_data_size
208 def dump(self): argument
209 print(f'{"Bitmap name":<25} {self.name}')
210 super(Qcow2BitmapDirEntry, self).dump()
211 self.bitmap_table.dump()
213 def to_json(self): argument
216 'name': self.name,
218 'bitmap_table': self.bitmap_table
232 def __init__(self, fd): argument
234 self.reserved = self.entry & self.BME_TABLE_ENTRY_RESERVED_MASK
235 self.offset = self.entry & self.BME_TABLE_ENTRY_OFFSET_MASK
236 if self.offset:
237 if self.entry & self.BME_TABLE_ENTRY_FLAG_ALL_ONES:
238 self.type = 'invalid'
240 self.type = 'serialized'
241 elif self.entry & self.BME_TABLE_ENTRY_FLAG_ALL_ONES:
242 self.type = 'all-ones'
244 self.type = 'all-zeroes'
246 def to_json(self): argument
247 return {'type': self.type, 'offset': self.offset,
248 'reserved': self.reserved}
253 def __init__(self, fd, offset, nb_entries, cluster_size): argument
254 self.cluster_size = cluster_size
257 self.entries = [Qcow2BitmapTableEntry(fd) for _ in range(nb_entries)]
260 def dump(self): argument
261 bitmap_table = enumerate(self.entries)
265 size = self.cluster_size
270 def to_json(self): argument
271 return self.entries
288 def to_json(self): argument
289 return self.mapping.get(self.value, "<unknown>")
298 def __init__(self, magic=None, length=None, data=None, fd=None, argument
317 self.magic = magic
318 self.length = length
322 self.data = data
326 if self.magic == QCOW2_EXT_MAGIC_BITMAPS:
327 self.obj = Qcow2BitmapExt(fd=fd, cluster_size=cluster_size)
328 self.data = None
330 padded = (self.length + 7) & ~7
331 self.data = fd.read(padded)
332 assert self.data is not None
333 self.obj = None
335 if self.data is not None:
336 data_str = self.data[:self.length]
342 self.data_str = data_str
345 def dump(self): argument
348 if self.obj is None:
349 print(f'{"data":<25} {self.data_str}')
351 self.obj.dump()
353 def to_json(self): argument
355 res = {'name': self.Magic(self.magic), **super().to_json()}
356 if self.obj is not None:
357 res['data'] = self.obj
359 res['data_str'] = self.data_str
394 def __init__(self, fd): argument
397 self.set_defaults()
398 self.cluster_size = 1 << self.cluster_bits
400 fd.seek(self.header_length)
401 self.load_extensions(fd)
403 if self.backing_file_offset:
404 fd.seek(self.backing_file_offset)
405 self.backing_file = fd.read(self.backing_file_size)
407 self.backing_file = None
409 def set_defaults(self): argument
410 if self.version == 2:
411 self.incompatible_features = 0
412 self.compatible_features = 0
413 self.autoclear_features = 0
414 self.refcount_order = 4
415 self.header_length = 72
417 def load_extensions(self, fd): argument
418 self.extensions = []
420 if self.backing_file_offset != 0:
421 end = min(self.cluster_size, self.backing_file_offset)
423 end = self.cluster_size
426 ext = QcowHeaderExtension(fd=fd, cluster_size=self.cluster_size)
430 self.extensions.append(ext)
432 def update_extensions(self, fd): argument
434 fd.seek(self.header_length)
435 extensions = self.extensions
442 if self.backing_file is not None:
443 self.backing_file_offset = fd.tell()
444 fd.write(self.backing_file)
446 if fd.tell() > self.cluster_size:
449 def update(self, fd): argument
450 header_bytes = self.header_length
452 self.update_extensions(fd)
455 header = tuple(self.__dict__[f] for t, p, f in QcowHeader.fields)
460 def dump_extensions(self, is_json=False): argument
462 print(json.dumps(self.extensions, indent=4, cls=ComplexEncoder))
465 for ex in self.extensions: