/brz/remove-bazaar

from __future__ import absolute_import

 

from .sixish import (

    PY3,

    )

    if PY3:

        __str__ = _format

    else:

        def __str__(self):

            return self._format().encode('utf-8')

 

        __unicode__ = _format

            return gettext(fmt) # _fmt strings should be ascii

class AlreadyBuilding(BzrError):

 

    _fmt = "The tree builder is already building a tree."

 

 

class DirstateCorrupt(BzrError):

 

    _fmt = "The dirstate file (%(state)s) appears to be corrupt: %(msg)s"

 

    def __init__(self, state, msg):

        BzrError.__init__(self)

        self.state = state

        self.msg = msg

 

 

class DisabledMethod(InternalBzrError):

 

    _fmt = "The smart server method '%(class_name)s' is disabled."

 

    def __init__(self, class_name):

        BzrError.__init__(self)

        self.class_name = class_name

 

 

class InvalidEntryName(InternalBzrError):

 

    _fmt = "Invalid entry name: %(name)s"

 

    def __init__(self, name):

        BzrError.__init__(self)

        self.name = name

 

 

        "the commit builder.")

class NoSuchIdInRepository(NoSuchId):

 

    _fmt = ('The file id "%(file_id)s" is not present in the repository'

            ' %(repository)r')

 

    def __init__(self, repository, file_id):

        BzrError.__init__(self, repository=repository, file_id=file_id)

 

 

class InventoryModified(InternalBzrError):

 

    _fmt = ("The current inventory for the tree %(tree)r has been modified,"

            " so a clean inventory cannot be read without data loss.")

 

    def __init__(self, tree):

        self.tree = tree

 

 

class NotBuilding(BzrError):

 

    _fmt = "Not currently building a tree."

 

 

class BzrCommandError(BzrError):

    # BzrCommandError, and non-UI code should not throw a subclass of

    # BzrCommandError.  ADHB 20051211

class BadIndexFormatSignature(BzrError):

 

    _fmt = "%(value)s is not an index of type %(_type)s."

 

    def __init__(self, value, _type):

        BzrError.__init__(self)

        self.value = value

        self._type = _type

 

 

class BadIndexData(BzrError):

 

    _fmt = "Error in data for index %(value)s."

 

    def __init__(self, value):

        BzrError.__init__(self)

        self.value = value

 

 

class BadIndexDuplicateKey(BzrError):

 

    _fmt = "The key '%(key)s' is already in index '%(index)s'."

 

    def __init__(self, key, index):

        BzrError.__init__(self)

        self.key = key

        self.index = index

 

 

class BadIndexKey(BzrError):

 

    _fmt = "The key '%(key)s' is not a valid key."

 

    def __init__(self, key):

        BzrError.__init__(self)

        self.key = key

 

 

class BadIndexOptions(BzrError):

 

    _fmt = "Could not parse options for index %(value)s."

 

    def __init__(self, value):

        BzrError.__init__(self)

        self.value = value

 

 

class BadIndexValue(BzrError):

 

    _fmt = "The value '%(value)s' is not a valid value."

 

    def __init__(self, value):

        BzrError.__init__(self)

        self.value = value

 

 

class UnavailableRepresentation(InternalBzrError):

 

    _fmt = ("The encoding '%(wanted)s' is not available for key %(key)s which "

        "is encoded as '%(native)s'.")

 

    def __init__(self, key, wanted, native):

        InternalBzrError.__init__(self)

        self.wanted = wanted

        self.native = native

        self.key = key

 

 

class UnknownHook(BzrError):

 

    _fmt = "The %(type)s hook '%(hook)s' is unknown in this version of breezy."

 

    def __init__(self, hook_type, hook_name):

        BzrError.__init__(self)

        self.type = hook_type

        self.hook = hook_name

 

 

class UnstackableBranchFormat(BzrError):

 

    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "

        "You will need to upgrade the branch to permit branch stacking.")

 

    def __init__(self, format, url):

        BzrError.__init__(self)

        self.format = format

        self.url = url

 

 

        "You will need to upgrade the repository to permit branch stacking.")

       from . import urlutils

       path = urlutils.unescape_for_display(path, 'ascii')

       if detail is not None:

           detail = ': ' + detail

       self.detail = detail

       self.controldir = controldir

       PathError.__init__(self, path=path)

           self.detail = self._get_detail()

       from . import urlutils

       self.path = urlutils.unescape_for_display(branch.base, 'ascii')

class AtomicFileAlreadyClosed(PathError):

 

    _fmt = ('"%(function)s" called on an AtomicFile after it was closed:'

            ' "%(path)s"')

 

    def __init__(self, path, function):

        PathError.__init__(self, path=path, extra=None)

        self.function = function

 

 

            "is not compatible with\n" \

            "%(source)s\n" \

            "%(details)s"

class PointlessCommit(BzrError):

 

    _fmt = "No changes to commit"

 

 

class CannotCommitSelectedFileMerge(BzrError):

 

    _fmt = 'Selected-file commit of merges is not supported yet:'\

        ' files %(files_str)s'

 

    def __init__(self, files):

        files_str = ', '.join(files)

        BzrError.__init__(self, files=files, files_str=files_str)

 

 

class ExcludesUnsupported(BzrError):

 

    _fmt = ('Excluding paths during commit is not supported by '

            'repository at %(repository)r.')

 

    def __init__(self, repository):

        BzrError.__init__(self, repository=repository)

 

 

class BadCommitMessageEncoding(BzrError):

 

    _fmt = 'The specified commit message contains characters unsupported by '\

        'the current encoding.'

 

 

class StrictCommitFailed(Exception):

 

    _fmt = "Commit refused because there are unknowns in the tree."

 

 

class InvalidRevisionSpec(BzrError):

 

    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"

            " %(branch_url)s%(extra)s")

 

    def __init__(self, spec, branch, extra=None):

        BzrError.__init__(self, branch=branch, spec=spec)

        self.branch_url = getattr(branch, 'user_url', str(branch))

        if extra:

            self.extra = '\n' + str(extra)

        else:

            self.extra = ''

 

 

           ' which is not permitted by the append_revisions_only setting on'

           ' branch "%(location)s".')

       import breezy.urlutils as urlutils

       location = urlutils.unescape_for_display(location, 'ascii')

       BzrError.__init__(self, location=location)

           "%(revision_a)s %(revision_b)s.")

            not_ancestor_id=not_ancestor_id)

 

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

 

 

            msg =  ''

                self.exc_type, self.exc_value, self.exc_tb)

class CantReprocessAndShowBase(BzrError):

 

    _fmt = ("Can't reprocess and show base, because reprocessing obscures "

           "the relationship of conflicting lines to the base")

 

 

class DuplicateFileId(BzrError):

 

    _fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"

 

    def __init__(self, file_id, entry):

        BzrError.__init__(self)

        self.file_id = file_id

        self.entry = entry

 

 

class MalformedTransform(InternalBzrError):

 

    _fmt = "Tree transform is malformed %(conflicts)r"

 

 

class NoFinalPath(BzrError):

 

    _fmt = ("No final name for trans_id %(trans_id)r\n"

            "file-id: %(file_id)r\n"

            "root trans-id: %(root_trans_id)r\n")

 

    def __init__(self, trans_id, transform):

        self.trans_id = trans_id

        self.file_id = transform.final_file_id(trans_id)

        self.root_trans_id = transform.root

 

 

class ReusingTransform(BzrError):

 

    _fmt = "Attempt to reuse a transform that has already been applied."

 

 

class CantMoveRoot(BzrError):

 

    _fmt = "Moving the root directory is not supported at this time"

 

 

class TransformRenameFailed(BzrError):

 

    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"

 

    def __init__(self, from_path, to_path, why, errno):

        self.from_path = from_path

        self.to_path = to_path

        self.why = why

        self.errno = errno

 

 

        "%(_has_extra)s%(extra)s")

        "%(_has_extra)s%(extra)s")

            "    %(problem)s"

class ExistingContent(BzrError):

    # Added in breezy 0.92, used by VersionedFile.add_lines.