« back to all changes in this revision
Viewing changes to bzrlib/inventory.py
- browse files at revision 120
- compare with another revision
- download diff
- download tarball
- view history from revision 120
- Committer: mbp at sourcefrog
- Date: 2005-03-28 13:20:38 UTC
- Revision ID: mbp@sourcefrog.net-20050328132038-3a8a5fb9f1023ee1
more check functions
- files added:
- bzrlib/tests.py
- files removed:
- .rsyncexclude
- bzrlib/selftest
- contrib
- contrib/bash
- contrib/zsh
- effbot
- effbot/org
- patches
- plugins
- plugins/changeset
- plugins/rsync
- urlgrabber
- files modified:
- .bzrignore
added
removed
bzrlib/inventory.py
1
# (C) 2005 Canonical Ltd
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
2
3
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
14
15
# along with this program; if not, write to the Free Software
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
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
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
24
35
25
36
import bzrlib
26
from bzrlib.errors import BzrError, BzrCheckError
27
28
37
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
29
38
from bzrlib.trace import mutter
30
39
31
class InventoryEntry(object):
40
class InventoryEntry(XMLMixin):
32
41
"""Description of a versioned file.
33
42
34
43
An InventoryEntry has the following fields, which are also
51
60
52
61
>>> i = Inventory()
53
62
>>> i.path2id('')
54
'TREE_ROOT'
55
>>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
56
>>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
63
>>> i.add(InventoryEntry('123', 'src', kind='directory'))
64
>>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
57
65
>>> for j in i.iter_entries():
58
66
... print j
59
67
...
60
('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
68
('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
61
69
('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
62
>>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
70
>>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
63
71
Traceback (most recent call last):
64
72
...
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'))
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'))
68
76
>>> i.path2id('src/wibble')
69
77
'2325'
70
78
>>> '2325' in i
71
79
True
72
>>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
80
>>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
73
81
>>> i['2326']
74
82
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
75
83
>>> for j in i.iter_entries():
84
92
>>> i.id2path('2326')
85
93
'src/wibble/wibble.c'
86
94
87
TODO: Maybe also keep the full path of the entry, and the children?
95
:todo: Maybe also keep the full path of the entry, and the children?
88
96
But those depend on its position within a particular inventory, and
89
97
it would be nice not to need to hold the backpointer here.
90
98
"""
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):
99
def __init__(self, file_id, name, kind='file', text_id=None,
100
parent_id=None):
99
101
"""Create an InventoryEntry
100
102
101
103
The filename must be a single component, relative to the
102
104
parent directory; it cannot be a whole path or relative name.
103
105
104
>>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
106
>>> e = InventoryEntry('123', 'hello.c')
105
107
>>> e.name
106
108
'hello.c'
107
109
>>> e.file_id
108
110
'123'
109
>>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
111
>>> e = InventoryEntry('123', 'src/hello.c')
110
112
Traceback (most recent call last):
111
BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
113
BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
112
114
"""
113
if '/' in name or '\\' in name:
114
raise BzrCheckError('InventoryEntry name %r is invalid' % name)
115
116
if len(splitpath(name)) != 1:
117
bailout('InventoryEntry name is not a simple filename: %r'
118
% name)
115
119
116
120
self.file_id = file_id
117
121
self.name = name
122
assert kind in ['file', 'directory']
118
123
self.kind = kind
119
124
self.text_id = text_id
120
125
self.parent_id = parent_id
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
126
self.text_sha1 = None
127
self.text_size = None
134
128
135
129
136
130
def copy(self):
137
131
other = InventoryEntry(self.file_id, self.name, self.kind,
138
self.parent_id, text_id=self.text_id)
132
self.text_id, self.parent_id)
139
133
other.text_sha1 = self.text_sha1
140
134
other.text_size = self.text_size
141
# note that children are *not* copied; they're pulled across when
142
# others are added
143
135
return other
144
136
145
137
154
146
155
147
def to_element(self):
156
148
"""Convert to XML element"""
157
from bzrlib.xml import Element
158
159
149
e = Element('entry')
160
150
161
151
e.set('name', self.name)
162
152
e.set('file_id', self.file_id)
163
153
e.set('kind', self.kind)
164
154
165
if self.text_size != None:
155
if self.text_size is not None:
166
156
e.set('text_size', '%d' % self.text_size)
167
157
168
for f in ['text_id', 'text_sha1']:
158
for f in ['text_id', 'text_sha1', 'parent_id']:
169
159
v = getattr(self, f)
170
if v != None:
160
if v is not None:
171
161
e.set(f, v)
172
162
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
180
163
e.tail = '\n'
181
164
182
165
return e
184
167
185
168
def from_element(cls, elt):
186
169
assert elt.tag == 'entry'
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
self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'))
196
171
self.text_id = elt.get('text_id')
197
172
self.text_sha1 = elt.get('text_sha1')
173
self.parent_id = elt.get('parent_id')
198
174
199
175
## mutter("read inventoryentry: %r" % (elt.attrib))
200
176
206
182
207
183
from_element = classmethod(from_element)
208
184
209
def __eq__(self, other):
185
def __cmp__(self, other):
186
if self is other:
187
return 0
210
188
if not isinstance(other, InventoryEntry):
211
189
return NotImplemented
212
190
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):
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):
248
202
"""Inventory of versioned files in a tree.
249
203
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.
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.
253
210
254
211
The inventory represents a typical unix file tree, with
255
212
directories containing files and subdirectories. We never store
259
216
returned quickly.
260
217
261
218
InventoryEntry objects must not be modified after they are
262
inserted, other than through the Inventory API.
219
inserted.
263
220
264
221
>>> inv = Inventory()
265
>>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
222
>>> inv.write_xml(sys.stdout)
223
<inventory>
224
</inventory>
225
>>> inv.add(InventoryEntry('123-123', 'hello.c'))
266
226
>>> inv['123-123'].name
267
227
'hello.c'
228
>>> for file_id in inv: print file_id
229
...
230
123-123
268
231
269
232
May be treated as an iterator or set to look up file ids:
270
233
277
240
278
241
>>> [x[0] for x in inv.iter_entries()]
279
242
['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
280
249
"""
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
281
264
def __init__(self):
282
265
"""Create or read an inventory.
283
266
284
267
If a working directory is specified, the inventory is read
285
268
from there. If the file is specified, read from that. If not,
286
269
the inventory is created empty.
287
288
The inventory is created with a default root directory, with
289
an id of None.
290
270
"""
291
self.root = RootEntry(ROOT_ID)
292
self._byid = {self.root.file_id: self.root}
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: {}}
293
276
294
277
295
278
def __iter__(self):
301
284
return len(self._byid)
302
285
303
286
304
def iter_entries(self, from_dir=None):
287
def iter_entries(self, parent_id=None):
305
288
"""Return (path, entry) pairs, in order by name."""
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
kids = self._tree[parent_id].items()
313
290
kids.sort()
314
291
for name, ie in kids:
315
292
yield name, ie
316
293
if ie.kind == 'directory':
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
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
355
306
356
307
357
308
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
358
318
def __contains__(self, file_id):
359
319
"""True if this entry contains a file with given id.
360
320
361
321
>>> inv = Inventory()
362
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
322
>>> inv.add(InventoryEntry('123', 'foo.c'))
363
323
>>> '123' in inv
364
324
True
365
325
>>> '456' in inv
372
332
"""Return the entry for given file_id.
373
333
374
334
>>> inv = Inventory()
375
>>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
335
>>> inv.add(InventoryEntry('123123', 'hello.c'))
376
336
>>> inv['123123'].name
377
337
'hello.c'
378
338
"""
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
return self._byid[file_id]
393
340
394
341
395
342
def add(self, entry):
397
344
398
345
To add a file to a branch ready to be committed, use Branch.add,
399
346
which calls this."""
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))
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))
411
358
412
359
self._byid[entry.file_id] = entry
413
parent.children[entry.name] = entry
360
self._tree[entry.parent_id][entry.name] = entry
361
362
if entry.kind == 'directory':
363
self._tree[entry.file_id] = {}
414
364
415
365
416
366
def add_path(self, relpath, kind, file_id=None):
417
367
"""Add entry from a path.
418
368
419
369
The immediate parent must already be versioned"""
420
from bzrlib.errors import NotVersionedError
421
422
370
parts = bzrlib.osutils.splitpath(relpath)
423
371
if len(parts) == 0:
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
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])
435
378
ie = InventoryEntry(file_id, parts[-1],
436
379
kind=kind, parent_id=parent_id)
437
380
return self.add(ie)
441
384
"""Remove entry by id.
442
385
443
386
>>> inv = Inventory()
444
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
387
>>> inv.add(InventoryEntry('123', 'foo.c'))
445
388
>>> '123' in inv
446
389
True
447
390
>>> del inv['123']
450
393
"""
451
394
ie = self[file_id]
452
395
453
assert self[ie.parent_id].children[ie.name] == ie
396
assert self._tree[ie.parent_id][ie.name] == ie
454
397
455
398
# TODO: Test deleting all children; maybe hoist to a separate
456
399
# deltree method?
457
400
if ie.kind == 'directory':
458
for cie in ie.children.values():
401
for cie in self._tree[file_id].values():
459
402
del self[cie.file_id]
460
del ie.children
403
del self._tree[file_id]
461
404
462
405
del self._byid[file_id]
463
del self[ie.parent_id].children[ie.name]
406
del self._tree[ie.parent_id][ie.name]
407
408
409
def id_set(self):
410
return Set(self._byid)
464
411
465
412
466
413
def to_element(self):
467
414
"""Convert to XML Element"""
468
from bzrlib.xml import Element
469
470
415
e = Element('inventory')
471
416
e.text = '\n'
472
417
for path, ie in self.iter_entries():
478
423
"""Construct from XML Element
479
424
480
425
>>> inv = Inventory()
481
>>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c', 'file', ROOT_ID))
426
>>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
482
427
>>> elt = inv.to_element()
483
428
>>> inv2 = Inventory.from_element(elt)
484
429
>>> inv2 == inv
493
438
from_element = classmethod(from_element)
494
439
495
440
496
def __eq__(self, other):
441
def __cmp__(self, other):
497
442
"""Compare two sets by comparing their contents.
498
443
499
444
>>> i1 = Inventory()
500
445
>>> i2 = Inventory()
501
446
>>> i1 == i2
502
447
True
503
>>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
448
>>> i1.add(InventoryEntry('123', 'foo'))
504
449
>>> i1 == i2
505
450
False
506
>>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
451
>>> i2.add(InventoryEntry('123', 'foo'))
507
452
>>> i1 == i2
508
453
True
509
454
"""
455
if self is other:
456
return 0
457
510
458
if not isinstance(other, Inventory):
511
459
return NotImplemented
512
460
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
"""
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."""
537
473
p = []
538
474
while file_id != None:
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)
475
ie = self[file_id]
476
p = [ie.name] + p
544
477
file_id = ie.parent_id
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
return joinpath(p)
554
479
555
480
556
481
562
487
563
488
This returns the entry of the last component in the path,
564
489
which may be either a file or a directory.
565
566
Returns None iff the path is not found.
567
490
"""
568
491
if isinstance(name, types.StringTypes):
569
492
name = splitpath(name)
570
493
571
mutter("lookup path %r" % name)
572
573
parent = self.root
494
parent_id = None
574
495
for f in name:
575
496
try:
576
cie = parent.children[f]
497
cie = self._tree[parent_id][f]
577
498
assert cie.name == f
578
assert cie.parent_id == parent.file_id
579
parent = cie
499
parent_id = cie.file_id
580
500
except KeyError:
581
501
# or raise an error?
582
502
return None
583
503
584
return parent.file_id
504
return parent_id
505
506
507
def get_child(self, parent_id, child_name):
508
return self._tree[parent_id].get(child_name)
585
509
586
510
587
511
def has_filename(self, names):
589
513
590
514
591
515
def has_id(self, file_id):
516
assert isinstance(file_id, str)
592
517
return self._byid.has_key(file_id)
593
518
594
519
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))
520
521
522
523
if __name__ == '__main__':
524
import doctest, inventory
525
doctest.testmod(inventory)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1