« back to all changes in this revision
Viewing changes to bzrlib/inventory.py
- browse files at revision 815
- compare with another revision
- download diff
- download tarball
- view history from revision 815
- Committer: Martin Pool
- Date: 2005-07-04 08:06:51 UTC
- Revision ID: mbp@sourcefrog.net-20050704080651-6ecec49164359e48
- track pending-merges
- unit tests for this
- unit tests for this
- 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
# TODO: Maybe store inventory_id in the file? Not really needed.
21
22
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
23
__author__ = "Martin Pool <mbp@canonical.com>"
24
25
import sys, os.path, types
26
from sets import Set
27
28
try:
29
from cElementTree import Element, ElementTree, SubElement
30
except ImportError:
31
from elementtree.ElementTree import Element, ElementTree, SubElement
32
33
from xml import XMLMixin
34
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
35
24
36
25
import bzrlib
26
from bzrlib.errors import BzrError, BzrCheckError
27
37
28
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
38
29
from bzrlib.trace import mutter
39
30
40
class InventoryEntry(XMLMixin):
31
class InventoryEntry(object):
41
32
"""Description of a versioned file.
42
33
43
34
An InventoryEntry has the following fields, which are also
60
51
61
52
>>> i = Inventory()
62
53
>>> i.path2id('')
63
>>> i.add(InventoryEntry('123', 'src', kind='directory'))
64
>>> 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'))
65
57
>>> for j in i.iter_entries():
66
58
... print j
67
59
...
68
('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
60
('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
69
61
('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
70
>>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
62
>>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
71
63
Traceback (most recent call last):
72
64
...
73
BzrError: ('inventory already contains entry with id {2323}', [])
74
>>> i.add(InventoryEntry('2324', 'bye.c', parent_id='123'))
75
>>> 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'))
76
68
>>> i.path2id('src/wibble')
77
69
'2325'
78
70
>>> '2325' in i
79
71
True
80
>>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
72
>>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
81
73
>>> i['2326']
82
74
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
83
75
>>> for j in i.iter_entries():
92
84
>>> i.id2path('2326')
93
85
'src/wibble/wibble.c'
94
86
95
: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?
96
88
But those depend on its position within a particular inventory, and
97
89
it would be nice not to need to hold the backpointer here.
98
90
"""
99
def __init__(self, file_id, name, kind='file', text_id=None,
100
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):
101
99
"""Create an InventoryEntry
102
100
103
101
The filename must be a single component, relative to the
104
102
parent directory; it cannot be a whole path or relative name.
105
103
106
>>> e = InventoryEntry('123', 'hello.c')
104
>>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
107
105
>>> e.name
108
106
'hello.c'
109
107
>>> e.file_id
110
108
'123'
111
>>> e = InventoryEntry('123', 'src/hello.c')
109
>>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
112
110
Traceback (most recent call last):
113
BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
111
BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
114
112
"""
115
116
if len(splitpath(name)) != 1:
117
bailout('InventoryEntry name is not a simple filename: %r'
118
% name)
113
if '/' in name or '\\' in name:
114
raise BzrCheckError('InventoryEntry name %r is invalid' % name)
119
115
120
116
self.file_id = file_id
121
117
self.name = name
122
assert kind in ['file', 'directory']
123
118
self.kind = kind
124
119
self.text_id = text_id
125
120
self.parent_id = parent_id
126
self.text_sha1 = None
127
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
128
134
129
135
130
136
def copy(self):
131
137
other = InventoryEntry(self.file_id, self.name, self.kind,
132
self.text_id, self.parent_id)
138
self.parent_id, text_id=self.text_id)
133
139
other.text_sha1 = self.text_sha1
134
140
other.text_size = self.text_size
141
# note that children are *not* copied; they're pulled across when
142
# others are added
135
143
return other
136
144
137
145
146
154
147
155
def to_element(self):
148
156
"""Convert to XML element"""
157
from bzrlib.xml import Element
158
149
159
e = Element('entry')
150
160
151
161
e.set('name', self.name)
152
162
e.set('file_id', self.file_id)
153
163
e.set('kind', self.kind)
154
164
155
if self.text_size is not None:
165
if self.text_size != None:
156
166
e.set('text_size', '%d' % self.text_size)
157
167
158
for f in ['text_id', 'text_sha1', 'parent_id']:
168
for f in ['text_id', 'text_sha1']:
159
169
v = getattr(self, f)
160
if v is not None:
170
if v != None:
161
171
e.set(f, v)
162
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
163
180
e.tail = '\n'
164
181
165
182
return e
167
184
168
185
def from_element(cls, elt):
169
186
assert elt.tag == 'entry'
170
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)
171
196
self.text_id = elt.get('text_id')
172
197
self.text_sha1 = elt.get('text_sha1')
173
self.parent_id = elt.get('parent_id')
174
198
175
199
## mutter("read inventoryentry: %r" % (elt.attrib))
176
200
182
206
183
207
from_element = classmethod(from_element)
184
208
185
def __cmp__(self, other):
186
if self is other:
187
return 0
209
def __eq__(self, other):
188
210
if not isinstance(other, InventoryEntry):
189
211
return NotImplemented
190
212
191
return cmp(self.file_id, other.file_id) \
192
or cmp(self.name, other.name) \
193
or cmp(self.text_sha1, other.text_sha1) \
194
or cmp(self.text_size, other.text_size) \
195
or cmp(self.text_id, other.text_id) \
196
or cmp(self.parent_id, other.parent_id) \
197
or cmp(self.kind, other.kind)
198
199
200
201
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):
202
248
"""Inventory of versioned files in a tree.
203
249
204
An Inventory acts like a set of InventoryEntry items. You can
205
also look files up by their file_id or name.
206
207
May be read from and written to a metadata file in a tree. To
208
manipulate the inventory (for example to add a file), it is read
209
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.
210
253
211
254
The inventory represents a typical unix file tree, with
212
255
directories containing files and subdirectories. We never store
216
259
returned quickly.
217
260
218
261
InventoryEntry objects must not be modified after they are
219
inserted.
262
inserted, other than through the Inventory API.
220
263
221
264
>>> inv = Inventory()
222
>>> inv.write_xml(sys.stdout)
223
<inventory>
224
</inventory>
225
>>> inv.add(InventoryEntry('123-123', 'hello.c'))
265
>>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
226
266
>>> inv['123-123'].name
227
267
'hello.c'
228
>>> for file_id in inv: print file_id
229
...
230
123-123
231
268
232
269
May be treated as an iterator or set to look up file ids:
233
270
240
277
241
278
>>> [x[0] for x in inv.iter_entries()]
242
279
['hello.c']
243
244
>>> inv.write_xml(sys.stdout)
245
<inventory>
246
<entry file_id="123-123" kind="file" name="hello.c" />
247
</inventory>
248
249
280
"""
250
251
## TODO: Clear up handling of files in subdirectories; we probably
252
## do want to be able to just look them up by name but this
253
## probably means gradually walking down the path, looking up as we go.
254
255
## TODO: Make sure only canonical filenames are stored.
256
257
## TODO: Do something sensible about the possible collisions on
258
## case-losing filesystems. Perhaps we should just always forbid
259
## such collisions.
260
261
## _tree should probably just be stored as
262
## InventoryEntry._children on each directory.
263
264
281
def __init__(self):
265
282
"""Create or read an inventory.
266
283
267
284
If a working directory is specified, the inventory is read
268
285
from there. If the file is specified, read from that. If not,
269
286
the inventory is created empty.
287
288
The inventory is created with a default root directory, with
289
an id of None.
270
290
"""
271
self._byid = dict()
272
273
# _tree is indexed by parent_id; at each level a map from name
274
# to ie. The None entry is the root.
275
self._tree = {None: {}}
291
self.root = RootEntry(ROOT_ID)
292
self._byid = {self.root.file_id: self.root}
276
293
277
294
278
295
def __iter__(self):
284
301
return len(self._byid)
285
302
286
303
287
def iter_entries(self, parent_id=None):
304
def iter_entries(self, from_dir=None):
288
305
"""Return (path, entry) pairs, in order by name."""
289
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()
290
313
kids.sort()
291
314
for name, ie in kids:
292
315
yield name, ie
293
316
if ie.kind == 'directory':
294
for cn, cie in self.iter_entries(parent_id=ie.file_id):
295
yield joinpath([name, cn]), cie
296
297
298
def directories(self, include_root=True):
299
"""Return (path, entry) pairs for all directories.
300
"""
301
if include_root:
302
yield '', None
303
for path, entry in self.iter_entries():
304
if entry.kind == 'directory':
305
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
306
355
307
356
308
357
309
def children(self, parent_id):
310
"""Return entries that are direct children of parent_id."""
311
return self._tree[parent_id]
312
313
314
315
# TODO: return all paths and entries
316
317
318
358
def __contains__(self, file_id):
319
359
"""True if this entry contains a file with given id.
320
360
321
361
>>> inv = Inventory()
322
>>> inv.add(InventoryEntry('123', 'foo.c'))
362
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
323
363
>>> '123' in inv
324
364
True
325
365
>>> '456' in inv
332
372
"""Return the entry for given file_id.
333
373
334
374
>>> inv = Inventory()
335
>>> inv.add(InventoryEntry('123123', 'hello.c'))
375
>>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
336
376
>>> inv['123123'].name
337
377
'hello.c'
338
378
"""
339
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)
340
393
341
394
342
395
def add(self, entry):
344
397
345
398
To add a file to a branch ready to be committed, use Branch.add,
346
399
which calls this."""
347
if entry.file_id in self:
348
bailout("inventory already contains entry with id {%s}" % entry.file_id)
349
350
if entry.parent_id != None:
351
if entry.parent_id not in self:
352
bailout("parent_id %s of new entry not found in inventory"
353
% entry.parent_id)
354
355
if self._tree[entry.parent_id].has_key(entry.name):
356
bailout("%s is already versioned"
357
% 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))
358
411
359
412
self._byid[entry.file_id] = entry
360
self._tree[entry.parent_id][entry.name] = entry
361
362
if entry.kind == 'directory':
363
self._tree[entry.file_id] = {}
413
parent.children[entry.name] = entry
364
414
365
415
366
416
def add_path(self, relpath, kind, file_id=None):
367
417
"""Add entry from a path.
368
418
369
419
The immediate parent must already be versioned"""
420
from bzrlib.errors import NotVersionedError
421
370
422
parts = bzrlib.osutils.splitpath(relpath)
371
423
if len(parts) == 0:
372
bailout("cannot re-add root of inventory")
373
374
if file_id is None:
375
file_id = bzrlib.branch.gen_file_id(relpath)
376
377
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
378
435
ie = InventoryEntry(file_id, parts[-1],
379
436
kind=kind, parent_id=parent_id)
380
437
return self.add(ie)
384
441
"""Remove entry by id.
385
442
386
443
>>> inv = Inventory()
387
>>> inv.add(InventoryEntry('123', 'foo.c'))
444
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
388
445
>>> '123' in inv
389
446
True
390
447
>>> del inv['123']
393
450
"""
394
451
ie = self[file_id]
395
452
396
assert self._tree[ie.parent_id][ie.name] == ie
453
assert self[ie.parent_id].children[ie.name] == ie
397
454
398
455
# TODO: Test deleting all children; maybe hoist to a separate
399
456
# deltree method?
400
457
if ie.kind == 'directory':
401
for cie in self._tree[file_id].values():
458
for cie in ie.children.values():
402
459
del self[cie.file_id]
403
del self._tree[file_id]
460
del ie.children
404
461
405
462
del self._byid[file_id]
406
del self._tree[ie.parent_id][ie.name]
407
408
409
def id_set(self):
410
return Set(self._byid)
463
del self[ie.parent_id].children[ie.name]
411
464
412
465
413
466
def to_element(self):
414
467
"""Convert to XML Element"""
468
from bzrlib.xml import Element
469
415
470
e = Element('inventory')
416
471
e.text = '\n'
417
472
for path, ie in self.iter_entries():
423
478
"""Construct from XML Element
424
479
425
480
>>> inv = Inventory()
426
>>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
481
>>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c', 'file', ROOT_ID))
427
482
>>> elt = inv.to_element()
428
483
>>> inv2 = Inventory.from_element(elt)
429
484
>>> inv2 == inv
438
493
from_element = classmethod(from_element)
439
494
440
495
441
def __cmp__(self, other):
496
def __eq__(self, other):
442
497
"""Compare two sets by comparing their contents.
443
498
444
499
>>> i1 = Inventory()
445
500
>>> i2 = Inventory()
446
501
>>> i1 == i2
447
502
True
448
>>> i1.add(InventoryEntry('123', 'foo'))
503
>>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
449
504
>>> i1 == i2
450
505
False
451
>>> i2.add(InventoryEntry('123', 'foo'))
506
>>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
452
507
>>> i1 == i2
453
508
True
454
509
"""
455
if self is other:
456
return 0
457
458
510
if not isinstance(other, Inventory):
459
511
return NotImplemented
460
512
461
if self.id_set() ^ other.id_set():
462
return 1
463
464
for file_id in self._byid:
465
c = cmp(self[file_id], other[file_id])
466
if c: return c
467
468
return 0
469
470
471
def id2path(self, file_id):
472
"""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
"""
473
537
p = []
474
538
while file_id != None:
475
ie = self[file_id]
476
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)
477
544
file_id = ie.parent_id
478
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)
479
554
480
555
481
556
487
562
488
563
This returns the entry of the last component in the path,
489
564
which may be either a file or a directory.
565
566
Returns None iff the path is not found.
490
567
"""
491
568
if isinstance(name, types.StringTypes):
492
569
name = splitpath(name)
493
570
494
parent_id = None
571
mutter("lookup path %r" % name)
572
573
parent = self.root
495
574
for f in name:
496
575
try:
497
cie = self._tree[parent_id][f]
576
cie = parent.children[f]
498
577
assert cie.name == f
499
parent_id = cie.file_id
578
assert cie.parent_id == parent.file_id
579
parent = cie
500
580
except KeyError:
501
581
# or raise an error?
502
582
return None
503
583
504
return parent_id
505
506
507
def get_child(self, parent_id, child_name):
508
return self._tree[parent_id].get(child_name)
584
return parent.file_id
509
585
510
586
511
587
def has_filename(self, names):
513
589
514
590
515
591
def has_id(self, file_id):
516
assert isinstance(file_id, str)
517
592
return self._byid.has_key(file_id)
518
593
519
594
520
521
522
523
if __name__ == '__main__':
524
import doctest, inventory
525
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