~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Andrew Bennetts
  • Date: 2007-03-28 07:08:42 UTC
  • mfrom: (2380 +trunk)
  • mto: (2018.5.146 hpss)
  • mto: This revision was merged to the branch mainline in revision 2414.
  • Revision ID: andrew.bennetts@canonical.com-20070328070842-r843houy668oxb9o
Merge from bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
132
132
    # readable explanation
133
133
 
134
134
    def __init__(self, *args, **kwds):
135
 
        # XXX: Use the underlying BzrError to always generate the args attribute
136
 
        # if it doesn't exist.  We can't use super here, because exceptions are
137
 
        # old-style classes in python2.4 (but new in 2.5).  --bmc, 20060426
 
135
        # XXX: Use the underlying BzrError to always generate the args
 
136
        # attribute if it doesn't exist.  We can't use super here, because
 
137
        # exceptions are old-style classes in python2.4 (but new in 2.5).
 
138
        # --bmc, 20060426
138
139
        symbol_versioning.warn('BzrNewError was deprecated in bzr 0.13; '
139
 
             'please convert %s to use BzrError instead' 
 
140
             'please convert %s to use BzrError instead'
140
141
             % self.__class__.__name__,
141
142
             DeprecationWarning,
142
143
             stacklevel=2)
223
224
 
224
225
class InventoryModified(BzrError):
225
226
 
226
 
    _fmt = ("The current inventory for the tree %(tree)r has been modified, "
227
 
            "so a clean inventory cannot be read without data loss.")
 
227
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
 
228
            " so a clean inventory cannot be read without data loss.")
228
229
 
229
230
    internal_error = True
230
231
 
342
343
    """Used when renaming and both source and dest exist."""
343
344
 
344
345
    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
345
 
         "%(extra)s")
 
346
            "%(extra)s")
346
347
 
347
348
    def __init__(self, source, dest, extra=None):
348
349
        BzrError.__init__(self)
425
426
 
426
427
class ShortReadvError(PathError):
427
428
 
428
 
    _fmt = "readv() read %(actual)s bytes rather than %(length)s bytes at %(offset)s for %(path)s%(extra)s"
 
429
    _fmt = ("readv() read %(actual)s bytes rather than %(length)s bytes"
 
430
            " at %(offset)s for %(path)s%(extra)s")
429
431
 
430
432
    internal_error = True
431
433
 
469
471
       self.path = urlutils.unescape_for_display(path, 'ascii')
470
472
 
471
473
 
 
474
class NoSubmitBranch(PathError):
 
475
 
 
476
    _fmt = 'No submit branch available for branch "%(path)s"'
 
477
 
 
478
    def __init__(self, branch):
 
479
       import bzrlib.urlutils as urlutils
 
480
       self.path = urlutils.unescape_for_display(branch.base, 'ascii')
 
481
 
 
482
 
472
483
class AlreadyBranchError(PathError):
473
484
 
474
485
    _fmt = "Already a branch: %(path)s."
482
493
 
483
494
class AtomicFileAlreadyClosed(PathError):
484
495
 
485
 
    _fmt = "'%(function)s' called on an AtomicFile after it was closed: %(path)s"
 
496
    _fmt = ("'%(function)s' called on an AtomicFile after it was closed:"
 
497
            " %(path)s")
486
498
 
487
499
    def __init__(self, path, function):
488
500
        PathError.__init__(self, path=path, extra=None)
491
503
 
492
504
class InaccessibleParent(PathError):
493
505
 
494
 
    _fmt = "Parent not accessible given base %(base)s and relative path %(path)s"
 
506
    _fmt = ("Parent not accessible given base %(base)s and"
 
507
            " relative path %(path)s")
495
508
 
496
509
    def __init__(self, path, base):
497
510
        PathError.__init__(self, path)
552
565
    _fmt = "%(context_info)s%(path)s is already versioned"
553
566
 
554
567
    def __init__(self, path, context_info=None):
555
 
        """Construct a new NotVersionedError.
 
568
        """Construct a new AlreadyVersionedError.
556
569
 
557
570
        :param path: This is the path which is versioned,
558
571
        which should be in a user friendly form.
621
634
 
622
635
class BadFileKindError(BzrError):
623
636
 
624
 
    _fmt = "Cannot operate on %(filename)s of unsupported kind %(kind)s"
 
637
    _fmt = 'Cannot operate on "%(filename)s" of unsupported kind "%(kind)s"'
 
638
 
 
639
    def __init__(self, filename, kind):
 
640
        BzrError.__init__(self, filename=filename, kind=kind)
625
641
 
626
642
 
627
643
class ForbiddenControlFileError(BzrError):
631
647
 
632
648
class LockError(BzrError):
633
649
 
634
 
    _fmt = "Lock error: %(message)s"
 
650
    _fmt = "Lock error: %(msg)s"
635
651
 
636
652
    internal_error = True
637
653
 
641
657
    #
642
658
    # New code should prefer to raise specific subclasses
643
659
    def __init__(self, message):
644
 
        self.message = message
 
660
        # Python 2.5 uses a slot for StandardError.message,
 
661
        # so use a different variable name
 
662
        # so it is exposed in self.__dict__
 
663
        self.msg = message
 
664
 
 
665
 
 
666
class LockActive(LockError):
 
667
 
 
668
    _fmt = "The lock for '%(lock_description)s' is in use and cannot be broken."
 
669
 
 
670
    internal_error = False
 
671
 
 
672
    def __init__(self, lock_description):
 
673
        self.lock_description = lock_description
645
674
 
646
675
 
647
676
class CommitNotPossible(LockError):
664
693
 
665
694
    _fmt = "A write attempt was made in a read only transaction on %(obj)s"
666
695
 
 
696
    # TODO: There should also be an error indicating that you need a write
 
697
    # lock and don't have any lock at all... mbp 20070226
 
698
 
667
699
    def __init__(self, obj):
668
700
        self.obj = obj
669
701
 
670
702
 
 
703
class ReadOnlyLockError(LockError):
 
704
 
 
705
    _fmt = "Cannot acquire write lock on %(fname)s. %(msg)s"
 
706
 
 
707
    def __init__(self, fname, msg):
 
708
        LockError.__init__(self, '')
 
709
        self.fname = fname
 
710
        self.msg = msg
 
711
 
 
712
 
671
713
class OutSideTransaction(BzrError):
672
714
 
673
 
    _fmt = "A transaction related operation was attempted after the transaction finished."
 
715
    _fmt = ("A transaction related operation was attempted after"
 
716
            " the transaction finished.")
674
717
 
675
718
 
676
719
class ObjectNotLocked(LockError):
707
750
    # bits?
708
751
 
709
752
    internal_error = False
710
 
    
 
753
 
711
754
    def __init__(self, lock):
712
755
        self.lock = lock
713
756
 
714
757
 
715
758
class LockBroken(LockError):
716
759
 
717
 
    _fmt = "Lock was broken while still open: %(lock)s - check storage consistency!"
 
760
    _fmt = ("Lock was broken while still open: %(lock)s"
 
761
            " - check storage consistency!")
718
762
 
719
763
    internal_error = False
720
764
 
724
768
 
725
769
class LockBreakMismatch(LockError):
726
770
 
727
 
    _fmt = "Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)r, wanted to break %(target)r"
 
771
    _fmt = ("Lock was released and re-acquired before being broken:"
 
772
            " %(lock)s: held by %(holder)r, wanted to break %(target)r")
728
773
 
729
774
    internal_error = False
730
775
 
799
844
        BzrError.__init__(self, branch=branch, revision=revision)
800
845
 
801
846
 
 
847
class NotLeftParentDescendant(BzrError):
 
848
 
 
849
    _fmt = ("Revision %(old_revision)s is not the left parent of"
 
850
            " %(new_revision)s, but branch %(branch_location)s expects this")
 
851
 
 
852
    internal_error = True
 
853
 
 
854
    def __init__(self, branch, old_revision, new_revision):
 
855
        BzrError.__init__(self, branch_location=branch.base,
 
856
                          old_revision=old_revision,
 
857
                          new_revision=new_revision)
 
858
 
 
859
 
802
860
class NoSuchRevisionSpec(BzrError):
803
861
 
804
862
    _fmt = "No namespace registered for string: %(spec)r"
807
865
        BzrError.__init__(self, spec=spec)
808
866
 
809
867
 
 
868
class NoSuchRevisionInTree(NoSuchRevision):
 
869
    """When using Tree.revision_tree, and the revision is not accessible."""
 
870
    
 
871
    _fmt = "The revision id %(revision_id)s is not present in the tree %(tree)s."
 
872
 
 
873
    def __init__(self, tree, revision_id):
 
874
        BzrError.__init__(self)
 
875
        self.tree = tree
 
876
        self.revision_id = revision_id
 
877
 
 
878
 
810
879
class InvalidRevisionSpec(BzrError):
811
880
 
812
 
    _fmt = "Requested revision: %(spec)r does not exist in branch: %(branch)s%(extra)s"
 
881
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
 
882
            " %(branch)s%(extra)s")
813
883
 
814
884
    def __init__(self, spec, branch, extra=None):
815
885
        BzrError.__init__(self, branch=branch, spec=spec)
824
894
    _fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"
825
895
 
826
896
 
 
897
class AppendRevisionsOnlyViolation(BzrError):
 
898
 
 
899
    _fmt = ('Operation denied because it would change the main history,'
 
900
           ' which is not permitted by the append_revisions_only setting on'
 
901
           ' branch "%(location)s".')
 
902
 
 
903
    def __init__(self, location):
 
904
       import bzrlib.urlutils as urlutils
 
905
       location = urlutils.unescape_for_display(location, 'ascii')
 
906
       BzrError.__init__(self, location=location)
 
907
 
 
908
 
827
909
class DivergedBranches(BzrError):
828
 
    
829
 
    _fmt = "These branches have diverged.  Use the merge command to reconcile them."""
 
910
 
 
911
    _fmt = ("These branches have diverged."
 
912
            " Use the merge command to reconcile them.")
830
913
 
831
914
    internal_error = False
832
915
 
835
918
        self.branch2 = branch2
836
919
 
837
920
 
 
921
class NotLefthandHistory(BzrError):
 
922
 
 
923
    _fmt = "Supplied history does not follow left-hand parents"
 
924
 
 
925
    internal_error = True
 
926
 
 
927
    def __init__(self, history):
 
928
        BzrError.__init__(self, history=history)
 
929
 
 
930
 
838
931
class UnrelatedBranches(BzrError):
839
932
 
840
 
    _fmt = "Branches have no common ancestor, and no merge base revision was specified."
 
933
    _fmt = ("Branches have no common ancestor, and"
 
934
            " no merge base revision was specified.")
841
935
 
842
936
    internal_error = False
843
937
 
853
947
 
854
948
class NoCommonRoot(BzrError):
855
949
 
856
 
    _fmt = "Revisions are not derived from the same root: " \
857
 
           "%(revision_a)s %(revision_b)s."
 
950
    _fmt = ("Revisions are not derived from the same root: "
 
951
           "%(revision_a)s %(revision_b)s.")
858
952
 
859
953
    def __init__(self, revision_a, revision_b):
860
954
        BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
883
977
    def __init__(self, bases):
884
978
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
885
979
                DeprecationWarning)
886
 
        msg = "The correct base is unclear, because %s are all equally close" %\
887
 
            ", ".join(bases)
 
980
        msg = ("The correct base is unclear, because %s are all equally close"
 
981
                % ", ".join(bases))
888
982
        BzrError.__init__(self, msg)
889
983
        self.bases = bases
890
984
 
912
1006
 
913
1007
class BoundBranchOutOfDate(BzrError):
914
1008
 
915
 
    _fmt = "Bound branch %(branch)s is out of date with master branch %(master)s."
 
1009
    _fmt = ("Bound branch %(branch)s is out of date"
 
1010
            " with master branch %(master)s.")
916
1011
 
917
1012
    def __init__(self, branch, master):
918
1013
        BzrError.__init__(self)
922
1017
        
923
1018
class CommitToDoubleBoundBranch(BzrError):
924
1019
 
925
 
    _fmt = "Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."
 
1020
    _fmt = ("Cannot commit to branch %(branch)s."
 
1021
            " It is bound to %(master)s, which is bound to %(remote)s.")
926
1022
 
927
1023
    def __init__(self, branch, master, remote):
928
1024
        BzrError.__init__(self)
942
1038
 
943
1039
class BoundBranchConnectionFailure(BzrError):
944
1040
 
945
 
    _fmt = "Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"
 
1041
    _fmt = ("Unable to connect to target of bound branch %(branch)s"
 
1042
            " => %(target)s: %(error)s")
946
1043
 
947
1044
    def __init__(self, branch, target, error):
948
1045
        BzrError.__init__(self)
1002
1099
 
1003
1100
class WeaveTextDiffers(WeaveError):
1004
1101
 
1005
 
    _fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"
 
1102
    _fmt = ("Weaves differ on text content. Revision:"
 
1103
            " {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1006
1104
 
1007
1105
    def __init__(self, revision_id, weave_a, weave_b):
1008
1106
        WeaveError.__init__(self)
1013
1111
 
1014
1112
class WeaveTextDiffers(WeaveError):
1015
1113
 
1016
 
    _fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"
 
1114
    _fmt = ("Weaves differ on text content. Revision:"
 
1115
            " {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1017
1116
 
1018
1117
    def __init__(self, revision_id, weave_a, weave_b):
1019
1118
        WeaveError.__init__(self)
1116
1215
 
1117
1216
class TooManyConcurrentRequests(BzrError):
1118
1217
 
1119
 
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit. "
1120
 
            "Be sure to finish_writing and finish_reading on the "
1121
 
            "current request that is open.")
 
1218
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
 
1219
            " Be sure to finish_writing and finish_reading on the"
 
1220
            " current request that is open.")
1122
1221
 
1123
1222
    internal_error = True
1124
1223
 
1251
1350
 
1252
1351
class CantReprocessAndShowBase(BzrError):
1253
1352
 
1254
 
    _fmt = "Can't reprocess and show base, because reprocessing obscures " \
1255
 
           "the relationship of conflicting lines to the base"
 
1353
    _fmt = ("Can't reprocess and show base, because reprocessing obscures "
 
1354
           "the relationship of conflicting lines to the base")
1256
1355
 
1257
1356
 
1258
1357
class GraphCycleError(BzrError):
1307
1406
 
1308
1407
 
1309
1408
class MustUseDecorated(Exception):
1310
 
    
1311
 
    _fmt = """A decorating function has requested its original command be used."""
1312
 
    
 
1409
 
 
1410
    _fmt = "A decorating function has requested its original command be used."
 
1411
 
1313
1412
 
1314
1413
class NoBundleFound(BzrError):
1315
1414
 
1332
1431
 
1333
1432
class MissingText(BzrError):
1334
1433
 
1335
 
    _fmt = "Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"
 
1434
    _fmt = ("Branch %(base)s is missing revision"
 
1435
            " %(text_revision)s of %(file_id)s")
1336
1436
 
1337
1437
    def __init__(self, branch, text_revision, file_id):
1338
1438
        BzrError.__init__(self)
1342
1442
        self.file_id = file_id
1343
1443
 
1344
1444
 
 
1445
class DuplicateFileId(BzrError):
 
1446
 
 
1447
    _fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"
 
1448
 
 
1449
    def __init__(self, file_id, entry):
 
1450
        BzrError.__init__(self)
 
1451
        self.file_id = file_id
 
1452
        self.entry = entry
 
1453
 
 
1454
 
1345
1455
class DuplicateKey(BzrError):
1346
1456
 
1347
1457
    _fmt = "Key %(key)s is already present in map"
1445
1555
 
1446
1556
class BzrBadParameterUnicode(BzrBadParameter):
1447
1557
 
1448
 
    _fmt = "Parameter %(param)s is unicode but only byte-strings are permitted."
 
1558
    _fmt = ("Parameter %(param)s is unicode but"
 
1559
            " only byte-strings are permitted.")
1449
1560
 
1450
1561
 
1451
1562
class BzrBadParameterContainsNewline(BzrBadParameter):
1537
1648
        self.tree = tree
1538
1649
 
1539
1650
 
 
1651
class PublicBranchOutOfDate(BzrError):
 
1652
 
 
1653
    _fmt = 'Public branch "%(public_location)s" lacks revision '\
 
1654
        '"%(revstring)s".'
 
1655
 
 
1656
    def __init__(self, public_location, revstring):
 
1657
        import bzrlib.urlutils as urlutils
 
1658
        public_location = urlutils.unescape_for_display(public_location,
 
1659
                                                        'ascii')
 
1660
        BzrError.__init__(self, public_location=public_location,
 
1661
                          revstring=revstring)
 
1662
 
 
1663
 
1540
1664
class MergeModifiedFormatError(BzrError):
1541
1665
 
1542
1666
    _fmt = "Error in merge modified format"
1549
1673
 
1550
1674
class CorruptRepository(BzrError):
1551
1675
 
1552
 
    _fmt = """An error has been detected in the repository %(repo_path)s.
1553
 
Please run bzr reconcile on this repository."""
 
1676
    _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
 
1677
            "Please run bzr reconcile on this repository.")
1554
1678
 
1555
1679
    def __init__(self, repo):
1556
1680
        BzrError.__init__(self)
1578
1702
 
1579
1703
class InvalidProgressBarType(BzrError):
1580
1704
 
1581
 
    _fmt = """Environment variable BZR_PROGRESS_BAR='%(bar_type)s is not a supported type
1582
 
Select one of: %(valid_types)s"""
 
1705
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
 
1706
            " is not a supported type Select one of: %(valid_types)s")
1583
1707
 
1584
1708
    def __init__(self, bar_type, valid_types):
1585
1709
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1587
1711
 
1588
1712
class UnsupportedOperation(BzrError):
1589
1713
 
1590
 
    _fmt = "The method %(mname)s is not supported on objects of type %(tname)s."
 
1714
    _fmt = ("The method %(mname)s is not supported on"
 
1715
            " objects of type %(tname)s.")
1591
1716
 
1592
1717
    def __init__(self, method, method_self):
1593
1718
        self.method = method
1600
1725
 
1601
1726
 
1602
1727
class NonAsciiRevisionId(UnsupportedOperation):
1603
 
    """Raised when a commit is attempting to set a non-ascii revision id but cant."""
 
1728
    """Raised when a commit is attempting to set a non-ascii revision id
 
1729
       but cant.
 
1730
    """
1604
1731
 
1605
1732
 
1606
1733
class BinaryFile(BzrError):
1619
1746
 
1620
1747
class TestamentMismatch(BzrError):
1621
1748
 
1622
 
    _fmt = """Testament did not match expected value.  
1623
 
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured 
 
1749
    _fmt = """Testament did not match expected value.
 
1750
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
1624
1751
       {%(measured)s}"""
1625
1752
 
1626
1753
    def __init__(self, revision_id, expected, measured):
1695
1822
        BadInventoryFormat.__init__(self, msg=msg)
1696
1823
 
1697
1824
 
 
1825
class RootNotRich(BzrError):
 
1826
 
 
1827
    _fmt = """This operation requires rich root data storage"""
 
1828
 
 
1829
 
1698
1830
class NoSmartMedium(BzrError):
1699
1831
 
1700
1832
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
 
1833
 
1701
1834
    internal_error = True
1702
1835
 
1703
1836
    def __init__(self, transport):
1721
1854
        self.vendor = vendor
1722
1855
 
1723
1856
 
 
1857
class SSHVendorNotFound(BzrError):
 
1858
 
 
1859
    _fmt = ("Don't know how to handle SSH connections."
 
1860
            " Please set BZR_SSH environment variable.")
 
1861
 
 
1862
 
1724
1863
class GhostRevisionUnusableHere(BzrError):
1725
1864
 
1726
1865
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
1732
1871
 
1733
1872
class IllegalUseOfScopeReplacer(BzrError):
1734
1873
 
1735
 
    _fmt = "ScopeReplacer object %(name)r was used incorrectly: %(msg)s%(extra)s"
 
1874
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
 
1875
            " %(msg)s%(extra)s")
1736
1876
 
1737
1877
    internal_error = True
1738
1878
 
1760
1900
 
1761
1901
class ImportNameCollision(BzrError):
1762
1902
 
1763
 
    _fmt = "Tried to import an object to the same name as an existing object. %(name)s"
 
1903
    _fmt = ("Tried to import an object to the same name as"
 
1904
            " an existing object. %(name)s")
1764
1905
 
1765
1906
    internal_error = True
1766
1907
 
1767
1908
    def __init__(self, name):
1768
1909
        BzrError.__init__(self)
1769
1910
        self.name = name
 
1911
 
 
1912
 
 
1913
class NotAMergeDirective(BzrError):
 
1914
    """File starting with %(firstline)r is not a merge directive"""
 
1915
    def __init__(self, firstline):
 
1916
        BzrError.__init__(self, firstline=firstline)
 
1917
 
 
1918
 
 
1919
class NoMergeSource(BzrError):
 
1920
    """Raise if no merge source was specified for a merge directive"""
 
1921
 
 
1922
    _fmt = "A merge directive must provide either a bundle or a public"\
 
1923
        " branch location."
 
1924
 
 
1925
 
 
1926
class PatchMissing(BzrError):
 
1927
    """Raise a patch type was specified but no patch supplied"""
 
1928
 
 
1929
    _fmt = "patch_type was %(patch_type)s, but no patch was supplied."
 
1930
 
 
1931
    def __init__(self, patch_type):
 
1932
        BzrError.__init__(self)
 
1933
        self.patch_type = patch_type
 
1934
 
 
1935
 
 
1936
class UnsupportedInventoryKind(BzrError):
 
1937
    
 
1938
    _fmt = """Unsupported entry kind %(kind)s"""
 
1939
 
 
1940
    def __init__(self, kind):
 
1941
        self.kind = kind
 
1942
 
 
1943
 
 
1944
class BadSubsumeSource(BzrError):
 
1945
 
 
1946
    _fmt = """Can't subsume %(other_tree)s into %(tree)s.  %(reason)s"""
 
1947
 
 
1948
    def __init__(self, tree, other_tree, reason):
 
1949
        self.tree = tree
 
1950
        self.other_tree = other_tree
 
1951
        self.reason = reason
 
1952
 
 
1953
 
 
1954
class SubsumeTargetNeedsUpgrade(BzrError):
 
1955
    
 
1956
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
 
1957
 
 
1958
    def __init__(self, other_tree):
 
1959
        self.other_tree = other_tree
 
1960
 
 
1961
 
 
1962
class BadReferenceTarget(BzrError):
 
1963
 
 
1964
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s.  %(reason)s"
 
1965
 
 
1966
    internal_error = True
 
1967
 
 
1968
    def __init__(self, tree, other_tree, reason):
 
1969
        self.tree = tree
 
1970
        self.other_tree = other_tree
 
1971
        self.reason = reason
 
1972
 
 
1973
 
 
1974
class NoSuchTag(BzrError):
 
1975
 
 
1976
    _fmt = "No such tag: %(tag_name)s"
 
1977
 
 
1978
    def __init__(self, tag_name):
 
1979
        self.tag_name = tag_name
 
1980
 
 
1981
 
 
1982
class TagsNotSupported(BzrError):
 
1983
 
 
1984
    _fmt = ("Tags not supported by %(branch)s;"
 
1985
            " you may be able to use bzr upgrade.")
 
1986
 
 
1987
    def __init__(self, branch):
 
1988
        self.branch = branch
 
1989
 
 
1990
        
 
1991
class TagAlreadyExists(BzrError):
 
1992
 
 
1993
    _fmt = "Tag %(tag_name)s already exists."
 
1994
 
 
1995
    def __init__(self, tag_name):
 
1996
        self.tag_name = tag_name