~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-09 04:08:15 UTC
  • Revision ID: mbp@sourcefrog.net-20050309040815-13242001617e4a06
import from baz patch-364

Show diffs side-by-side

added added

removed removed

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