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