~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005, 2006 Canonical Ltd

    :cvar internal_error: if true (or absent) this was probably caused by a

    bzr bug and should be displayed with a traceback; if False this was

    def __str__(self):

            # contains a preformatted message; must be cast to plain str

            return str(s)

                s = fmt % self.__dict__

                if isinstance(s, unicode):

                    return s.encode('utf8')

            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%s' \

                   str(e))

        # XXX: Use the underlying BzrError to always generate the args attribute

        # if it doesn't exist.  We can't use super here, because exceptions are

        # old-style classes in python2.4 (but new in 2.5).  --bmc, 20060426

             'please convert %s to use BzrError instead' 

            return 'Unprintable exception %s(%r): %s' \

                   self.__dict__, str(e))

class BzrCheckError(BzrError):

    internal_error = True

 

class InvalidEntryName(BzrError):

    internal_error = True

 

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

class InventoryModified(BzrError):

 

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

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

 

    internal_error = True

    _fmt = "No WorkingTree exists for %(base)s."

class WorkingTreeAlreadyPopulated(BzrError):

 

    _fmt = """Working tree already populated in %(base)s"""

 

    internal_error = True

    internal_error = False

 

    def __init__(self, msg):

        # Object.__str__() must return a real string

        # returning a Unicode string is a python error.

        if isinstance(msg, unicode):

            self.msg = msg.encode('utf8')

        else:

            self.msg = msg

 

    def __str__(self):

        return self.msg

         "%(extra)s")

    _fmt = "%(path)r is not a directory %(extra)s"

    _fmt = "%(path)r is not in the working directory %(extra)s"

    _fmt = "Directory not empty: %(path)r%(extra)s"

 

 

class ReadingCompleted(BzrError):

    internal_error = True

 

    _fmt = "Device or resource busy: %(path)r%(extra)s"

    _fmt = "Permission denied: %(path)r%(extra)s"

    _fmt = "Invalid url supplied to transport: %(path)r%(extra)s"

    _fmt = "Invalid URL join request: %(args)s%(extra)s"

 

    def __init__(self, msg, base, args):

        PathError.__init__(self, base, msg)

        self.args = [base] + list(args)

    _fmt = "readv() read %(actual)s bytes rather than %(length)s bytes at %(offset)s for %(path)s%(extra)s"

class PathNotChild(BzrError):

    _fmt = "Path %(path)r is not a child of path %(base)r%(extra)s"

    _fmt = "Path %(path)r is not unicode normalized"

    _fmt = "Not a branch: %(path)s"

    _fmt = "Already a branch: %(path)s."

    _fmt = "Directory contains a branch, but no working tree \

(use bzr checkout if you wish to build a working tree): %(path)s"

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

    _fmt = "Parent not accessible given base %(base)s and relative path %(path)s"

    _fmt = "No repository present: %(path)r"

    _fmt = "File %(path)s in not in branch %(branch_base)s."

    

    _fmt = "Unsupported branch format: %(format)s"

    _fmt = "Unknown branch format: %(format)r"

    _fmt = "%(context_info)s%(path)s is already versioned"

        """Construct a new NotVersionedError.

    _fmt = "%(context_info)s%(path)s is not versioned"

    _fmt = "Cannot operate on %(filename)s of unsupported kind %(kind)s"

    _fmt = "Cannot operate on %(filename)s because it is a control file"

 

 

class LockError(BzrError):

 

    _fmt = "Lock error: %(message)s"

 

    internal_error = True

        self.message = message

    _fmt = "A transaction related operation was attempted after the transaction finished."

    _fmt = "Could not acquire lock %(lock)s"

    

    _fmt = "Lock was broken while still open: %(lock)s - check storage consistency!"

    _fmt = "Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)r, wanted to break %(target)r"

class NoSuchRevision(BzrError):

 

    _fmt = "Branch %(branch)s has no revision %(revision)s"

 

    internal_error = True

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

    

    _fmt = "These branches have diverged.  Use the merge command to reconcile them."""

    internal_error = False

    _fmt = "Branches have no common ancestor, and no merge base revision was specified."

 

    internal_error = False

    _fmt = "Revisions are not derived from the same root: " \

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

        msg = "The correct base is unclear, because %s are all equally close" %\

            ", ".join(bases)

class NoCommits(BzrError):

    def __init__(self, branch):

        BzrError.__init__(self, branch=branch)

 

    _fmt = "Bound branch %(branch)s is out of date with master branch %(master)s."

    _fmt = "Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."

    _fmt = "Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"

    _fmt = "Parents are mismatched between two revisions."

    _fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"

    _fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"

    _fmt = "Revision {%(revision_id)s} not present in %(file_id)s."

    _fmt = "Revision {%(revision_id)s} already present in %(file_id)s."

class KnitError(BzrError):

    internal_error = True

 

 

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