/brz/remove-bazaar

# Copyright (C) 2006-2011 Canonical Ltd

from __future__ import absolute_import

from ..lazy_import import lazy_import

import gzip

 

from breezy import (

    patiencediff,

from breezy.bzr import (

    index as _mod_index,

    pack,

    )

 

from breezy.bzr import pack_repo

from breezy.i18n import gettext

from .. import (

    annotate,

from ..errors import (

    InternalBzrError,

    InvalidRevisionId,

from ..osutils import (

from ..sixish import (

    BytesIO,

    range,

    viewitems,

    viewvalues,

    )

from ..bzr.versionedfile import (

    _KeyRefs,

    VersionedFilesWithFallbacks,

class KnitError(InternalBzrError):

 

    _fmt = "Knit error"

 

 

class KnitCorrupt(KnitError):

 

    _fmt = "Knit %(filename)s corrupt: %(how)s"

 

    def __init__(self, filename, how):

        KnitError.__init__(self)

        self.filename = filename

        self.how = how

 

 

class SHA1KnitCorrupt(KnitCorrupt):

 

    _fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "

        "match expected sha-1. key %(key)s expected sha %(expected)s actual "

        "sha %(actual)s")

 

    def __init__(self, filename, actual, expected, key, content):

        KnitError.__init__(self)

        self.filename = filename

        self.actual = actual

        self.expected = expected

        self.key = key

        self.content = content

 

 

class KnitDataStreamIncompatible(KnitError):

    # Not raised anymore, as we can convert data streams.  In future we may

    # need it again for more exotic cases, so we're keeping it around for now.

 

    _fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."

 

    def __init__(self, stream_format, target_format):

        self.stream_format = stream_format

        self.target_format = target_format

 

 

class KnitDataStreamUnknown(KnitError):

    # Indicates a data stream we don't know how to handle.

 

    _fmt = "Cannot parse knit data stream of format \"%(stream_format)s\"."

 

    def __init__(self, stream_format):

        self.stream_format = stream_format

 

 

class KnitHeaderError(KnitError):

 

    _fmt = 'Knit header error: %(badline)r unexpected for file "%(filename)s".'

 

    def __init__(self, badline, filename):

        KnitError.__init__(self)

        self.badline = badline

        self.filename = filename

 

 

class KnitIndexUnknownMethod(KnitError):

    """Raised when we don't understand the storage method.

 

    Currently only 'fulltext' and 'line-delta' are supported.

    """

 

    _fmt = ("Knit index %(filename)s does not have a known method"

            " in options: %(options)r")

 

    def __init__(self, filename, options):

        KnitError.__init__(self)

        self.filename = filename

        self.options = options

 

 

        basis_entry = next(self._basis_vf.get_record_stream(

            [compression_parent], 'unordered', True))

        basis_entry = next(self._basis_vf.get_record_stream(

            [compression_parent], 'unordered', True))

    This is always stored in memory as a list of lines with \\n at the end,

        self._lines = list(lines)

        except ValueError as e:

        return AnnotatedKnitContent(self._lines)

        lines = (tuple(line.split(' ', 1)) for line in content)

                contents = [next(lines).split(' ', 1)[1] for _ in range(count)]

                contents = [tuple(next(lines).split(' ', 1))

                    for _ in range(count)]

            for _ in range(count):

                origin, text = next(lines).split(' ', 1)

        if isinstance(key, tuple):

            for _ in range(count):

                yield next(lines)

        access = pack_repo._DirectPackAccess({})

    return sum(index_memo[2]

               for index_memo in viewvalues(all_build_index_memos))

 

 

class KnitVersionedFiles(VersionedFilesWithFallbacks):

            'breezy.bzr.pack_repo.AggregateIndex' for the signature.

        self._immediate_fallback_vfs = []

    def without_fallbacks(self):

        """Return a clone of this object without any fallbacks configured."""

        return KnitVersionedFiles(self._index, self._access,

            self._max_delta_chain, self._factory.annotated,

            self._reload_func)

 

        self._immediate_fallback_vfs.append(a_versioned_files)

        if not isinstance(text, bytes):

            if not isinstance(element, str):

        elif not isinstance(key[-1], str):

                    raise KnitCorrupt(self,

        for fallback_vfs in self._immediate_fallback_vfs:

        for count in range(self._max_delta_chain):

            except (RevisionNotPresent, KeyError) as e:

 

        * method is the way referenced data should be applied.

        * index_memo is the handle to pass to the data access to actually get

          the data

        * next is the build-parent of the version, or None for fulltexts.

        * parents is the version_ids of the parents of this version

 

        :param allow_missing: If True do not raise an error on a missing

            component, just ignore it.

            for key, details in viewitems(build_details):

        sources = [self._index] + self._immediate_fallback_vfs

 

            * record: data returned from read_records (a KnitContentobject)

            * record_details: opaque information to pass to parse_record

            * digest: SHA1 digest of the full text after all steps are done

            * next: build-parent of the version, i.e. the leftmost ancestor.

 

                                       in viewitems(position_map)]

            except errors.RetryWithNewPacks as e:

            except errors.RetryWithNewPacks as e:

                for key, details in viewitems(build_details))

                    vf = self._immediate_fallback_vfs[parent_maps.index(source) - 1]

        for key, details in viewitems(record_map):

        for source in self._immediate_fallback_vfs:

            convertibles = {"knit-annotated-ft-gz"}

                       or not self._immediate_fallback_vfs

                       or compression_parent in self._index

                       or compression_parent not in self)):

                # TODO: self.__contains__ is somewhat redundant with

                # self._index.__contains__; we really want something that directly

                    if compression_parent not in self._index:

                for key, details in viewitems(build_details):

                    pb.update(gettext('Walking content'), key_idx, total)

            except errors.RetryWithNewPacks as e:

        if keys and not self._immediate_fallback_vfs:

        for source in self._immediate_fallback_vfs:

        pb.update(gettext('Walking content'), total, total)

        df = gzip.GzipFile(mode='rb', fileobj=BytesIO(raw_data))