def export_unusual_file_modes(self, rev): try: file_modes = rev.properties[u'file-modes'] except KeyError: return {} else: return dict(bencode.bdecode(file_modes.encode("utf-8")))
def read_revision_from_string(self, text): # TODO: consider writing a Revision decoder, rather than using the # generic bencode decoder # However, to decode all 25k revisions of bzr takes approx 1.3s # If we remove all extra validation that goes down to about 1.2s. # Of that time, probably 0.6s is spend in bencode.bdecode(). # Regardless 'time brz log' of everything is 7+s, so 1.3s to # extract revision texts isn't a majority of time. ret = bencode.bdecode(text) if not isinstance(ret, list): raise ValueError("invalid revision text") schema = self._schema # timezone is allowed to be missing, but should be set bits = {'timezone': None} for key, value in ret: # Will raise KeyError if not a valid part of the schema, or an # entry is given 2 times. var_name, expected_type, validator = schema[key] if value.__class__ is not expected_type: raise ValueError('key %s did not conform to the expected type' ' %s, but was %s' % (key, expected_type, type(value))) if validator is not None: value = validator(value) bits[var_name] = value if len(bits) != len(schema): missing = [key for key, (var_name, _, _) in schema.items() if var_name not in bits] raise ValueError('Revision text was missing expected keys %s.' ' text %r' % (missing, text)) del bits[None] # Get rid of 'format' since it doesn't get mapped rev = _mod_revision.Revision(**bits) return rev
def parse_metadata(records): names, metadata_bytes = next(records) if names[0] != (b'metadata', ): raise ShelfCorrupt metadata = bencode.bdecode(metadata_bytes) message = metadata.get(b'message') if message is not None: metadata[b'message'] = message.decode('utf-8') return metadata
def do_with_locked_branch(self, branch, value_dict, name, section): utf8_dict = bencode.bdecode(value_dict) value_dict = {} for key, value in utf8_dict.items(): value_dict[key.decode('utf8')] = value.decode('utf8') if not section: section = None else: section = section.decode('utf-8') branch._get_config().set_option(value_dict, name.decode('utf-8'), section) return SuccessfulSmartServerResponse(())
def _deserialize_tag_dict(self, tag_content): """Convert the tag file into a dictionary of tags""" # was a special case to make initialization easy, an empty definition # is an empty dictionary if tag_content == b'': return {} try: r = {} for k, v in bencode.bdecode(tag_content).items(): r[k.decode('utf-8')] = v return r except ValueError as e: raise ValueError("failed to deserialize tag dictionary %r: %s" % (tag_content, e))
def iter_records(self): """Iterate through bundle records :return: a generator of (bytes, metadata, content_kind, revision_id, file_id) """ iterator = pack.iter_records_from_file(self._container_file) for names, bytes in iterator: if len(names) != 1: raise errors.BadBundle('Record has %d names instead of 1' % len(names)) metadata = bencode.bdecode(bytes) if metadata[b'storage_kind'] == b'header': bytes = None else: _unused, bytes = next(iterator) yield (bytes, metadata) + self.decode_name(names[0][0])
def _generate_hg_message_tail(self, rev): extra = {} renames = [] branch = 'default' for name in rev.properties: if name == u'hg:extra:branch': branch = rev.properties[u'hg:extra:branch'] elif name.startswith(u'hg:extra'): extra[name[len(u'hg:extra:'):]] = base64.b64decode( rev.properties[name]) elif name == u'hg:renames': renames = bencode.bdecode( base64.b64decode(rev.properties[u'hg:renames'])) # TODO: Export other properties as 'bzr:' extras? ret = format_hg_metadata(renames, branch, extra) if not isinstance(ret, bytes): raise TypeError(ret) return ret
def load(self): import fastbencode as bencode with open(self._filename + '.mpidx', 'rb') as f: self._parents, snapshots, self._diff_offset = bencode.bdecode( f.read()) self._snapshots = set(snapshots)