« back to all changes in this revision
Viewing changes to bzrlib/inventory.py
- browse files at revision 804
- compare with another revision
- download diff
- download tarball
- view history from revision 804
- Committer: Martin Pool
- Date: 2005-06-29 02:55:33 UTC
- Revision ID: mbp@sourcefrog.net-20050629025533-c8fb62423361c8a2
Patch from John:
- StringIO mixes poorly with difflib
- StringIO mixes poorly with difflib
- files added:
- .rsyncexclude
- bzrlib/selftest
- contrib
- contrib/bash
- contrib/zsh
- effbot
- effbot/org
- patches
- plugins
- plugins/changeset
- plugins/rsync
- urlgrabber
- files removed:
- bzrlib/tests.py
- files modified:
- .bzrignore
added
removed
bzrlib/inventory.py
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
1
# (C) 2005 Canonical Ltd
3
2
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
15
14
# along with this program; if not, write to the Free Software
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
16
18
"""Inventories map files to their name in a revision."""
19
20
21
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
22
__author__ = "Martin Pool <mbp@canonical.com>"
23
24
import sys, os.path, types
25
from sets import Set
26
27
try:
28
from cElementTree import Element, ElementTree, SubElement
29
except ImportError:
30
from elementtree.ElementTree import Element, ElementTree, SubElement
31
32
from xml import XMLMixin
33
from errors import bailout
17
18
# This should really be an id randomly assigned when the tree is
19
# created, but it's not for now.
20
ROOT_ID = "TREE_ROOT"
21
22
23
import sys, os.path, types, re
34
24
35
25
import bzrlib
26
from bzrlib.errors import BzrError, BzrCheckError
27
36
28
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
37
29
from bzrlib.trace import mutter
38
30
39
class InventoryEntry(XMLMixin):
31
class InventoryEntry(object):
40
32
"""Description of a versioned file.
41
33
42
34
An InventoryEntry has the following fields, which are also
59
51
60
52
>>> i = Inventory()
61
53
>>> i.path2id('')
62
>>> i.add(InventoryEntry('123', 'src', kind='directory'))
63
>>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
54
'TREE_ROOT'
55
>>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
56
>>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
64
57
>>> for j in i.iter_entries():
65
58
... print j
66
59
...
67
('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
60
('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
68
61
('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
69
>>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
62
>>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
70
63
Traceback (most recent call last):
71
64
...
72
BzrError: ('inventory already contains entry with id {2323}', [])
73
>>> i.add(InventoryEntry('2324', 'bye.c', parent_id='123'))
74
>>> i.add(InventoryEntry('2325', 'wibble', parent_id='123', kind='directory'))
65
BzrError: inventory already contains entry with id {2323}
66
>>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
67
>>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
75
68
>>> i.path2id('src/wibble')
76
69
'2325'
77
70
>>> '2325' in i
78
71
True
79
>>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
72
>>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
80
73
>>> i['2326']
81
74
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
82
75
>>> for j in i.iter_entries():
91
84
>>> i.id2path('2326')
92
85
'src/wibble/wibble.c'
93
86
94
:todo: Maybe also keep the full path of the entry, and the children?
87
TODO: Maybe also keep the full path of the entry, and the children?
95
88
But those depend on its position within a particular inventory, and
96
89
it would be nice not to need to hold the backpointer here.
97
90
"""
98
def __init__(self, file_id, name, kind='file', text_id=None,
99
parent_id=None):
91
92
# TODO: split InventoryEntry into subclasses for files,
93
# directories, etc etc.
94
95
text_sha1 = None
96
text_size = None
97
98
def __init__(self, file_id, name, kind, parent_id, text_id=None):
100
99
"""Create an InventoryEntry
101
100
102
101
The filename must be a single component, relative to the
103
102
parent directory; it cannot be a whole path or relative name.
104
103
105
>>> e = InventoryEntry('123', 'hello.c')
104
>>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
106
105
>>> e.name
107
106
'hello.c'
108
107
>>> e.file_id
109
108
'123'
110
>>> e = InventoryEntry('123', 'src/hello.c')
109
>>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
111
110
Traceback (most recent call last):
112
BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
111
BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
113
112
"""
114
115
if len(splitpath(name)) != 1:
116
bailout('InventoryEntry name is not a simple filename: %r'
117
% name)
113
if '/' in name or '\\' in name:
114
raise BzrCheckError('InventoryEntry name %r is invalid' % name)
118
115
119
116
self.file_id = file_id
120
117
self.name = name
121
assert kind in ['file', 'directory']
122
118
self.kind = kind
123
119
self.text_id = text_id
124
120
self.parent_id = parent_id
125
self.text_sha1 = None
126
self.text_size = None
121
if kind == 'directory':
122
self.children = {}
123
elif kind == 'file':
124
pass
125
else:
126
raise BzrError("unhandled entry kind %r" % kind)
127
128
129
130
def sorted_children(self):
131
l = self.children.items()
132
l.sort()
133
return l
127
134
128
135
129
136
def copy(self):
130
137
other = InventoryEntry(self.file_id, self.name, self.kind,
131
self.text_id, self.parent_id)
138
self.parent_id, text_id=self.text_id)
132
139
other.text_sha1 = self.text_sha1
133
140
other.text_size = self.text_size
141
# note that children are *not* copied; they're pulled across when
142
# others are added
134
143
return other
135
144
136
145
145
154
146
155
def to_element(self):
147
156
"""Convert to XML element"""
157
from bzrlib.xml import Element
158
148
159
e = Element('entry')
149
160
150
161
e.set('name', self.name)
151
162
e.set('file_id', self.file_id)
152
163
e.set('kind', self.kind)
153
164
154
if self.text_size is not None:
165
if self.text_size != None:
155
166
e.set('text_size', '%d' % self.text_size)
156
167
157
for f in ['text_id', 'text_sha1', 'parent_id']:
168
for f in ['text_id', 'text_sha1']:
158
169
v = getattr(self, f)
159
if v is not None:
170
if v != None:
160
171
e.set(f, v)
161
172
173
# to be conservative, we don't externalize the root pointers
174
# for now, leaving them as null in the xml form. in a future
175
# version it will be implied by nested elements.
176
if self.parent_id != ROOT_ID:
177
assert isinstance(self.parent_id, basestring)
178
e.set('parent_id', self.parent_id)
179
162
180
e.tail = '\n'
163
181
164
182
return e
166
184
167
185
def from_element(cls, elt):
168
186
assert elt.tag == 'entry'
169
self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'))
187
188
## original format inventories don't have a parent_id for
189
## nodes in the root directory, but it's cleaner to use one
190
## internally.
191
parent_id = elt.get('parent_id')
192
if parent_id == None:
193
parent_id = ROOT_ID
194
195
self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'), parent_id)
170
196
self.text_id = elt.get('text_id')
171
197
self.text_sha1 = elt.get('text_sha1')
172
self.parent_id = elt.get('parent_id')
173
198
174
199
## mutter("read inventoryentry: %r" % (elt.attrib))
175
200
181
206
182
207
from_element = classmethod(from_element)
183
208
184
def __cmp__(self, other):
185
if self is other:
186
return 0
209
def __eq__(self, other):
187
210
if not isinstance(other, InventoryEntry):
188
211
return NotImplemented
189
212
190
return cmp(self.file_id, other.file_id) \
191
or cmp(self.name, other.name) \
192
or cmp(self.text_sha1, other.text_sha1) \
193
or cmp(self.text_size, other.text_size) \
194
or cmp(self.text_id, other.text_id) \
195
or cmp(self.parent_id, other.parent_id) \
196
or cmp(self.kind, other.kind)
197
198
199
200
class Inventory(XMLMixin):
213
return (self.file_id == other.file_id) \
214
and (self.name == other.name) \
215
and (self.text_sha1 == other.text_sha1) \
216
and (self.text_size == other.text_size) \
217
and (self.text_id == other.text_id) \
218
and (self.parent_id == other.parent_id) \
219
and (self.kind == other.kind)
220
221
222
def __ne__(self, other):
223
return not (self == other)
224
225
def __hash__(self):
226
raise ValueError('not hashable')
227
228
229
230
class RootEntry(InventoryEntry):
231
def __init__(self, file_id):
232
self.file_id = file_id
233
self.children = {}
234
self.kind = 'root_directory'
235
self.parent_id = None
236
self.name = ''
237
238
def __eq__(self, other):
239
if not isinstance(other, RootEntry):
240
return NotImplemented
241
242
return (self.file_id == other.file_id) \
243
and (self.children == other.children)
244
245
246
247
class Inventory(object):
201
248
"""Inventory of versioned files in a tree.
202
249
203
An Inventory acts like a set of InventoryEntry items. You can
204
also look files up by their file_id or name.
205
206
May be read from and written to a metadata file in a tree. To
207
manipulate the inventory (for example to add a file), it is read
208
in, modified, and then written back out.
250
This describes which file_id is present at each point in the tree,
251
and possibly the SHA-1 or other information about the file.
252
Entries can be looked up either by path or by file_id.
209
253
210
254
The inventory represents a typical unix file tree, with
211
255
directories containing files and subdirectories. We never store
215
259
returned quickly.
216
260
217
261
InventoryEntry objects must not be modified after they are
218
inserted.
262
inserted, other than through the Inventory API.
219
263
220
264
>>> inv = Inventory()
221
>>> inv.write_xml(sys.stdout)
222
<inventory>
223
</inventory>
224
>>> inv.add(InventoryEntry('123-123', 'hello.c'))
265
>>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
225
266
>>> inv['123-123'].name
226
267
'hello.c'
227
>>> for file_id in inv: print file_id
228
...
229
123-123
230
268
231
269
May be treated as an iterator or set to look up file ids:
232
270
239
277
240
278
>>> [x[0] for x in inv.iter_entries()]
241
279
['hello.c']
242
243
>>> inv.write_xml(sys.stdout)
244
<inventory>
245
<entry file_id="123-123" kind="file" name="hello.c" />
246
</inventory>
247
248
280
"""
249
250
## TODO: Clear up handling of files in subdirectories; we probably
251
## do want to be able to just look them up by name but this
252
## probably means gradually walking down the path, looking up as we go.
253
254
## TODO: Make sure only canonical filenames are stored.
255
256
## TODO: Do something sensible about the possible collisions on
257
## case-losing filesystems. Perhaps we should just always forbid
258
## such collisions.
259
260
## _tree should probably just be stored as
261
## InventoryEntry._children on each directory.
262
263
281
def __init__(self):
264
282
"""Create or read an inventory.
265
283
266
284
If a working directory is specified, the inventory is read
267
285
from there. If the file is specified, read from that. If not,
268
286
the inventory is created empty.
287
288
The inventory is created with a default root directory, with
289
an id of None.
269
290
"""
270
self._byid = dict()
271
272
# _tree is indexed by parent_id; at each level a map from name
273
# to ie. The None entry is the root.
274
self._tree = {None: {}}
291
self.root = RootEntry(ROOT_ID)
292
self._byid = {self.root.file_id: self.root}
275
293
276
294
277
295
def __iter__(self):
283
301
return len(self._byid)
284
302
285
303
286
def iter_entries(self, parent_id=None):
304
def iter_entries(self, from_dir=None):
287
305
"""Return (path, entry) pairs, in order by name."""
288
kids = self._tree[parent_id].items()
306
if from_dir == None:
307
assert self.root
308
from_dir = self.root
309
elif isinstance(from_dir, basestring):
310
from_dir = self._byid[from_dir]
311
312
kids = from_dir.children.items()
289
313
kids.sort()
290
314
for name, ie in kids:
291
315
yield name, ie
292
316
if ie.kind == 'directory':
293
for cn, cie in self.iter_entries(parent_id=ie.file_id):
294
yield joinpath([name, cn]), cie
295
296
297
def directories(self, include_root=True):
298
"""Return (path, entry) pairs for all directories.
299
"""
300
if include_root:
301
yield '', None
302
for path, entry in self.iter_entries():
303
if entry.kind == 'directory':
304
yield path, entry
317
for cn, cie in self.iter_entries(from_dir=ie.file_id):
318
yield os.path.join(name, cn), cie
319
320
321
def entries(self):
322
"""Return list of (path, ie) for all entries except the root.
323
324
This may be faster than iter_entries.
325
"""
326
accum = []
327
def descend(dir_ie, dir_path):
328
kids = dir_ie.children.items()
329
kids.sort()
330
for name, ie in kids:
331
child_path = os.path.join(dir_path, name)
332
accum.append((child_path, ie))
333
if ie.kind == 'directory':
334
descend(ie, child_path)
335
336
descend(self.root, '')
337
return accum
338
339
340
def directories(self):
341
"""Return (path, entry) pairs for all directories, including the root.
342
"""
343
accum = []
344
def descend(parent_ie, parent_path):
345
accum.append((parent_path, parent_ie))
346
347
kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
348
kids.sort()
349
350
for name, child_ie in kids:
351
child_path = os.path.join(parent_path, name)
352
descend(child_ie, child_path)
353
descend(self.root, '')
354
return accum
305
355
306
356
307
357
308
def children(self, parent_id):
309
"""Return entries that are direct children of parent_id."""
310
return self._tree[parent_id]
311
312
313
314
# TODO: return all paths and entries
315
316
317
358
def __contains__(self, file_id):
318
359
"""True if this entry contains a file with given id.
319
360
320
361
>>> inv = Inventory()
321
>>> inv.add(InventoryEntry('123', 'foo.c'))
362
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
322
363
>>> '123' in inv
323
364
True
324
365
>>> '456' in inv
331
372
"""Return the entry for given file_id.
332
373
333
374
>>> inv = Inventory()
334
>>> inv.add(InventoryEntry('123123', 'hello.c'))
375
>>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
335
376
>>> inv['123123'].name
336
377
'hello.c'
337
378
"""
338
return self._byid[file_id]
379
try:
380
return self._byid[file_id]
381
except KeyError:
382
if file_id == None:
383
raise BzrError("can't look up file_id None")
384
else:
385
raise BzrError("file_id {%s} not in inventory" % file_id)
386
387
388
def get_file_kind(self, file_id):
389
return self._byid[file_id].kind
390
391
def get_child(self, parent_id, filename):
392
return self[parent_id].children.get(filename)
339
393
340
394
341
395
def add(self, entry):
343
397
344
398
To add a file to a branch ready to be committed, use Branch.add,
345
399
which calls this."""
346
if entry.file_id in self:
347
bailout("inventory already contains entry with id {%s}" % entry.file_id)
348
349
if entry.parent_id != None:
350
if entry.parent_id not in self:
351
bailout("parent_id %s of new entry not found in inventory"
352
% entry.parent_id)
353
354
if self._tree[entry.parent_id].has_key(entry.name):
355
bailout("%s is already versioned"
356
% appendpath(self.id2path(entry.parent_id), entry.name))
400
if entry.file_id in self._byid:
401
raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
402
403
try:
404
parent = self._byid[entry.parent_id]
405
except KeyError:
406
raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
407
408
if parent.children.has_key(entry.name):
409
raise BzrError("%s is already versioned" %
410
appendpath(self.id2path(parent.file_id), entry.name))
357
411
358
412
self._byid[entry.file_id] = entry
359
self._tree[entry.parent_id][entry.name] = entry
360
361
if entry.kind == 'directory':
362
self._tree[entry.file_id] = {}
413
parent.children[entry.name] = entry
363
414
364
415
365
416
def add_path(self, relpath, kind, file_id=None):
366
417
"""Add entry from a path.
367
418
368
419
The immediate parent must already be versioned"""
420
from bzrlib.errors import NotVersionedError
421
369
422
parts = bzrlib.osutils.splitpath(relpath)
370
423
if len(parts) == 0:
371
bailout("cannot re-add root of inventory")
372
373
if file_id is None:
374
file_id = bzrlib.branch.gen_file_id(relpath)
375
376
parent_id = self.path2id(parts[:-1])
424
raise BzrError("cannot re-add root of inventory")
425
426
if file_id == None:
427
from bzrlib.branch import gen_file_id
428
file_id = gen_file_id(relpath)
429
430
parent_path = parts[:-1]
431
parent_id = self.path2id(parent_path)
432
if parent_id == None:
433
raise NotVersionedError(parent_path)
434
377
435
ie = InventoryEntry(file_id, parts[-1],
378
436
kind=kind, parent_id=parent_id)
379
437
return self.add(ie)
383
441
"""Remove entry by id.
384
442
385
443
>>> inv = Inventory()
386
>>> inv.add(InventoryEntry('123', 'foo.c'))
444
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
387
445
>>> '123' in inv
388
446
True
389
447
>>> del inv['123']
392
450
"""
393
451
ie = self[file_id]
394
452
395
assert self._tree[ie.parent_id][ie.name] == ie
453
assert self[ie.parent_id].children[ie.name] == ie
396
454
397
455
# TODO: Test deleting all children; maybe hoist to a separate
398
456
# deltree method?
399
457
if ie.kind == 'directory':
400
for cie in self._tree[file_id].values():
458
for cie in ie.children.values():
401
459
del self[cie.file_id]
402
del self._tree[file_id]
460
del ie.children
403
461
404
462
del self._byid[file_id]
405
del self._tree[ie.parent_id][ie.name]
406
407
408
def id_set(self):
409
return Set(self._byid)
463
del self[ie.parent_id].children[ie.name]
410
464
411
465
412
466
def to_element(self):
413
467
"""Convert to XML Element"""
468
from bzrlib.xml import Element
469
414
470
e = Element('inventory')
415
471
e.text = '\n'
416
472
for path, ie in self.iter_entries():
422
478
"""Construct from XML Element
423
479
424
480
>>> inv = Inventory()
425
>>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
481
>>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c', 'file', ROOT_ID))
426
482
>>> elt = inv.to_element()
427
483
>>> inv2 = Inventory.from_element(elt)
428
484
>>> inv2 == inv
437
493
from_element = classmethod(from_element)
438
494
439
495
440
def __cmp__(self, other):
496
def __eq__(self, other):
441
497
"""Compare two sets by comparing their contents.
442
498
443
499
>>> i1 = Inventory()
444
500
>>> i2 = Inventory()
445
501
>>> i1 == i2
446
502
True
447
>>> i1.add(InventoryEntry('123', 'foo'))
503
>>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
448
504
>>> i1 == i2
449
505
False
450
>>> i2.add(InventoryEntry('123', 'foo'))
506
>>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
451
507
>>> i1 == i2
452
508
True
453
509
"""
454
if self is other:
455
return 0
456
457
510
if not isinstance(other, Inventory):
458
511
return NotImplemented
459
512
460
if self.id_set() ^ other.id_set():
461
return 1
462
463
for file_id in self._byid:
464
c = cmp(self[file_id], other[file_id])
465
if c: return c
466
467
return 0
468
469
470
def id2path(self, file_id):
471
"""Return as a list the path to file_id."""
513
if len(self._byid) != len(other._byid):
514
# shortcut: obviously not the same
515
return False
516
517
return self._byid == other._byid
518
519
520
def __ne__(self, other):
521
return not (self == other)
522
523
524
def __hash__(self):
525
raise ValueError('not hashable')
526
527
528
529
def get_idpath(self, file_id):
530
"""Return a list of file_ids for the path to an entry.
531
532
The list contains one element for each directory followed by
533
the id of the file itself. So the length of the returned list
534
is equal to the depth of the file in the tree, counting the
535
root directory as depth 1.
536
"""
472
537
p = []
473
538
while file_id != None:
474
ie = self[file_id]
475
p = [ie.name] + p
539
try:
540
ie = self._byid[file_id]
541
except KeyError:
542
raise BzrError("file_id {%s} not found in inventory" % file_id)
543
p.insert(0, ie.file_id)
476
544
file_id = ie.parent_id
477
return joinpath(p)
545
return p
546
547
548
def id2path(self, file_id):
549
"""Return as a list the path to file_id."""
550
551
# get all names, skipping root
552
p = [self[fid].name for fid in self.get_idpath(file_id)[1:]]
553
return os.sep.join(p)
478
554
479
555
480
556
486
562
487
563
This returns the entry of the last component in the path,
488
564
which may be either a file or a directory.
565
566
Returns None iff the path is not found.
489
567
"""
490
568
if isinstance(name, types.StringTypes):
491
569
name = splitpath(name)
492
570
493
parent_id = None
571
mutter("lookup path %r" % name)
572
573
parent = self.root
494
574
for f in name:
495
575
try:
496
cie = self._tree[parent_id][f]
576
cie = parent.children[f]
497
577
assert cie.name == f
498
parent_id = cie.file_id
578
assert cie.parent_id == parent.file_id
579
parent = cie
499
580
except KeyError:
500
581
# or raise an error?
501
582
return None
502
583
503
return parent_id
504
505
506
def get_child(self, parent_id, child_name):
507
return self._tree[parent_id].get(child_name)
584
return parent.file_id
508
585
509
586
510
587
def has_filename(self, names):
512
589
513
590
514
591
def has_id(self, file_id):
515
assert isinstance(file_id, str)
516
592
return self._byid.has_key(file_id)
517
593
518
594
519
520
521
522
if __name__ == '__main__':
523
import doctest, inventory
524
doctest.testmod(inventory)
595
def rename(self, file_id, new_parent_id, new_name):
596
"""Move a file within the inventory.
597
598
This can change either the name, or the parent, or both.
599
600
This does not move the working file."""
601
if not is_valid_name(new_name):
602
raise BzrError("not an acceptable filename: %r" % new_name)
603
604
new_parent = self._byid[new_parent_id]
605
if new_name in new_parent.children:
606
raise BzrError("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
607
608
new_parent_idpath = self.get_idpath(new_parent_id)
609
if file_id in new_parent_idpath:
610
raise BzrError("cannot move directory %r into a subdirectory of itself, %r"
611
% (self.id2path(file_id), self.id2path(new_parent_id)))
612
613
file_ie = self._byid[file_id]
614
old_parent = self._byid[file_ie.parent_id]
615
616
# TODO: Don't leave things messed up if this fails
617
618
del old_parent.children[file_ie.name]
619
new_parent.children[new_name] = file_ie
620
621
file_ie.name = new_name
622
file_ie.parent_id = new_parent_id
623
624
625
626
627
_NAME_RE = re.compile(r'^[^/\\]+$')
628
629
def is_valid_name(name):
630
return bool(_NAME_RE.match(name))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1