/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

remove all trailing whitespace from bzr source

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Exceptions for bzr, and reporting of them.
18
18
"""
154
154
               )
155
155
 
156
156
    def __eq__(self, other):
157
 
        if self.__class__ is not other.__class__:
 
157
        if self.__class__ != other.__class__:
158
158
            return NotImplemented
159
159
        return self.__dict__ == other.__dict__
160
160
 
636
636
        self.url = url
637
637
 
638
638
 
639
 
class UnstackableLocationError(BzrError):
640
 
 
641
 
    _fmt = "The branch '%(branch_url)s' cannot be stacked on '%(target_url)s'."
642
 
 
643
 
    def __init__(self, branch_url, target_url):
644
 
        BzrError.__init__(self)
645
 
        self.branch_url = branch_url
646
 
        self.target_url = target_url
647
 
 
648
 
 
649
639
class UnstackableRepositoryFormat(BzrError):
650
640
 
651
641
    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
702
692
# TODO: Probably this behavior of should be a common superclass
703
693
class NotBranchError(PathError):
704
694
 
705
 
    _fmt = 'Not a branch: "%(path)s"%(detail)s.'
 
695
    _fmt = 'Not a branch: "%(path)s".'
706
696
 
707
 
    def __init__(self, path, detail=None, bzrdir=None):
 
697
    def __init__(self, path):
708
698
       import bzrlib.urlutils as urlutils
709
 
       path = urlutils.unescape_for_display(path, 'ascii')
710
 
       if detail is not None:
711
 
           detail = ': ' + detail
712
 
       self.detail = detail
713
 
       self.bzrdir = bzrdir
714
 
       PathError.__init__(self, path=path)
715
 
 
716
 
    def _format(self):
717
 
        # XXX: Ideally self.detail would be a property, but Exceptions in
718
 
        # Python 2.4 have to be old-style classes so properties don't work.
719
 
        # Instead we override _format.
720
 
        if self.detail is None:
721
 
            if self.bzrdir is not None:
722
 
                try:
723
 
                    self.bzrdir.open_repository()
724
 
                except NoRepositoryPresent:
725
 
                    self.detail = ''
726
 
                else:
727
 
                    self.detail = ': location is a repository'
728
 
            else:
729
 
                self.detail = ''
730
 
        return PathError._format(self)
 
699
       self.path = urlutils.unescape_for_display(path, 'ascii')
731
700
 
732
701
 
733
702
class NoSubmitBranch(PathError):
814
783
 
815
784
 
816
785
class IncompatibleRepositories(BzrError):
817
 
    """Report an error that two repositories are not compatible.
818
 
 
819
 
    Note that the source and target repositories are permitted to be strings:
820
 
    this exception is thrown from the smart server and may refer to a
821
 
    repository the client hasn't opened.
822
 
    """
823
786
 
824
787
    _fmt = "%(target)s\n" \
825
788
            "is not compatible with\n" \
1040
1003
 
1041
1004
class LockContention(LockError):
1042
1005
 
1043
 
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
 
1006
    _fmt = 'Could not acquire lock "%(lock)s"'
1044
1007
    # TODO: show full url for lock, combining the transport and relative
1045
1008
    # bits?
1046
1009
 
1047
1010
    internal_error = False
1048
1011
 
1049
 
    def __init__(self, lock, msg=''):
 
1012
    def __init__(self, lock):
1050
1013
        self.lock = lock
1051
 
        self.msg = msg
1052
1014
 
1053
1015
 
1054
1016
class LockBroken(LockError):
1179
1141
 
1180
1142
class InvalidRevisionSpec(BzrError):
1181
1143
 
1182
 
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
 
1144
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
1183
1145
            " %(branch)s%(extra)s")
1184
1146
 
1185
1147
    def __init__(self, spec, branch, extra=None):
1210
1172
class DivergedBranches(BzrError):
1211
1173
 
1212
1174
    _fmt = ("These branches have diverged."
1213
 
            " Use the missing command to see how.\n"
1214
 
            "Use the merge command to reconcile them.")
 
1175
            " Use the merge command to reconcile them.")
1215
1176
 
1216
1177
    def __init__(self, branch1, branch2):
1217
1178
        self.branch1 = branch1
1265
1226
            not_ancestor_id=not_ancestor_id)
1266
1227
 
1267
1228
 
 
1229
class InstallFailed(BzrError):
 
1230
 
 
1231
    def __init__(self, revisions):
 
1232
        revision_str = ", ".join(str(r) for r in revisions)
 
1233
        msg = "Could not install revisions:\n%s" % revision_str
 
1234
        BzrError.__init__(self, msg)
 
1235
        self.revisions = revisions
 
1236
 
 
1237
 
1268
1238
class AmbiguousBase(BzrError):
1269
1239
 
1270
1240
    def __init__(self, bases):
1271
 
        symbol_versioning.warn("BzrError AmbiguousBase has been deprecated "
1272
 
            "as of bzrlib 0.8.", DeprecationWarning, stacklevel=2)
 
1241
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
 
1242
                DeprecationWarning)
1273
1243
        msg = ("The correct base is unclear, because %s are all equally close"
1274
1244
                % ", ".join(bases))
1275
1245
        BzrError.__init__(self, msg)
1297
1267
class BoundBranchOutOfDate(BzrError):
1298
1268
 
1299
1269
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
1300
 
            " %(master)s.%(extra_help)s")
 
1270
            " %(master)s.")
1301
1271
 
1302
1272
    def __init__(self, branch, master):
1303
1273
        BzrError.__init__(self)
1304
1274
        self.branch = branch
1305
1275
        self.master = master
1306
 
        self.extra_help = ''
1307
1276
 
1308
1277
 
1309
1278
class CommitToDoubleBoundBranch(BzrError):
1665
1634
            self.port = ':%s' % port
1666
1635
 
1667
1636
 
1668
 
# XXX: This is also used for unexpected end of file, which is different at the
1669
 
# TCP level from "connection reset".
1670
1637
class ConnectionReset(TransportError):
1671
1638
 
1672
1639
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
2034
2001
 
2035
2002
class BadConversionTarget(BzrError):
2036
2003
 
2037
 
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
2038
 
            "    %(problem)s"
 
2004
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
2039
2005
 
2040
 
    def __init__(self, problem, format, from_format=None):
 
2006
    def __init__(self, problem, format):
2041
2007
        BzrError.__init__(self)
2042
2008
        self.problem = problem
2043
2009
        self.format = format
2044
 
        self.from_format = from_format or '(unspecified)'
2045
2010
 
2046
2011
 
2047
2012
class NoDiffFound(BzrError):
2123
2088
 
2124
2089
class OutOfDateTree(BzrError):
2125
2090
 
2126
 
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
 
2091
    _fmt = "Working tree is out of date, please run 'bzr update'."
2127
2092
 
2128
 
    def __init__(self, tree, more=None):
2129
 
        if more is None:
2130
 
            more = ''
2131
 
        else:
2132
 
            more = ' ' + more
 
2093
    def __init__(self, tree):
2133
2094
        BzrError.__init__(self)
2134
2095
        self.tree = tree
2135
 
        self.more = more
2136
2096
 
2137
2097
 
2138
2098
class PublicBranchOutOfDate(BzrError):
2176
2136
 
2177
2137
    def __init__(self, repo):
2178
2138
        BzrError.__init__(self)
2179
 
        self.repo_path = repo.user_url
 
2139
        self.repo_path = repo.bzrdir.root_transport.base
2180
2140
 
2181
2141
 
2182
2142
class InconsistentDelta(BzrError):
2192
2152
        self.reason = reason
2193
2153
 
2194
2154
 
2195
 
class InconsistentDeltaDelta(InconsistentDelta):
2196
 
    """Used when we get a delta that is not valid."""
2197
 
 
2198
 
    _fmt = ("An inconsistent delta was supplied: %(delta)r"
2199
 
            "\nreason: %(reason)s")
2200
 
 
2201
 
    def __init__(self, delta, reason):
2202
 
        BzrError.__init__(self)
2203
 
        self.delta = delta
2204
 
        self.reason = reason
2205
 
 
2206
 
 
2207
2155
class UpgradeRequired(BzrError):
2208
2156
 
2209
2157
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
2218
2166
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
2219
2167
 
2220
2168
 
2221
 
class RichRootUpgradeRequired(UpgradeRequired):
2222
 
 
2223
 
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
2224
 
           " a format which supports rich roots.")
2225
 
 
2226
 
 
2227
2169
class LocalRequiresBoundBranch(BzrError):
2228
2170
 
2229
2171
    _fmt = "Cannot perform local-only commits on unbound branches."
2230
2172
 
2231
2173
 
 
2174
class InvalidProgressBarType(BzrError):
 
2175
 
 
2176
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
 
2177
            " is not a supported type Select one of: %(valid_types)s")
 
2178
 
 
2179
    def __init__(self, bar_type, valid_types):
 
2180
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
 
2181
 
 
2182
 
2232
2183
class UnsupportedOperation(BzrError):
2233
2184
 
2234
2185
    _fmt = ("The method %(mname)s is not supported on"
2355
2306
        self.transport = transport
2356
2307
 
2357
2308
 
 
2309
class NoSmartServer(NotBranchError):
 
2310
 
 
2311
    _fmt = "No smart server available at %(url)s"
 
2312
 
 
2313
    @symbol_versioning.deprecated_method(symbol_versioning.one_four)
 
2314
    def __init__(self, url):
 
2315
        self.url = url
 
2316
 
 
2317
 
2358
2318
class UnknownSSH(BzrError):
2359
2319
 
2360
2320
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2541
2501
 
2542
2502
class MalformedBugIdentifier(BzrError):
2543
2503
 
2544
 
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
2545
 
            'See "bzr help bugs" for more information on this feature.')
 
2504
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
2546
2505
 
2547
2506
    def __init__(self, bug_id, reason):
2548
2507
        self.bug_id = bug_id
2569
2528
        self.branch = branch
2570
2529
 
2571
2530
 
2572
 
class InvalidLineInBugsProperty(BzrError):
2573
 
 
2574
 
    _fmt = ("Invalid line in bugs property: '%(line)s'")
2575
 
 
2576
 
    def __init__(self, line):
2577
 
        self.line = line
2578
 
 
2579
 
 
2580
 
class InvalidBugStatus(BzrError):
2581
 
 
2582
 
    _fmt = ("Invalid bug status: '%(status)s'")
2583
 
 
2584
 
    def __init__(self, status):
2585
 
        self.status = status
2586
 
 
2587
 
 
2588
2531
class UnexpectedSmartServerResponse(BzrError):
2589
2532
 
2590
2533
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2715
2658
 
2716
2659
class NoMailAddressSpecified(BzrError):
2717
2660
 
2718
 
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
 
2661
    _fmt = "No mail-to address specified."
2719
2662
 
2720
2663
 
2721
2664
class UnknownMailClient(BzrError):
2754
2697
 
2755
2698
    def __init__(self, bzrdir):
2756
2699
        import bzrlib.urlutils as urlutils
2757
 
        display_url = urlutils.unescape_for_display(bzrdir.user_url,
 
2700
        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,
2758
2701
                                                    'ascii')
2759
2702
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
2760
2703
 
2801
2744
    _fmt = "'%(display_url)s' is already standalone."
2802
2745
 
2803
2746
 
2804
 
class AlreadyWithTrees(BzrDirError):
2805
 
 
2806
 
    _fmt = ("Shared repository '%(display_url)s' already creates "
2807
 
            "working trees.")
2808
 
 
2809
 
 
2810
 
class AlreadyWithNoTrees(BzrDirError):
2811
 
 
2812
 
    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
2813
 
            "working trees.")
2814
 
 
2815
 
 
2816
2747
class ReconfigurationNotSupported(BzrDirError):
2817
2748
 
2818
2749
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
2825
2756
 
2826
2757
class UncommittedChanges(BzrError):
2827
2758
 
2828
 
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
2829
 
            ' (See bzr status).%(more)s')
 
2759
    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'
2830
2760
 
2831
 
    def __init__(self, tree, more=None):
2832
 
        if more is None:
2833
 
            more = ''
2834
 
        else:
2835
 
            more = ' ' + more
 
2761
    def __init__(self, tree):
2836
2762
        import bzrlib.urlutils as urlutils
2837
2763
        display_url = urlutils.unescape_for_display(
2838
 
            tree.user_url, 'ascii')
2839
 
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
 
2764
            tree.bzrdir.root_transport.base, 'ascii')
 
2765
        BzrError.__init__(self, tree=tree, display_url=display_url)
2840
2766
 
2841
2767
 
2842
2768
class MissingTemplateVariable(BzrError):
2901
2827
    pass
2902
2828
 
2903
2829
 
 
2830
class NotATerminal(BzrError):
 
2831
 
 
2832
    _fmt = 'Unable to ask for a password without real terminal.'
 
2833
 
 
2834
 
2904
2835
class UnableEncodePath(BzrError):
2905
2836
 
2906
2837
    _fmt = ('Unable to encode %(kind)s path %(path)r in '
2948
2879
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
2949
2880
 
2950
2881
    def __init__(self, host, port, orig_error):
2951
 
        # nb: in python2.4 socket.error doesn't have a useful repr
2952
2882
        BzrError.__init__(self, host=host, port=port,
2953
 
            orig_error=repr(orig_error.args))
 
2883
            orig_error=orig_error[1])
2954
2884
 
2955
2885
 
2956
2886
class UnknownRules(BzrError):
2964
2894
class HookFailed(BzrError):
2965
2895
    """Raised when a pre_change_branch_tip hook function fails anything other
2966
2896
    than TipChangeRejected.
2967
 
 
2968
 
    Note that this exception is no longer raised, and the import is only left
2969
 
    to be nice to code which might catch it in a plugin.
2970
2897
    """
2971
2898
 
2972
2899
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
2973
2900
            "%(traceback_text)s%(exc_value)s")
2974
2901
 
2975
 
    def __init__(self, hook_stage, hook_name, exc_info, warn=True):
2976
 
        if warn:
2977
 
            symbol_versioning.warn("BzrError HookFailed has been deprecated "
2978
 
                "as of bzrlib 2.1.", DeprecationWarning, stacklevel=2)
 
2902
    def __init__(self, hook_stage, hook_name, exc_info):
2979
2903
        import traceback
2980
2904
        self.hook_stage = hook_stage
2981
2905
        self.hook_name = hook_name
3010
2934
        BzrError.__init__(self, shelf_id=shelf_id)
3011
2935
 
3012
2936
 
3013
 
class InvalidShelfId(BzrError):
3014
 
 
3015
 
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
3016
 
 
3017
 
    def __init__(self, invalid_id):
3018
 
        BzrError.__init__(self, invalid_id=invalid_id)
3019
 
 
3020
 
 
3021
 
class JailBreak(BzrError):
3022
 
 
3023
 
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
3024
 
 
3025
 
    def __init__(self, url):
3026
 
        BzrError.__init__(self, url=url)
3027
 
 
3028
 
 
3029
2937
class UserAbort(BzrError):
3030
2938
 
3031
2939
    _fmt = 'The user aborted the operation.'
3032
 
 
3033
 
 
3034
 
class MustHaveWorkingTree(BzrError):
3035
 
 
3036
 
    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
3037
 
 
3038
 
    def __init__(self, format, url):
3039
 
        BzrError.__init__(self, format=format, url=url)
3040
 
 
3041
 
 
3042
 
class NoSuchView(BzrError):
3043
 
    """A view does not exist.
3044
 
    """
3045
 
 
3046
 
    _fmt = u"No such view: %(view_name)s."
3047
 
 
3048
 
    def __init__(self, view_name):
3049
 
        self.view_name = view_name
3050
 
 
3051
 
 
3052
 
class ViewsNotSupported(BzrError):
3053
 
    """Views are not supported by a tree format.
3054
 
    """
3055
 
 
3056
 
    _fmt = ("Views are not supported by %(tree)s;"
3057
 
            " use 'bzr upgrade' to change your tree to a later format.")
3058
 
 
3059
 
    def __init__(self, tree):
3060
 
        self.tree = tree
3061
 
 
3062
 
 
3063
 
class FileOutsideView(BzrError):
3064
 
 
3065
 
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
3066
 
            '%(view_str)s')
3067
 
 
3068
 
    def __init__(self, file_name, view_files):
3069
 
        self.file_name = file_name
3070
 
        self.view_str = ", ".join(view_files)
3071
 
 
3072
 
 
3073
 
class UnresumableWriteGroup(BzrError):
3074
 
 
3075
 
    _fmt = ("Repository %(repository)s cannot resume write group "
3076
 
            "%(write_groups)r: %(reason)s")
3077
 
 
3078
 
    internal_error = True
3079
 
 
3080
 
    def __init__(self, repository, write_groups, reason):
3081
 
        self.repository = repository
3082
 
        self.write_groups = write_groups
3083
 
        self.reason = reason
3084
 
 
3085
 
 
3086
 
class UnsuspendableWriteGroup(BzrError):
3087
 
 
3088
 
    _fmt = ("Repository %(repository)s cannot suspend a write group.")
3089
 
 
3090
 
    internal_error = True
3091
 
 
3092
 
    def __init__(self, repository):
3093
 
        self.repository = repository
3094
 
 
3095
 
 
3096
 
class LossyPushToSameVCS(BzrError):
3097
 
 
3098
 
    _fmt = ("Lossy push not possible between %(source_branch)r and "
3099
 
            "%(target_branch)r that are in the same VCS.")
3100
 
 
3101
 
    internal_error = True
3102
 
 
3103
 
    def __init__(self, source_branch, target_branch):
3104
 
        self.source_branch = source_branch
3105
 
        self.target_branch = target_branch
3106
 
 
3107
 
 
3108
 
class NoRoundtrippingSupport(BzrError):
3109
 
 
3110
 
    _fmt = ("Roundtripping is not supported between %(source_branch)r and "
3111
 
            "%(target_branch)r.")
3112
 
 
3113
 
    internal_error = True
3114
 
 
3115
 
    def __init__(self, source_branch, target_branch):
3116
 
        self.source_branch = source_branch
3117
 
        self.target_branch = target_branch
3118
 
 
3119
 
 
3120
 
class FileTimestampUnavailable(BzrError):
3121
 
 
3122
 
    _fmt = "The filestamp for %(path)s is not available."
3123
 
 
3124
 
    internal_error = True
3125
 
 
3126
 
    def __init__(self, path):
3127
 
        self.path = path
3128
 
 
3129
 
 
3130
 
class NoColocatedBranchSupport(BzrError):
3131
 
 
3132
 
    _fmt = ("%(bzrdir)r does not support co-located branches.")
3133
 
 
3134
 
    def __init__(self, bzrdir):
3135
 
        self.bzrdir = bzrdir
3136