← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Martin Pool
  • Date: 2008-03-16 08:25:21 UTC
  • mto: (3280.2.2 prepare-1.3)
  • mto: This revision was merged to the branch mainline in revision 3284.
  • Revision ID: mbp@sourcefrog.net-20080316082521-xmex8wq1uyj6cxyh
Fix doctest syntax

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
1
 
# Copyright (C) 2005, 2006 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
44
44
# 'unprintable'.
45
45
 
46
46
 
 
47
# return codes from the bzr program
 
48
EXIT_OK = 0
 
49
EXIT_ERROR = 3
 
50
EXIT_INTERNAL_ERROR = 4
 
51
 
 
52
 
47
53
class BzrError(StandardError):
48
54
    """
49
55
    Base class for errors raised by bzrlib.
50
56
 
51
 
    :cvar internal_error: if true (or absent) this was probably caused by a
52
 
    bzr bug and should be displayed with a traceback; if False this was
 
57
    :cvar internal_error: if True this was probably caused by a bzr bug and
 
58
    should be displayed with a traceback; if False (or absent) this was
53
59
    probably a user or environment error and they don't need the gory details.
54
60
    (That can be overridden by -Derror on the command line.)
55
61
 
95
101
        try:
96
102
            fmt = self._get_format_string()
97
103
            if fmt:
98
 
                s = fmt % self.__dict__
 
104
                d = dict(self.__dict__)
 
105
                # special case: python2.5 puts the 'message' attribute in a
 
106
                # slot, so it isn't seen in __dict__
 
107
                d['message'] = getattr(self, 'message', 'no message')
 
108
                s = fmt % d
99
109
                # __str__() should always return a 'str' object
100
110
                # never a 'unicode' object.
101
111
                if isinstance(s, unicode):
102
112
                    return s.encode('utf8')
103
113
                return s
104
114
        except (AttributeError, TypeError, NameError, ValueError, KeyError), e:
105
 
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%s' \
 
115
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
106
116
                % (self.__class__.__name__,
107
117
                   self.__dict__,
108
118
                   getattr(self, '_fmt', None),
109
 
                   str(e))
 
119
                   e)
110
120
 
111
121
    def _get_format_string(self):
112
122
        """Return format string for this exception or None"""
126
136
               )
127
137
 
128
138
 
 
139
class InternalBzrError(BzrError):
 
140
    """Base class for errors that are internal in nature.
 
141
 
 
142
    This is a convenience class for errors that are internal. The
 
143
    internal_error attribute can still be altered in subclasses, if needed.
 
144
    Using this class is simply an easy way to get internal errors.
 
145
    """
 
146
 
 
147
    internal_error = True
 
148
 
 
149
 
129
150
class BzrNewError(BzrError):
130
151
    """Deprecated error base class."""
131
152
    # base classes should override the docstring with their human-
132
153
    # readable explanation
133
154
 
134
155
    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
 
156
        # XXX: Use the underlying BzrError to always generate the args
 
157
        # attribute if it doesn't exist.  We can't use super here, because
 
158
        # exceptions are old-style classes in python2.4 (but new in 2.5).
 
159
        # --bmc, 20060426
138
160
        symbol_versioning.warn('BzrNewError was deprecated in bzr 0.13; '
139
 
             'please convert %s to use BzrError instead' 
 
161
             'please convert %s to use BzrError instead'
140
162
             % self.__class__.__name__,
141
163
             DeprecationWarning,
142
164
             stacklevel=2)
153
175
                return s.encode('utf8')
154
176
            return s
155
177
        except (TypeError, NameError, ValueError, KeyError), e:
156
 
            return 'Unprintable exception %s(%r): %s' \
 
178
            return 'Unprintable exception %s(%r): %r' \
157
179
                % (self.__class__.__name__,
158
 
                   self.__dict__, str(e))
 
180
                   self.__dict__, e)
159
181
 
160
182
 
161
183
class AlreadyBuilding(BzrError):
163
185
    _fmt = "The tree builder is already building a tree."
164
186
 
165
187
 
166
 
class BzrCheckError(BzrError):
 
188
class BzrCheckError(InternalBzrError):
167
189
    
168
190
    _fmt = "Internal check failed: %(message)s"
169
191
 
170
 
    internal_error = True
171
 
 
172
192
    def __init__(self, message):
173
193
        BzrError.__init__(self)
174
194
        self.message = message
175
195
 
176
196
 
177
 
class InvalidEntryName(BzrError):
 
197
class DisabledMethod(InternalBzrError):
 
198
 
 
199
    _fmt = "The smart server method '%(class_name)s' is disabled."
 
200
 
 
201
    def __init__(self, class_name):
 
202
        BzrError.__init__(self)
 
203
        self.class_name = class_name
 
204
 
 
205
 
 
206
class IncompatibleAPI(BzrError):
 
207
 
 
208
    _fmt = 'The API for "%(api)s" is not compatible with "%(wanted)s". '\
 
209
        'It supports versions "%(minimum)s" to "%(current)s".'
 
210
 
 
211
    def __init__(self, api, wanted, minimum, current):
 
212
        self.api = api
 
213
        self.wanted = wanted
 
214
        self.minimum = minimum
 
215
        self.current = current
 
216
 
 
217
 
 
218
class InProcessTransport(BzrError):
 
219
 
 
220
    _fmt = "The transport '%(transport)s' is only accessible within this " \
 
221
        "process."
 
222
 
 
223
    def __init__(self, transport):
 
224
        self.transport = transport
 
225
 
 
226
 
 
227
class InvalidEntryName(InternalBzrError):
178
228
    
179
229
    _fmt = "Invalid entry name: %(name)s"
180
230
 
181
 
    internal_error = True
182
 
 
183
231
    def __init__(self, name):
184
232
        BzrError.__init__(self)
185
233
        self.name = name
204
252
        self.revision_id = revision_id
205
253
        self.branch = branch
206
254
 
 
255
 
207
256
class ReservedId(BzrError):
208
257
 
209
258
    _fmt = "Reserved revision-id {%(revision_id)s}"
211
260
    def __init__(self, revision_id):
212
261
        self.revision_id = revision_id
213
262
 
 
263
 
 
264
class RootMissing(InternalBzrError):
 
265
 
 
266
    _fmt = ("The root entry of a tree must be the first entry supplied to "
 
267
        "record_entry_contents.")
 
268
 
 
269
 
 
270
class NoPublicBranch(BzrError):
 
271
 
 
272
    _fmt = 'There is no public branch set for "%(branch_url)s".'
 
273
 
 
274
    def __init__(self, branch):
 
275
        import bzrlib.urlutils as urlutils
 
276
        public_location = urlutils.unescape_for_display(branch.base, 'ascii')
 
277
        BzrError.__init__(self, branch_url=public_location)
 
278
 
 
279
 
 
280
class NoHelpTopic(BzrError):
 
281
 
 
282
    _fmt = ("No help could be found for '%(topic)s'. "
 
283
        "Please use 'bzr help topics' to obtain a list of topics.")
 
284
 
 
285
    def __init__(self, topic):
 
286
        self.topic = topic
 
287
 
 
288
 
214
289
class NoSuchId(BzrError):
215
290
 
216
 
    _fmt = "The file id %(file_id)s is not present in the tree %(tree)s."
 
291
    _fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
217
292
    
218
293
    def __init__(self, tree, file_id):
219
294
        BzrError.__init__(self)
221
296
        self.tree = tree
222
297
 
223
298
 
224
 
class InventoryModified(BzrError):
225
 
 
226
 
    _fmt = ("The current inventory for the tree %(tree)r has been modified, "
227
 
            "so a clean inventory cannot be read without data loss.")
228
 
 
229
 
    internal_error = True
 
299
class NoSuchIdInRepository(NoSuchId):
 
300
 
 
301
    _fmt = ('The file id "%(file_id)s" is not present in the repository'
 
302
            ' %(repository)r')
 
303
 
 
304
    def __init__(self, repository, file_id):
 
305
        BzrError.__init__(self, repository=repository, file_id=file_id)
 
306
 
 
307
 
 
308
class InventoryModified(InternalBzrError):
 
309
 
 
310
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
 
311
            " so a clean inventory cannot be read without data loss.")
230
312
 
231
313
    def __init__(self, tree):
232
314
        self.tree = tree
234
316
 
235
317
class NoWorkingTree(BzrError):
236
318
 
237
 
    _fmt = "No WorkingTree exists for %(base)s."
 
319
    _fmt = 'No WorkingTree exists for "%(base)s".'
238
320
    
239
321
    def __init__(self, base):
240
322
        BzrError.__init__(self)
254
336
        self.url = url
255
337
 
256
338
 
257
 
class WorkingTreeAlreadyPopulated(BzrError):
258
 
 
259
 
    _fmt = """Working tree already populated in %(base)s"""
260
 
 
261
 
    internal_error = True
 
339
class WorkingTreeAlreadyPopulated(InternalBzrError):
 
340
 
 
341
    _fmt = 'Working tree already populated in "%(base)s"'
262
342
 
263
343
    def __init__(self, base):
264
344
        self.base = base
265
345
 
 
346
 
266
347
class BzrCommandError(BzrError):
267
348
    """Error from user command"""
268
349
 
269
 
    internal_error = False
270
 
 
271
350
    # Error from malformed user command; please avoid raising this as a
272
351
    # generic exception not caused by user input.
273
352
    #
300
379
    _fmt = "Error in command line options"
301
380
 
302
381
 
 
382
class BadIndexFormatSignature(BzrError):
 
383
 
 
384
    _fmt = "%(value)s is not an index of type %(_type)s."
 
385
 
 
386
    def __init__(self, value, _type):
 
387
        BzrError.__init__(self)
 
388
        self.value = value
 
389
        self._type = _type
 
390
 
 
391
 
 
392
class BadIndexData(BzrError):
 
393
 
 
394
    _fmt = "Error in data for index %(value)s."
 
395
 
 
396
    def __init__(self, value):
 
397
        BzrError.__init__(self)
 
398
        self.value = value
 
399
 
 
400
 
 
401
class BadIndexDuplicateKey(BzrError):
 
402
 
 
403
    _fmt = "The key '%(key)s' is already in index '%(index)s'."
 
404
 
 
405
    def __init__(self, key, index):
 
406
        BzrError.__init__(self)
 
407
        self.key = key
 
408
        self.index = index
 
409
 
 
410
 
 
411
class BadIndexKey(BzrError):
 
412
 
 
413
    _fmt = "The key '%(key)s' is not a valid key."
 
414
 
 
415
    def __init__(self, key):
 
416
        BzrError.__init__(self)
 
417
        self.key = key
 
418
 
 
419
 
 
420
class BadIndexOptions(BzrError):
 
421
 
 
422
    _fmt = "Could not parse options for index %(value)s."
 
423
 
 
424
    def __init__(self, value):
 
425
        BzrError.__init__(self)
 
426
        self.value = value
 
427
 
 
428
 
 
429
class BadIndexValue(BzrError):
 
430
 
 
431
    _fmt = "The value '%(value)s' is not a valid value."
 
432
 
 
433
    def __init__(self, value):
 
434
        BzrError.__init__(self)
 
435
        self.value = value
 
436
 
 
437
 
303
438
class BadOptionValue(BzrError):
304
439
 
305
440
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
315
450
 
316
451
# XXX: Should be unified with TransportError; they seem to represent the
317
452
# same thing
 
453
# RBC 20060929: I think that unifiying with TransportError would be a mistake
 
454
# - this is finer than a TransportError - and more useful as such. It 
 
455
# differentiates between 'transport has failed' and 'operation on a transport
 
456
# has failed.'
318
457
class PathError(BzrError):
319
458
    
320
459
    _fmt = "Generic path error: %(path)r%(extra)s)"
342
481
    """Used when renaming and both source and dest exist."""
343
482
 
344
483
    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
345
 
         "%(extra)s")
 
484
            " (Use --after to tell bzr about a rename that has already"
 
485
            " happened)%(extra)s")
346
486
 
347
487
    def __init__(self, source, dest, extra=None):
348
488
        BzrError.__init__(self)
356
496
 
357
497
class NotADirectory(PathError):
358
498
 
359
 
    _fmt = "%(path)r is not a directory %(extra)s"
 
499
    _fmt = '"%(path)s" is not a directory %(extra)s'
360
500
 
361
501
 
362
502
class NotInWorkingDirectory(PathError):
363
503
 
364
 
    _fmt = "%(path)r is not in the working directory %(extra)s"
 
504
    _fmt = '"%(path)s" is not in the working directory %(extra)s'
365
505
 
366
506
 
367
507
class DirectoryNotEmpty(PathError):
368
508
 
369
 
    _fmt = "Directory not empty: %(path)r%(extra)s"
370
 
 
371
 
 
372
 
class ReadingCompleted(BzrError):
 
509
    _fmt = 'Directory not empty: "%(path)s"%(extra)s'
 
510
 
 
511
 
 
512
class HardLinkNotSupported(PathError):
 
513
 
 
514
    _fmt = 'Hard-linking "%(path)s" is not supported'
 
515
 
 
516
 
 
517
class ReadingCompleted(InternalBzrError):
373
518
    
374
519
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
375
520
            "called upon it - the request has been completed and no more "
376
521
            "data may be read.")
377
522
 
378
 
    internal_error = True
379
 
 
380
523
    def __init__(self, request):
381
524
        self.request = request
382
525
 
383
526
 
384
527
class ResourceBusy(PathError):
385
528
 
386
 
    _fmt = "Device or resource busy: %(path)r%(extra)s"
 
529
    _fmt = 'Device or resource busy: "%(path)s"%(extra)s'
387
530
 
388
531
 
389
532
class PermissionDenied(PathError):
390
533
 
391
 
    _fmt = "Permission denied: %(path)r%(extra)s"
 
534
    _fmt = 'Permission denied: "%(path)s"%(extra)s'
392
535
 
393
536
 
394
537
class InvalidURL(PathError):
395
538
 
396
 
    _fmt = "Invalid url supplied to transport: %(path)r%(extra)s"
 
539
    _fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
397
540
 
398
541
 
399
542
class InvalidURLJoin(PathError):
400
543
 
401
 
    _fmt = "Invalid URL join request: %(args)s%(extra)s"
 
544
    _fmt = 'Invalid URL join request: "%(args)s"%(extra)s'
402
545
 
403
546
    def __init__(self, msg, base, args):
404
547
        PathError.__init__(self, base, msg)
423
566
        PathError.__init__(self, url, extra=extra)
424
567
 
425
568
 
 
569
class ReadError(PathError):
 
570
    
 
571
    _fmt = """Error reading from %(path)r."""
 
572
 
 
573
 
426
574
class ShortReadvError(PathError):
427
575
 
428
 
    _fmt = "readv() read %(actual)s bytes rather than %(length)s bytes at %(offset)s for %(path)s%(extra)s"
 
576
    _fmt = ('readv() read %(actual)s bytes rather than %(length)s bytes'
 
577
            ' at %(offset)s for "%(path)s"%(extra)s')
429
578
 
430
579
    internal_error = True
431
580
 
436
585
        self.actual = actual
437
586
 
438
587
 
439
 
class PathNotChild(BzrError):
 
588
class PathNotChild(PathError):
440
589
 
441
 
    _fmt = "Path %(path)r is not a child of path %(base)r%(extra)s"
 
590
    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
442
591
 
443
592
    internal_error = True
444
593
 
454
603
 
455
604
class InvalidNormalization(PathError):
456
605
 
457
 
    _fmt = "Path %(path)r is not unicode normalized"
 
606
    _fmt = 'Path "%(path)s" is not unicode normalized'
458
607
 
459
608
 
460
609
# TODO: This is given a URL; we try to unescape it but doing that from inside
462
611
# TODO: Probably this behavior of should be a common superclass 
463
612
class NotBranchError(PathError):
464
613
 
465
 
    _fmt = "Not a branch: %(path)s"
 
614
    _fmt = 'Not a branch: "%(path)s".'
466
615
 
467
616
    def __init__(self, path):
468
617
       import bzrlib.urlutils as urlutils
469
618
       self.path = urlutils.unescape_for_display(path, 'ascii')
470
619
 
471
620
 
 
621
class NoSubmitBranch(PathError):
 
622
 
 
623
    _fmt = 'No submit branch available for branch "%(path)s"'
 
624
 
 
625
    def __init__(self, branch):
 
626
       import bzrlib.urlutils as urlutils
 
627
       self.path = urlutils.unescape_for_display(branch.base, 'ascii')
 
628
 
 
629
 
472
630
class AlreadyBranchError(PathError):
473
631
 
474
 
    _fmt = "Already a branch: %(path)s."
 
632
    _fmt = 'Already a branch: "%(path)s".'
475
633
 
476
634
 
477
635
class BranchExistsWithoutWorkingTree(PathError):
478
636
 
479
 
    _fmt = "Directory contains a branch, but no working tree \
480
 
(use bzr checkout if you wish to build a working tree): %(path)s"
 
637
    _fmt = 'Directory contains a branch, but no working tree \
 
638
(use bzr checkout if you wish to build a working tree): "%(path)s"'
481
639
 
482
640
 
483
641
class AtomicFileAlreadyClosed(PathError):
484
642
 
485
 
    _fmt = "'%(function)s' called on an AtomicFile after it was closed: %(path)s"
 
643
    _fmt = ('"%(function)s" called on an AtomicFile after it was closed:'
 
644
            ' "%(path)s"')
486
645
 
487
646
    def __init__(self, path, function):
488
647
        PathError.__init__(self, path=path, extra=None)
491
650
 
492
651
class InaccessibleParent(PathError):
493
652
 
494
 
    _fmt = "Parent not accessible given base %(base)s and relative path %(path)s"
 
653
    _fmt = ('Parent not accessible given base "%(base)s" and'
 
654
            ' relative path "%(path)s"')
495
655
 
496
656
    def __init__(self, path, base):
497
657
        PathError.__init__(self, path)
500
660
 
501
661
class NoRepositoryPresent(BzrError):
502
662
 
503
 
    _fmt = "No repository present: %(path)r"
 
663
    _fmt = 'No repository present: "%(path)s"'
504
664
    def __init__(self, bzrdir):
505
665
        BzrError.__init__(self)
506
666
        self.path = bzrdir.transport.clone('..').base
508
668
 
509
669
class FileInWrongBranch(BzrError):
510
670
 
511
 
    _fmt = "File %(path)s in not in branch %(branch_base)s."
 
671
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
512
672
 
513
673
    def __init__(self, branch, path):
514
674
        BzrError.__init__(self)
518
678
 
519
679
 
520
680
class UnsupportedFormatError(BzrError):
521
 
    
522
 
    _fmt = "Unsupported branch format: %(format)s"
 
681
 
 
682
    _fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
523
683
 
524
684
 
525
685
class UnknownFormatError(BzrError):
526
686
    
527
 
    _fmt = "Unknown branch format: %(format)r"
 
687
    _fmt = "Unknown %(kind)s format: %(format)r"
 
688
 
 
689
    def __init__(self, format, kind='branch'):
 
690
        self.kind = kind
 
691
        self.format = format
528
692
 
529
693
 
530
694
class IncompatibleFormat(BzrError):
537
701
        self.bzrdir = bzrdir_format
538
702
 
539
703
 
 
704
class IncompatibleRepositories(BzrError):
 
705
 
 
706
    _fmt = "Repository %(target)s is not compatible with repository"\
 
707
        " %(source)s"
 
708
 
 
709
    def __init__(self, source, target):
 
710
        BzrError.__init__(self, target=target, source=source)
 
711
 
 
712
 
540
713
class IncompatibleRevision(BzrError):
541
714
    
542
715
    _fmt = "Revision is not compatible with %(repo_format)s"
549
722
class AlreadyVersionedError(BzrError):
550
723
    """Used when a path is expected not to be versioned, but it is."""
551
724
 
552
 
    _fmt = "%(context_info)s%(path)s is already versioned"
 
725
    _fmt = "%(context_info)s%(path)s is already versioned."
553
726
 
554
727
    def __init__(self, path, context_info=None):
555
728
        """Construct a new AlreadyVersionedError.
570
743
class NotVersionedError(BzrError):
571
744
    """Used when a path is expected to be versioned, but it is not."""
572
745
 
573
 
    _fmt = "%(context_info)s%(path)s is not versioned"
 
746
    _fmt = "%(context_info)s%(path)s is not versioned."
574
747
 
575
748
    def __init__(self, path, context_info=None):
576
749
        """Construct a new NotVersionedError.
621
794
 
622
795
class BadFileKindError(BzrError):
623
796
 
624
 
    _fmt = "Cannot operate on %(filename)s of unsupported kind %(kind)s"
 
797
    _fmt = 'Cannot operate on "%(filename)s" of unsupported kind "%(kind)s"'
 
798
 
 
799
    def __init__(self, filename, kind):
 
800
        BzrError.__init__(self, filename=filename, kind=kind)
625
801
 
626
802
 
627
803
class ForbiddenControlFileError(BzrError):
628
804
 
629
 
    _fmt = "Cannot operate on %(filename)s because it is a control file"
630
 
 
631
 
 
632
 
class LockError(BzrError):
633
 
 
634
 
    _fmt = "Lock error: %(message)s"
635
 
 
636
 
    internal_error = True
 
805
    _fmt = 'Cannot operate on "%(filename)s" because it is a control file'
 
806
 
 
807
 
 
808
class LockError(InternalBzrError):
 
809
 
 
810
    _fmt = "Lock error: %(msg)s"
637
811
 
638
812
    # All exceptions from the lock/unlock functions should be from
639
813
    # this exception class.  They will be translated as necessary. The
641
815
    #
642
816
    # New code should prefer to raise specific subclasses
643
817
    def __init__(self, message):
644
 
        self.message = message
 
818
        # Python 2.5 uses a slot for StandardError.message,
 
819
        # so use a different variable name.  We now work around this in
 
820
        # BzrError.__str__, but this member name is kept for compatability.
 
821
        self.msg = message
 
822
 
 
823
 
 
824
class LockActive(LockError):
 
825
 
 
826
    _fmt = "The lock for '%(lock_description)s' is in use and cannot be broken."
 
827
 
 
828
    internal_error = False
 
829
 
 
830
    def __init__(self, lock_description):
 
831
        self.lock_description = lock_description
645
832
 
646
833
 
647
834
class CommitNotPossible(LockError):
664
851
 
665
852
    _fmt = "A write attempt was made in a read only transaction on %(obj)s"
666
853
 
 
854
    # TODO: There should also be an error indicating that you need a write
 
855
    # lock and don't have any lock at all... mbp 20070226
 
856
 
667
857
    def __init__(self, obj):
668
858
        self.obj = obj
669
859
 
670
860
 
 
861
class ReadOnlyLockError(LockError):
 
862
 
 
863
    _fmt = "Cannot acquire write lock on %(fname)s. %(msg)s"
 
864
 
 
865
    @symbol_versioning.deprecated_method(symbol_versioning.zero_ninetytwo)
 
866
    def __init__(self, fname, msg):
 
867
        LockError.__init__(self, '')
 
868
        self.fname = fname
 
869
        self.msg = msg
 
870
 
 
871
 
 
872
class LockFailed(LockError):
 
873
 
 
874
    internal_error = False
 
875
 
 
876
    _fmt = "Cannot lock %(lock)s: %(why)s"
 
877
 
 
878
    def __init__(self, lock, why):
 
879
        LockError.__init__(self, '')
 
880
        self.lock = lock
 
881
        self.why = why
 
882
 
 
883
 
671
884
class OutSideTransaction(BzrError):
672
885
 
673
 
    _fmt = "A transaction related operation was attempted after the transaction finished."
 
886
    _fmt = ("A transaction related operation was attempted after"
 
887
            " the transaction finished.")
674
888
 
675
889
 
676
890
class ObjectNotLocked(LockError):
694
908
 
695
909
class UnlockableTransport(LockError):
696
910
 
 
911
    internal_error = False
 
912
 
697
913
    _fmt = "Cannot lock: transport is read only: %(transport)s"
698
914
 
699
915
    def __init__(self, transport):
702
918
 
703
919
class LockContention(LockError):
704
920
 
705
 
    _fmt = "Could not acquire lock %(lock)s"
 
921
    _fmt = 'Could not acquire lock "%(lock)s"'
706
922
    # TODO: show full url for lock, combining the transport and relative
707
923
    # bits?
708
924
 
709
925
    internal_error = False
710
 
    
 
926
 
711
927
    def __init__(self, lock):
712
928
        self.lock = lock
713
929
 
714
930
 
715
931
class LockBroken(LockError):
716
932
 
717
 
    _fmt = "Lock was broken while still open: %(lock)s - check storage consistency!"
 
933
    _fmt = ("Lock was broken while still open: %(lock)s"
 
934
            " - check storage consistency!")
718
935
 
719
936
    internal_error = False
720
937
 
724
941
 
725
942
class LockBreakMismatch(LockError):
726
943
 
727
 
    _fmt = "Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)r, wanted to break %(target)r"
 
944
    _fmt = ("Lock was released and re-acquired before being broken:"
 
945
            " %(lock)s: held by %(holder)r, wanted to break %(target)r")
728
946
 
729
947
    internal_error = False
730
948
 
744
962
        self.lock = lock
745
963
 
746
964
 
 
965
class TokenLockingNotSupported(LockError):
 
966
 
 
967
    _fmt = "The object %(obj)s does not support token specifying a token when locking."
 
968
 
 
969
    def __init__(self, obj):
 
970
        self.obj = obj
 
971
 
 
972
 
 
973
class TokenMismatch(LockBroken):
 
974
 
 
975
    _fmt = "The lock token %(given_token)r does not match lock token %(lock_token)r."
 
976
 
 
977
    internal_error = True
 
978
 
 
979
    def __init__(self, given_token, lock_token):
 
980
        self.given_token = given_token
 
981
        self.lock_token = lock_token
 
982
 
 
983
 
747
984
class PointlessCommit(BzrError):
748
985
 
749
986
    _fmt = "No changes to commit"
750
987
 
751
988
 
 
989
class CannotCommitSelectedFileMerge(BzrError):
 
990
 
 
991
    _fmt = 'Selected-file commit of merges is not supported yet:'\
 
992
        ' files %(files_str)s'
 
993
 
 
994
    def __init__(self, files):
 
995
        files_str = ', '.join(files)
 
996
        BzrError.__init__(self, files=files, files_str=files_str)
 
997
 
 
998
 
 
999
class BadCommitMessageEncoding(BzrError):
 
1000
 
 
1001
    _fmt = 'The specified commit message contains characters unsupported by '\
 
1002
        'the current encoding.'
 
1003
 
 
1004
 
752
1005
class UpgradeReadonly(BzrError):
753
1006
 
754
1007
    _fmt = "Upgrade URL cannot work with readonly URLs."
768
1021
    _fmt = "Commit refused because there are unknowns in the tree."
769
1022
 
770
1023
 
771
 
class NoSuchRevision(BzrError):
772
 
 
773
 
    _fmt = "Branch %(branch)s has no revision %(revision)s"
774
 
 
775
 
    internal_error = True
 
1024
class NoSuchRevision(InternalBzrError):
 
1025
 
 
1026
    _fmt = "%(branch)s has no revision %(revision)s"
776
1027
 
777
1028
    def __init__(self, branch, revision):
 
1029
        # 'branch' may sometimes be an internal object like a KnitRevisionStore
778
1030
        BzrError.__init__(self, branch=branch, revision=revision)
779
1031
 
780
1032
 
781
 
class NotLeftParentDescendant(BzrError):
782
 
 
783
 
    _fmt = "Revision %(old_revision)s is not the left parent of"\
784
 
        " %(new_revision)s, but branch %(branch_location)s expects this"
785
 
 
786
 
    internal_error = True
 
1033
# zero_ninetyone: this exception is no longer raised and should be removed
 
1034
class NotLeftParentDescendant(InternalBzrError):
 
1035
 
 
1036
    _fmt = ("Revision %(old_revision)s is not the left parent of"
 
1037
            " %(new_revision)s, but branch %(branch_location)s expects this")
787
1038
 
788
1039
    def __init__(self, branch, old_revision, new_revision):
789
1040
        BzrError.__init__(self, branch_location=branch.base,
791
1042
                          new_revision=new_revision)
792
1043
 
793
1044
 
 
1045
class RangeInChangeOption(BzrError):
 
1046
 
 
1047
    _fmt = "Option --change does not accept revision ranges"
 
1048
 
 
1049
 
794
1050
class NoSuchRevisionSpec(BzrError):
795
1051
 
796
1052
    _fmt = "No namespace registered for string: %(spec)r"
802
1058
class NoSuchRevisionInTree(NoSuchRevision):
803
1059
    """When using Tree.revision_tree, and the revision is not accessible."""
804
1060
    
805
 
    _fmt = "The revision id %(revision_id)s is not present in the tree %(tree)s."
 
1061
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
806
1062
 
807
1063
    def __init__(self, tree, revision_id):
808
1064
        BzrError.__init__(self)
812
1068
 
813
1069
class InvalidRevisionSpec(BzrError):
814
1070
 
815
 
    _fmt = "Requested revision: %(spec)r does not exist in branch: %(branch)s%(extra)s"
 
1071
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
 
1072
            " %(branch)s%(extra)s")
816
1073
 
817
1074
    def __init__(self, spec, branch, extra=None):
818
1075
        BzrError.__init__(self, branch=branch, spec=spec)
829
1086
 
830
1087
class AppendRevisionsOnlyViolation(BzrError):
831
1088
 
832
 
    _fmt = 'Operation denied because it would change the main history, '\
833
 
           'which is not permitted by the append_revisions_only setting on'\
834
 
           ' branch "%(location)s".'
 
1089
    _fmt = ('Operation denied because it would change the main history,'
 
1090
           ' which is not permitted by the append_revisions_only setting on'
 
1091
           ' branch "%(location)s".')
835
1092
 
836
1093
    def __init__(self, location):
837
1094
       import bzrlib.urlutils as urlutils
840
1097
 
841
1098
 
842
1099
class DivergedBranches(BzrError):
843
 
    
844
 
    _fmt = "These branches have diverged.  Use the merge command to reconcile them."""
845
1100
 
846
 
    internal_error = False
 
1101
    _fmt = ("These branches have diverged."
 
1102
            " Use the merge command to reconcile them.")
847
1103
 
848
1104
    def __init__(self, branch1, branch2):
849
1105
        self.branch1 = branch1
850
1106
        self.branch2 = branch2
851
1107
 
852
1108
 
853
 
class NotLefthandHistory(BzrError):
 
1109
class NotLefthandHistory(InternalBzrError):
854
1110
 
855
1111
    _fmt = "Supplied history does not follow left-hand parents"
856
1112
 
857
 
    internal_error = True
858
 
 
859
1113
    def __init__(self, history):
860
1114
        BzrError.__init__(self, history=history)
861
1115
 
862
1116
 
863
1117
class UnrelatedBranches(BzrError):
864
1118
 
865
 
    _fmt = "Branches have no common ancestor, and no merge base revision was specified."
866
 
 
867
 
    internal_error = False
 
1119
    _fmt = ("Branches have no common ancestor, and"
 
1120
            " no merge base revision was specified.")
 
1121
 
 
1122
 
 
1123
class CannotReverseCherrypick(BzrError):
 
1124
 
 
1125
    _fmt = ('Selected merge cannot perform reverse cherrypicks.  Try merge3'
 
1126
            ' or diff3.')
868
1127
 
869
1128
 
870
1129
class NoCommonAncestor(BzrError):
878
1137
 
879
1138
class NoCommonRoot(BzrError):
880
1139
 
881
 
    _fmt = "Revisions are not derived from the same root: " \
882
 
           "%(revision_a)s %(revision_b)s."
 
1140
    _fmt = ("Revisions are not derived from the same root: "
 
1141
           "%(revision_a)s %(revision_b)s.")
883
1142
 
884
1143
    def __init__(self, revision_a, revision_b):
885
1144
        BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
908
1167
    def __init__(self, bases):
909
1168
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
910
1169
                DeprecationWarning)
911
 
        msg = "The correct base is unclear, because %s are all equally close" %\
912
 
            ", ".join(bases)
 
1170
        msg = ("The correct base is unclear, because %s are all equally close"
 
1171
                % ", ".join(bases))
913
1172
        BzrError.__init__(self, msg)
914
1173
        self.bases = bases
915
1174
 
937
1196
 
938
1197
class BoundBranchOutOfDate(BzrError):
939
1198
 
940
 
    _fmt = "Bound branch %(branch)s is out of date with master branch %(master)s."
 
1199
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
 
1200
            " %(master)s.")
941
1201
 
942
1202
    def __init__(self, branch, master):
943
1203
        BzrError.__init__(self)
947
1207
        
948
1208
class CommitToDoubleBoundBranch(BzrError):
949
1209
 
950
 
    _fmt = "Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."
 
1210
    _fmt = ("Cannot commit to branch %(branch)s."
 
1211
            " It is bound to %(master)s, which is bound to %(remote)s.")
951
1212
 
952
1213
    def __init__(self, branch, master, remote):
953
1214
        BzrError.__init__(self)
967
1228
 
968
1229
class BoundBranchConnectionFailure(BzrError):
969
1230
 
970
 
    _fmt = "Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"
 
1231
    _fmt = ("Unable to connect to target of bound branch %(branch)s"
 
1232
            " => %(target)s: %(error)s")
971
1233
 
972
1234
    def __init__(self, branch, target, error):
973
1235
        BzrError.__init__(self)
1017
1279
 
1018
1280
class WeaveParentMismatch(WeaveError):
1019
1281
 
1020
 
    _fmt = "Parents are mismatched between two revisions."
 
1282
    _fmt = "Parents are mismatched between two revisions. %(message)s"
1021
1283
    
1022
1284
 
1023
1285
class WeaveInvalidChecksum(WeaveError):
1027
1289
 
1028
1290
class WeaveTextDiffers(WeaveError):
1029
1291
 
1030
 
    _fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"
 
1292
    _fmt = ("Weaves differ on text content. Revision:"
 
1293
            " {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1031
1294
 
1032
1295
    def __init__(self, revision_id, weave_a, weave_b):
1033
1296
        WeaveError.__init__(self)
1038
1301
 
1039
1302
class WeaveTextDiffers(WeaveError):
1040
1303
 
1041
 
    _fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"
 
1304
    _fmt = ("Weaves differ on text content. Revision:"
 
1305
            " {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1042
1306
 
1043
1307
    def __init__(self, revision_id, weave_a, weave_b):
1044
1308
        WeaveError.__init__(self)
1054
1318
 
1055
1319
class RevisionNotPresent(VersionedFileError):
1056
1320
    
1057
 
    _fmt = "Revision {%(revision_id)s} not present in %(file_id)s."
 
1321
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1058
1322
 
1059
1323
    def __init__(self, revision_id, file_id):
1060
1324
        VersionedFileError.__init__(self)
1064
1328
 
1065
1329
class RevisionAlreadyPresent(VersionedFileError):
1066
1330
    
1067
 
    _fmt = "Revision {%(revision_id)s} already present in %(file_id)s."
 
1331
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1068
1332
 
1069
1333
    def __init__(self, revision_id, file_id):
1070
1334
        VersionedFileError.__init__(self)
1072
1336
        self.file_id = file_id
1073
1337
 
1074
1338
 
1075
 
class KnitError(BzrError):
 
1339
class VersionedFileInvalidChecksum(VersionedFileError):
 
1340
 
 
1341
    _fmt = "Text did not match its checksum: %(message)s"
 
1342
 
 
1343
 
 
1344
class KnitError(InternalBzrError):
1076
1345
    
1077
1346
    _fmt = "Knit error"
1078
1347
 
1079
 
    internal_error = True
1080
 
 
1081
 
 
1082
 
class KnitHeaderError(KnitError):
1083
 
 
1084
 
    _fmt = "Knit header error: %(badline)r unexpected for file %(filename)s"
1085
 
 
1086
 
    def __init__(self, badline, filename):
1087
 
        KnitError.__init__(self)
1088
 
        self.badline = badline
1089
 
        self.filename = filename
1090
 
 
1091
1348
 
1092
1349
class KnitCorrupt(KnitError):
1093
1350
 
1099
1356
        self.how = how
1100
1357
 
1101
1358
 
 
1359
class KnitDataStreamIncompatible(KnitError):
 
1360
    # Not raised anymore, as we can convert data streams.  In future we may
 
1361
    # need it again for more exotic cases, so we're keeping it around for now.
 
1362
 
 
1363
    _fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."
 
1364
 
 
1365
    def __init__(self, stream_format, target_format):
 
1366
        self.stream_format = stream_format
 
1367
        self.target_format = target_format
 
1368
        
 
1369
 
 
1370
class KnitDataStreamUnknown(KnitError):
 
1371
    # Indicates a data stream we don't know how to handle.
 
1372
 
 
1373
    _fmt = "Cannot parse knit data stream of format \"%(stream_format)s\"."
 
1374
 
 
1375
    def __init__(self, stream_format):
 
1376
        self.stream_format = stream_format
 
1377
        
 
1378
 
 
1379
class KnitHeaderError(KnitError):
 
1380
 
 
1381
    _fmt = 'Knit header error: %(badline)r unexpected for file "%(filename)s".'
 
1382
 
 
1383
    def __init__(self, badline, filename):
 
1384
        KnitError.__init__(self)
 
1385
        self.badline = badline
 
1386
        self.filename = filename
 
1387
 
1102
1388
class KnitIndexUnknownMethod(KnitError):
1103
1389
    """Raised when we don't understand the storage method.
1104
1390
 
1139
1425
        BzrError.__init__(self)
1140
1426
 
1141
1427
 
1142
 
class TooManyConcurrentRequests(BzrError):
1143
 
 
1144
 
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit. "
1145
 
            "Be sure to finish_writing and finish_reading on the "
1146
 
            "current request that is open.")
1147
 
 
1148
 
    internal_error = True
 
1428
class TooManyConcurrentRequests(InternalBzrError):
 
1429
 
 
1430
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
 
1431
            " Be sure to finish_writing and finish_reading on the"
 
1432
            " currently open request.")
1149
1433
 
1150
1434
    def __init__(self, medium):
1151
1435
        self.medium = medium
1196
1480
 
1197
1481
class InvalidRange(TransportError):
1198
1482
 
1199
 
    _fmt = "Invalid range access in %(path)s at %(offset)s."
1200
 
    
1201
 
    def __init__(self, path, offset):
1202
 
        TransportError.__init__(self, ("Invalid range access in %s at %d"
1203
 
                                       % (path, offset)))
 
1483
    _fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
 
1484
 
 
1485
    def __init__(self, path, offset, msg=None):
 
1486
        TransportError.__init__(self, msg)
1204
1487
        self.path = path
1205
1488
        self.offset = offset
1206
1489
 
1217
1500
class InvalidHttpRange(InvalidHttpResponse):
1218
1501
 
1219
1502
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1220
 
    
 
1503
 
1221
1504
    def __init__(self, path, range, msg):
1222
1505
        self.range = range
1223
1506
        InvalidHttpResponse.__init__(self, path, msg)
1226
1509
class InvalidHttpContentType(InvalidHttpResponse):
1227
1510
 
1228
1511
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1229
 
    
 
1512
 
1230
1513
    def __init__(self, path, ctype, msg):
1231
1514
        self.ctype = ctype
1232
1515
        InvalidHttpResponse.__init__(self, path, msg)
1233
1516
 
1234
1517
 
 
1518
class RedirectRequested(TransportError):
 
1519
 
 
1520
    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'
 
1521
 
 
1522
    def __init__(self, source, target, is_permanent=False, qual_proto=None):
 
1523
        self.source = source
 
1524
        self.target = target
 
1525
        if is_permanent:
 
1526
            self.permanently = ' permanently'
 
1527
        else:
 
1528
            self.permanently = ''
 
1529
        self._qualified_proto = qual_proto
 
1530
        TransportError.__init__(self)
 
1531
 
 
1532
    def _requalify_url(self, url):
 
1533
        """Restore the qualified proto in front of the url"""
 
1534
        # When this exception is raised, source and target are in
 
1535
        # user readable format. But some transports may use a
 
1536
        # different proto (http+urllib:// will present http:// to
 
1537
        # the user. If a qualified proto is specified, the code
 
1538
        # trapping the exception can get the qualified urls to
 
1539
        # properly handle the redirection themself (creating a
 
1540
        # new transport object from the target url for example).
 
1541
        # But checking that the scheme of the original and
 
1542
        # redirected urls are the same can be tricky. (see the
 
1543
        # FIXME in BzrDir.open_from_transport for the unique use
 
1544
        # case so far).
 
1545
        if self._qualified_proto is None:
 
1546
            return url
 
1547
 
 
1548
        # The TODO related to NotBranchError mention that doing
 
1549
        # that kind of manipulation on the urls may not be the
 
1550
        # exception object job. On the other hand, this object is
 
1551
        # the interface between the code and the user so
 
1552
        # presenting the urls in different ways is indeed its
 
1553
        # job...
 
1554
        import urlparse
 
1555
        proto, netloc, path, query, fragment = urlparse.urlsplit(url)
 
1556
        return urlparse.urlunsplit((self._qualified_proto, netloc, path,
 
1557
                                   query, fragment))
 
1558
 
 
1559
    def get_source_url(self):
 
1560
        return self._requalify_url(self.source)
 
1561
 
 
1562
    def get_target_url(self):
 
1563
        return self._requalify_url(self.target)
 
1564
 
 
1565
 
 
1566
class TooManyRedirections(TransportError):
 
1567
 
 
1568
    _fmt = "Too many redirections"
 
1569
 
 
1570
 
1235
1571
class ConflictsInTree(BzrError):
1236
1572
 
1237
1573
    _fmt = "Working tree has conflicts."
1258
1594
 
1259
1595
class SigningFailed(BzrError):
1260
1596
 
1261
 
    _fmt = "Failed to gpg sign data with command %(command_line)r"
 
1597
    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'
1262
1598
 
1263
1599
    def __init__(self, command_line):
1264
1600
        BzrError.__init__(self, command_line=command_line)
1276
1612
 
1277
1613
class CantReprocessAndShowBase(BzrError):
1278
1614
 
1279
 
    _fmt = "Can't reprocess and show base, because reprocessing obscures " \
1280
 
           "the relationship of conflicting lines to the base"
 
1615
    _fmt = ("Can't reprocess and show base, because reprocessing obscures "
 
1616
           "the relationship of conflicting lines to the base")
1281
1617
 
1282
1618
 
1283
1619
class GraphCycleError(BzrError):
1289
1625
        self.graph = graph
1290
1626
 
1291
1627
 
1292
 
class WritingCompleted(BzrError):
 
1628
class WritingCompleted(InternalBzrError):
1293
1629
 
1294
1630
    _fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1295
1631
            "called upon it - accept bytes may not be called anymore.")
1296
1632
 
1297
 
    internal_error = True
1298
 
 
1299
1633
    def __init__(self, request):
1300
1634
        self.request = request
1301
1635
 
1302
1636
 
1303
 
class WritingNotComplete(BzrError):
 
1637
class WritingNotComplete(InternalBzrError):
1304
1638
 
1305
1639
    _fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1306
1640
            "called upon it - until the write phase is complete no "
1307
1641
            "data may be read.")
1308
1642
 
1309
 
    internal_error = True
1310
 
 
1311
1643
    def __init__(self, request):
1312
1644
        self.request = request
1313
1645
 
1321
1653
        self.filename = filename
1322
1654
 
1323
1655
 
1324
 
class MediumNotConnected(BzrError):
 
1656
class MediumNotConnected(InternalBzrError):
1325
1657
 
1326
1658
    _fmt = """The medium '%(medium)s' is not connected."""
1327
1659
 
1328
 
    internal_error = True
1329
 
 
1330
1660
    def __init__(self, medium):
1331
1661
        self.medium = medium
1332
1662
 
1333
1663
 
1334
1664
class MustUseDecorated(Exception):
1335
 
    
1336
 
    _fmt = """A decorating function has requested its original command be used."""
1337
 
    
 
1665
 
 
1666
    _fmt = "A decorating function has requested its original command be used."
 
1667
 
1338
1668
 
1339
1669
class NoBundleFound(BzrError):
1340
1670
 
1341
 
    _fmt = "No bundle was found in %(filename)s"
 
1671
    _fmt = 'No bundle was found in "%(filename)s".'
1342
1672
 
1343
1673
    def __init__(self, filename):
1344
1674
        BzrError.__init__(self)
1357
1687
 
1358
1688
class MissingText(BzrError):
1359
1689
 
1360
 
    _fmt = "Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"
 
1690
    _fmt = ("Branch %(base)s is missing revision"
 
1691
            " %(text_revision)s of %(file_id)s")
1361
1692
 
1362
1693
    def __init__(self, branch, text_revision, file_id):
1363
1694
        BzrError.__init__(self)
1367
1698
        self.file_id = file_id
1368
1699
 
1369
1700
 
 
1701
class DuplicateFileId(BzrError):
 
1702
 
 
1703
    _fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"
 
1704
 
 
1705
    def __init__(self, file_id, entry):
 
1706
        BzrError.__init__(self)
 
1707
        self.file_id = file_id
 
1708
        self.entry = entry
 
1709
 
 
1710
 
1370
1711
class DuplicateKey(BzrError):
1371
1712
 
1372
1713
    _fmt = "Key %(key)s is already present in map"
1373
1714
 
1374
1715
 
 
1716
class DuplicateHelpPrefix(BzrError):
 
1717
 
 
1718
    _fmt = "The prefix %(prefix)s is in the help search path twice."
 
1719
 
 
1720
    def __init__(self, prefix):
 
1721
        self.prefix = prefix
 
1722
 
 
1723
 
1375
1724
class MalformedTransform(BzrError):
1376
1725
 
1377
1726
    _fmt = "Tree transform is malformed %(conflicts)r"
1389
1738
        self.root_trans_id = transform.root
1390
1739
 
1391
1740
 
1392
 
class BzrBadParameter(BzrError):
 
1741
class BzrBadParameter(InternalBzrError):
1393
1742
 
1394
1743
    _fmt = "Bad parameter: %(param)r"
1395
1744
 
1457
1806
    def __init__(self, from_path, to_path, extra=None):
1458
1807
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1459
1808
 
 
1809
class BzrRemoveChangedFilesError(BzrError):
 
1810
    """Used when user is trying to remove changed files."""
 
1811
 
 
1812
    _fmt = ("Can't safely remove modified or unknown files:\n"
 
1813
        "%(changes_as_text)s"
 
1814
        "Use --keep to not delete them, or --force to delete them regardless.")
 
1815
 
 
1816
    def __init__(self, tree_delta):
 
1817
        BzrError.__init__(self)
 
1818
        self.changes_as_text = tree_delta.get_changes_as_text()
 
1819
        #self.paths_as_string = '\n'.join(changed_files)
 
1820
        #self.paths_as_string = '\n'.join([quotefn(p) for p in changed_files])
 
1821
 
1460
1822
 
1461
1823
class BzrBadParameterNotString(BzrBadParameter):
1462
1824
 
1470
1832
 
1471
1833
class BzrBadParameterUnicode(BzrBadParameter):
1472
1834
 
1473
 
    _fmt = "Parameter %(param)s is unicode but only byte-strings are permitted."
 
1835
    _fmt = ("Parameter %(param)s is unicode but"
 
1836
            " only byte-strings are permitted.")
1474
1837
 
1475
1838
 
1476
1839
class BzrBadParameterContainsNewline(BzrBadParameter):
1518
1881
        self.format = format
1519
1882
 
1520
1883
 
 
1884
class NoDiffFound(BzrError):
 
1885
 
 
1886
    _fmt = 'Could not find an appropriate Differ for file "%(path)s"'
 
1887
 
 
1888
    def __init__(self, path):
 
1889
        BzrError.__init__(self, path)
 
1890
 
 
1891
 
 
1892
class ExecutableMissing(BzrError):
 
1893
 
 
1894
    _fmt = "%(exe_name)s could not be found on this machine"
 
1895
 
 
1896
    def __init__(self, exe_name):
 
1897
        BzrError.__init__(self, exe_name=exe_name)
 
1898
 
 
1899
 
1521
1900
class NoDiff(BzrError):
1522
1901
 
1523
1902
    _fmt = "Diff is not installed on this machine: %(msg)s"
1531
1910
    _fmt = "Diff3 is not installed on this machine."
1532
1911
 
1533
1912
 
 
1913
class ExistingContent(BzrError):
 
1914
    # Added in bzrlib 0.92, used by VersionedFile.add_lines.
 
1915
 
 
1916
    _fmt = "The content being inserted is already present."
 
1917
 
 
1918
 
1534
1919
class ExistingLimbo(BzrError):
1535
1920
 
1536
1921
    _fmt = """This tree contains left-over files from a failed operation.
1542
1927
       self.limbo_dir = limbo_dir
1543
1928
 
1544
1929
 
 
1930
class ExistingPendingDeletion(BzrError):
 
1931
 
 
1932
    _fmt = """This tree contains left-over files from a failed operation.
 
1933
    Please examine %(pending_deletion)s to see if it contains any files you
 
1934
    wish to keep, and delete it when you are done."""
 
1935
 
 
1936
    def __init__(self, pending_deletion):
 
1937
       BzrError.__init__(self, pending_deletion=pending_deletion)
 
1938
 
 
1939
 
1545
1940
class ImmortalLimbo(BzrError):
1546
1941
 
1547
 
    _fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
 
1942
    _fmt = """Unable to delete transform temporary directory %(limbo_dir)s.
1548
1943
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1549
1944
    keep, and delete it when you are done."""
1550
1945
 
1553
1948
       self.limbo_dir = limbo_dir
1554
1949
 
1555
1950
 
 
1951
class ImmortalPendingDeletion(BzrError):
 
1952
 
 
1953
    _fmt = ("Unable to delete transform temporary directory "
 
1954
    "%(pending_deletion)s.  Please examine %(pending_deletion)s to see if it "
 
1955
    "contains any files you wish to keep, and delete it when you are done.")
 
1956
 
 
1957
    def __init__(self, pending_deletion):
 
1958
       BzrError.__init__(self, pending_deletion=pending_deletion)
 
1959
 
 
1960
 
1556
1961
class OutOfDateTree(BzrError):
1557
1962
 
1558
1963
    _fmt = "Working tree is out of date, please run 'bzr update'."
1562
1967
        self.tree = tree
1563
1968
 
1564
1969
 
 
1970
class PublicBranchOutOfDate(BzrError):
 
1971
 
 
1972
    _fmt = 'Public branch "%(public_location)s" lacks revision '\
 
1973
        '"%(revstring)s".'
 
1974
 
 
1975
    def __init__(self, public_location, revstring):
 
1976
        import bzrlib.urlutils as urlutils
 
1977
        public_location = urlutils.unescape_for_display(public_location,
 
1978
                                                        'ascii')
 
1979
        BzrError.__init__(self, public_location=public_location,
 
1980
                          revstring=revstring)
 
1981
 
 
1982
 
1565
1983
class MergeModifiedFormatError(BzrError):
1566
1984
 
1567
1985
    _fmt = "Error in merge modified format"
1572
1990
    _fmt = "Format error in conflict listings"
1573
1991
 
1574
1992
 
 
1993
class CorruptDirstate(BzrError):
 
1994
 
 
1995
    _fmt = ("Inconsistency in dirstate file %(dirstate_path)s.\n"
 
1996
            "Error: %(description)s")
 
1997
 
 
1998
    def __init__(self, dirstate_path, description):
 
1999
        BzrError.__init__(self)
 
2000
        self.dirstate_path = dirstate_path
 
2001
        self.description = description
 
2002
 
 
2003
 
1575
2004
class CorruptRepository(BzrError):
1576
2005
 
1577
 
    _fmt = """An error has been detected in the repository %(repo_path)s.
1578
 
Please run bzr reconcile on this repository."""
 
2006
    _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
 
2007
            "Please run bzr reconcile on this repository.")
1579
2008
 
1580
2009
    def __init__(self, repo):
1581
2010
        BzrError.__init__(self)
1582
2011
        self.repo_path = repo.bzrdir.root_transport.base
1583
2012
 
1584
2013
 
 
2014
class InconsistentDelta(BzrError):
 
2015
    """Used when we get a delta that is not valid."""
 
2016
 
 
2017
    _fmt = ("An inconsistent delta was supplied involving %(path)r,"
 
2018
            " %(file_id)r\nreason: %(reason)s")
 
2019
 
 
2020
    def __init__(self, path, file_id, reason):
 
2021
        BzrError.__init__(self)
 
2022
        self.path = path
 
2023
        self.file_id = file_id
 
2024
        self.reason = reason
 
2025
 
 
2026
 
1585
2027
class UpgradeRequired(BzrError):
1586
2028
 
1587
2029
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
1603
2045
 
1604
2046
class InvalidProgressBarType(BzrError):
1605
2047
 
1606
 
    _fmt = """Environment variable BZR_PROGRESS_BAR='%(bar_type)s is not a supported type
1607
 
Select one of: %(valid_types)s"""
 
2048
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
 
2049
            " is not a supported type Select one of: %(valid_types)s")
1608
2050
 
1609
2051
    def __init__(self, bar_type, valid_types):
1610
2052
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1612
2054
 
1613
2055
class UnsupportedOperation(BzrError):
1614
2056
 
1615
 
    _fmt = "The method %(mname)s is not supported on objects of type %(tname)s."
 
2057
    _fmt = ("The method %(mname)s is not supported on"
 
2058
            " objects of type %(tname)s.")
1616
2059
 
1617
2060
    def __init__(self, method, method_self):
1618
2061
        self.method = method
1625
2068
 
1626
2069
 
1627
2070
class NonAsciiRevisionId(UnsupportedOperation):
1628
 
    """Raised when a commit is attempting to set a non-ascii revision id but cant."""
 
2071
    """Raised when a commit is attempting to set a non-ascii revision id
 
2072
       but cant.
 
2073
    """
1629
2074
 
1630
2075
 
1631
2076
class BinaryFile(BzrError):
1644
2089
 
1645
2090
class TestamentMismatch(BzrError):
1646
2091
 
1647
 
    _fmt = """Testament did not match expected value.  
1648
 
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured 
 
2092
    _fmt = """Testament did not match expected value.
 
2093
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
1649
2094
       {%(measured)s}"""
1650
2095
 
1651
2096
    def __init__(self, revision_id, expected, measured):
1720
2165
        BadInventoryFormat.__init__(self, msg=msg)
1721
2166
 
1722
2167
 
1723
 
class NoSmartMedium(BzrError):
 
2168
class RootNotRich(BzrError):
 
2169
 
 
2170
    _fmt = """This operation requires rich root data storage"""
 
2171
 
 
2172
 
 
2173
class NoSmartMedium(InternalBzrError):
1724
2174
 
1725
2175
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
1726
 
    internal_error = True
1727
2176
 
1728
2177
    def __init__(self, transport):
1729
2178
        self.transport = transport
1746
2195
        self.vendor = vendor
1747
2196
 
1748
2197
 
 
2198
class SSHVendorNotFound(BzrError):
 
2199
 
 
2200
    _fmt = ("Don't know how to handle SSH connections."
 
2201
            " Please set BZR_SSH environment variable.")
 
2202
 
 
2203
 
1749
2204
class GhostRevisionUnusableHere(BzrError):
1750
2205
 
1751
2206
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
1755
2210
        self.revision_id = revision_id
1756
2211
 
1757
2212
 
1758
 
class IllegalUseOfScopeReplacer(BzrError):
1759
 
 
1760
 
    _fmt = "ScopeReplacer object %(name)r was used incorrectly: %(msg)s%(extra)s"
1761
 
 
1762
 
    internal_error = True
 
2213
class IllegalUseOfScopeReplacer(InternalBzrError):
 
2214
 
 
2215
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
 
2216
            " %(msg)s%(extra)s")
1763
2217
 
1764
2218
    def __init__(self, name, msg, extra=None):
1765
2219
        BzrError.__init__(self)
1771
2225
            self.extra = ''
1772
2226
 
1773
2227
 
1774
 
class InvalidImportLine(BzrError):
 
2228
class InvalidImportLine(InternalBzrError):
1775
2229
 
1776
2230
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
1777
2231
 
1778
 
    internal_error = True
1779
 
 
1780
2232
    def __init__(self, text, msg):
1781
2233
        BzrError.__init__(self)
1782
2234
        self.text = text
1783
2235
        self.msg = msg
1784
2236
 
1785
2237
 
1786
 
class ImportNameCollision(BzrError):
1787
 
 
1788
 
    _fmt = "Tried to import an object to the same name as an existing object. %(name)s"
1789
 
 
1790
 
    internal_error = True
1791
 
 
1792
 
    def __init__(self, name):
1793
 
        BzrError.__init__(self)
1794
 
        self.name = name
 
2238
class ImportNameCollision(InternalBzrError):
 
2239
 
 
2240
    _fmt = ("Tried to import an object to the same name as"
 
2241
            " an existing object. %(name)s")
 
2242
 
 
2243
    def __init__(self, name):
 
2244
        BzrError.__init__(self)
 
2245
        self.name = name
 
2246
 
 
2247
 
 
2248
class NotAMergeDirective(BzrError):
 
2249
    """File starting with %(firstline)r is not a merge directive"""
 
2250
    def __init__(self, firstline):
 
2251
        BzrError.__init__(self, firstline=firstline)
 
2252
 
 
2253
 
 
2254
class NoMergeSource(BzrError):
 
2255
    """Raise if no merge source was specified for a merge directive"""
 
2256
 
 
2257
    _fmt = "A merge directive must provide either a bundle or a public"\
 
2258
        " branch location."
 
2259
 
 
2260
 
 
2261
class IllegalMergeDirectivePayload(BzrError):
 
2262
    """A merge directive contained something other than a patch or bundle"""
 
2263
 
 
2264
    _fmt = "Bad merge directive payload %(start)r"
 
2265
 
 
2266
    def __init__(self, start):
 
2267
        BzrError(self)
 
2268
        self.start = start
 
2269
 
 
2270
 
 
2271
class PatchVerificationFailed(BzrError):
 
2272
    """A patch from a merge directive could not be verified"""
 
2273
 
 
2274
    _fmt = "Preview patch does not match requested changes."
 
2275
 
 
2276
 
 
2277
class PatchMissing(BzrError):
 
2278
    """Raise a patch type was specified but no patch supplied"""
 
2279
 
 
2280
    _fmt = "Patch_type was %(patch_type)s, but no patch was supplied."
 
2281
 
 
2282
    def __init__(self, patch_type):
 
2283
        BzrError.__init__(self)
 
2284
        self.patch_type = patch_type
 
2285
 
 
2286
 
 
2287
class UnsupportedInventoryKind(BzrError):
 
2288
    
 
2289
    _fmt = """Unsupported entry kind %(kind)s"""
 
2290
 
 
2291
    def __init__(self, kind):
 
2292
        self.kind = kind
 
2293
 
 
2294
 
 
2295
class BadSubsumeSource(BzrError):
 
2296
 
 
2297
    _fmt = "Can't subsume %(other_tree)s into %(tree)s. %(reason)s"
 
2298
 
 
2299
    def __init__(self, tree, other_tree, reason):
 
2300
        self.tree = tree
 
2301
        self.other_tree = other_tree
 
2302
        self.reason = reason
 
2303
 
 
2304
 
 
2305
class SubsumeTargetNeedsUpgrade(BzrError):
 
2306
    
 
2307
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
 
2308
 
 
2309
    def __init__(self, other_tree):
 
2310
        self.other_tree = other_tree
 
2311
 
 
2312
 
 
2313
class BadReferenceTarget(InternalBzrError):
 
2314
 
 
2315
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
 
2316
           "%(reason)s"
 
2317
 
 
2318
    def __init__(self, tree, other_tree, reason):
 
2319
        self.tree = tree
 
2320
        self.other_tree = other_tree
 
2321
        self.reason = reason
 
2322
 
 
2323
 
 
2324
class NoSuchTag(BzrError):
 
2325
 
 
2326
    _fmt = "No such tag: %(tag_name)s"
 
2327
 
 
2328
    def __init__(self, tag_name):
 
2329
        self.tag_name = tag_name
 
2330
 
 
2331
 
 
2332
class TagsNotSupported(BzrError):
 
2333
 
 
2334
    _fmt = ("Tags not supported by %(branch)s;"
 
2335
            " you may be able to use bzr upgrade --dirstate-tags.")
 
2336
 
 
2337
    def __init__(self, branch):
 
2338
        self.branch = branch
 
2339
 
 
2340
        
 
2341
class TagAlreadyExists(BzrError):
 
2342
 
 
2343
    _fmt = "Tag %(tag_name)s already exists."
 
2344
 
 
2345
    def __init__(self, tag_name):
 
2346
        self.tag_name = tag_name
 
2347
 
 
2348
 
 
2349
class MalformedBugIdentifier(BzrError):
 
2350
 
 
2351
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
 
2352
 
 
2353
    def __init__(self, bug_id, reason):
 
2354
        self.bug_id = bug_id
 
2355
        self.reason = reason
 
2356
 
 
2357
 
 
2358
class InvalidBugTrackerURL(BzrError):
 
2359
 
 
2360
    _fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
 
2361
            "contain {id}: %(url)s")
 
2362
 
 
2363
    def __init__(self, abbreviation, url):
 
2364
        self.abbreviation = abbreviation
 
2365
        self.url = url
 
2366
 
 
2367
 
 
2368
class UnknownBugTrackerAbbreviation(BzrError):
 
2369
 
 
2370
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
 
2371
            "on %(branch)s")
 
2372
 
 
2373
    def __init__(self, abbreviation, branch):
 
2374
        self.abbreviation = abbreviation
 
2375
        self.branch = branch
 
2376
 
 
2377
 
 
2378
class UnexpectedSmartServerResponse(BzrError):
 
2379
 
 
2380
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
 
2381
 
 
2382
    def __init__(self, response_tuple):
 
2383
        self.response_tuple = response_tuple
 
2384
 
 
2385
 
 
2386
class ContainerError(BzrError):
 
2387
    """Base class of container errors."""
 
2388
 
 
2389
 
 
2390
class UnknownContainerFormatError(ContainerError):
 
2391
 
 
2392
    _fmt = "Unrecognised container format: %(container_format)r"
 
2393
    
 
2394
    def __init__(self, container_format):
 
2395
        self.container_format = container_format
 
2396
 
 
2397
 
 
2398
class UnexpectedEndOfContainerError(ContainerError):
 
2399
 
 
2400
    _fmt = "Unexpected end of container stream"
 
2401
 
 
2402
 
 
2403
class UnknownRecordTypeError(ContainerError):
 
2404
 
 
2405
    _fmt = "Unknown record type: %(record_type)r"
 
2406
 
 
2407
    def __init__(self, record_type):
 
2408
        self.record_type = record_type
 
2409
 
 
2410
 
 
2411
class InvalidRecordError(ContainerError):
 
2412
 
 
2413
    _fmt = "Invalid record: %(reason)s"
 
2414
 
 
2415
    def __init__(self, reason):
 
2416
        self.reason = reason
 
2417
 
 
2418
 
 
2419
class ContainerHasExcessDataError(ContainerError):
 
2420
 
 
2421
    _fmt = "Container has data after end marker: %(excess)r"
 
2422
 
 
2423
    def __init__(self, excess):
 
2424
        self.excess = excess
 
2425
 
 
2426
 
 
2427
class DuplicateRecordNameError(ContainerError):
 
2428
 
 
2429
    _fmt = "Container has multiple records with the same name: %(name)s"
 
2430
 
 
2431
    def __init__(self, name):
 
2432
        self.name = name
 
2433
 
 
2434
 
 
2435
class NoDestinationAddress(InternalBzrError):
 
2436
 
 
2437
    _fmt = "Message does not have a destination address."
 
2438
 
 
2439
 
 
2440
class RepositoryDataStreamError(BzrError):
 
2441
 
 
2442
    _fmt = "Corrupt or incompatible data stream: %(reason)s"
 
2443
 
 
2444
    def __init__(self, reason):
 
2445
        self.reason = reason
 
2446
 
 
2447
 
 
2448
class SMTPError(BzrError):
 
2449
 
 
2450
    _fmt = "SMTP error: %(error)s"
 
2451
 
 
2452
    def __init__(self, error):
 
2453
        self.error = error
 
2454
 
 
2455
 
 
2456
class NoMessageSupplied(BzrError):
 
2457
 
 
2458
    _fmt = "No message supplied."
 
2459
 
 
2460
 
 
2461
class NoMailAddressSpecified(BzrError):
 
2462
 
 
2463
    _fmt = "No mail-to address specified."
 
2464
 
 
2465
 
 
2466
class UnknownMailClient(BzrError):
 
2467
 
 
2468
    _fmt = "Unknown mail client: %(mail_client)s"
 
2469
 
 
2470
    def __init__(self, mail_client):
 
2471
        BzrError.__init__(self, mail_client=mail_client)
 
2472
 
 
2473
 
 
2474
class MailClientNotFound(BzrError):
 
2475
 
 
2476
    _fmt = "Unable to find mail client with the following names:"\
 
2477
        " %(mail_command_list_string)s"
 
2478
 
 
2479
    def __init__(self, mail_command_list):
 
2480
        mail_command_list_string = ', '.join(mail_command_list)
 
2481
        BzrError.__init__(self, mail_command_list=mail_command_list,
 
2482
                          mail_command_list_string=mail_command_list_string)
 
2483
 
 
2484
class SMTPConnectionRefused(SMTPError):
 
2485
 
 
2486
    _fmt = "SMTP connection to %(host)s refused"
 
2487
 
 
2488
    def __init__(self, error, host):
 
2489
        self.error = error
 
2490
        self.host = host
 
2491
 
 
2492
 
 
2493
class DefaultSMTPConnectionRefused(SMTPConnectionRefused):
 
2494
 
 
2495
    _fmt = "Please specify smtp_server.  No server at default %(host)s."
 
2496
 
 
2497
 
 
2498
class BzrDirError(BzrError):
 
2499
 
 
2500
    def __init__(self, bzrdir):
 
2501
        import bzrlib.urlutils as urlutils
 
2502
        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,
 
2503
                                                    'ascii')
 
2504
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
 
2505
 
 
2506
 
 
2507
class AlreadyBranch(BzrDirError):
 
2508
 
 
2509
    _fmt = "'%(display_url)s' is already a branch."
 
2510
 
 
2511
 
 
2512
class AlreadyTree(BzrDirError):
 
2513
 
 
2514
    _fmt = "'%(display_url)s' is already a tree."
 
2515
 
 
2516
 
 
2517
class AlreadyCheckout(BzrDirError):
 
2518
 
 
2519
    _fmt = "'%(display_url)s' is already a checkout."
 
2520
 
 
2521
 
 
2522
class AlreadyLightweightCheckout(BzrDirError):
 
2523
 
 
2524
    _fmt = "'%(display_url)s' is already a lightweight checkout."
 
2525
 
 
2526
 
 
2527
class ReconfigurationNotSupported(BzrDirError):
 
2528
 
 
2529
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
 
2530
 
 
2531
 
 
2532
class NoBindLocation(BzrDirError):
 
2533
 
 
2534
    _fmt = "No location could be found to bind to at %(display_url)s."
 
2535
 
 
2536
 
 
2537
class UncommittedChanges(BzrError):
 
2538
 
 
2539
    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'
 
2540
 
 
2541
    def __init__(self, tree):
 
2542
        import bzrlib.urlutils as urlutils
 
2543
        display_url = urlutils.unescape_for_display(
 
2544
            tree.bzrdir.root_transport.base, 'ascii')
 
2545
        BzrError.__init__(self, tree=tree, display_url=display_url)
 
2546
 
 
2547
 
 
2548
class MissingTemplateVariable(BzrError):
 
2549
 
 
2550
    _fmt = 'Variable {%(name)s} is not available.'
 
2551
 
 
2552
    def __init__(self, name):
 
2553
        self.name = name
 
2554
 
 
2555
 
 
2556
class NoTemplate(BzrError):
 
2557
 
 
2558
    _fmt = 'No template specified.'
 
2559
 
 
2560
 
 
2561
class UnableCreateSymlink(BzrError):
 
2562
 
 
2563
    _fmt = 'Unable to create symlink %(path_str)son this platform'
 
2564
 
 
2565
    def __init__(self, path=None):
 
2566
        path_str = ''
 
2567
        if path:
 
2568
            try:
 
2569
                path_str = repr(str(path))
 
2570
            except UnicodeEncodeError:
 
2571
                path_str = repr(path)
 
2572
            path_str += ' '
 
2573
        self.path_str = path_str
 
2574
 
 
2575
 
 
2576
class UnsupportedTimezoneFormat(BzrError):
 
2577
 
 
2578
    _fmt = ('Unsupported timezone format "%(timezone)s", '
 
2579
            'options are "utc", "original", "local".')
 
2580
 
 
2581
    def __init__(self, timezone):
 
2582
        self.timezone = timezone
 
2583
 
 
2584
 
 
2585
class UnableEncodePath(BzrError):
 
2586
 
 
2587
    _fmt = ('Unable to encode %(kind)s path %(path)r in '
 
2588
            'user encoding %(user_encoding)s')
 
2589
 
 
2590
    def __init__(self, path, kind):
 
2591
        self.path = path
 
2592
        self.kind = kind
 
2593
        self.user_encoding = osutils.get_user_encoding()