Merge lp:~jelmer/brz/inv-not-dict into lp:brz

[Jelmer Vernooij]

Remove the __getitem__, __iter__ and __delitem__ implementations from Inventory.

Instead, add .get_entry(), .all_file_ids() and .delete().

[Martin Packman (gz)]

Thanks. Couple of inline notes.

review: Approve

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-dev/86/

=== modified file 'breezy/bundle/serializer/v08.py'
--- breezy/bundle/serializer/v08.py	2018-02-24 15:50:23 +0000
+++ breezy/bundle/serializer/v08.py	2018-03-25 02:37:06 +0000
@@ -281,7 +281,7 @@
 
         def finish_action(action, file_id, kind, meta_modified, text_modified,
                           old_path, new_path):
-            entry = new_tree.root_inventory[file_id]
+            entry = new_tree.root_inventory.get_entry(file_id)
             if entry.revision != default_revision_id:
                 action.add_utf8_property('last-changed', entry.revision)
             if meta_modified:

=== modified file 'breezy/bzr/inventory.py'
--- breezy/bzr/inventory.py	2018-03-24 17:48:04 +0000
+++ breezy/bzr/inventory.py	2018-03-25 02:37:06 +0000
@@ -112,7 +112,7 @@
     '2325'
     >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
     InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None, revision=None)
-    >>> i['2326']
+    >>> i.get_entry('2326')
     InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None, revision=None)
     >>> for path, entry in i.iter_entries():
     ...     print path
@@ -179,7 +179,7 @@
         # identify candidate head revision ids.
         for inv in previous_inventories:
             try:
-                ie = inv[self.file_id]
+                ie = inv.get_entry(self.file_id)
             except errors.NoSuchId:
                 pass
             else:
@@ -680,7 +680,7 @@
             from_dir = self.root
             yield '', self.root
         elif isinstance(from_dir, (str, text_type)):
-            from_dir = self[from_dir]
+            from_dir = self.get_entry(from_dir)
 
         # unrolling the recursive called changed the time from
         # 440ms/663ms (inline/total) to 116ms/116ms
@@ -762,14 +762,14 @@
                     except errors.NoSuchId:
                         pass
                     else:
-                        yield path, self[file_id]
+                        yield path, self.get_entry(file_id)
                 return
             from_dir = self.root
             if (specific_file_ids is None or yield_parents or
                 self.root.file_id in specific_file_ids):
                 yield u'', self.root
         elif isinstance(from_dir, (str, text_type)):
-            from_dir = self[from_dir]
+            from_dir = self.get_entry(from_dir)
 
         if specific_file_ids is not None:
             # TODO: jam 20070302 This could really be done as a loop rather
@@ -779,7 +779,7 @@
             def add_ancestors(file_id):
                 if not byid.has_id(file_id):
                     return
-                parent_id = byid[file_id].parent_id
+                parent_id = byid.get_entry(file_id).parent_id
                 if parent_id is None:
                     return
                 if parent_id not in parents:
@@ -811,8 +811,8 @@
 
     def _make_delta(self, old):
         """Make an inventory delta from two inventories."""
-        old_ids = set(old)
-        new_ids = set(self)
+        old_ids = set(old.iter_all_ids())
+        new_ids = set(self.iter_all_ids())
         adds = new_ids - old_ids
         deletes = old_ids - new_ids
         common = old_ids.intersection(new_ids)
@@ -820,11 +820,11 @@
         for file_id in deletes:
             delta.append((old.id2path(file_id), None, file_id, None))
         for file_id in adds:
-            delta.append((None, self.id2path(file_id), file_id, self[file_id]))
+            delta.append((None, self.id2path(file_id), file_id, self.get_entry(file_id)))
         for file_id in common:
-            if old[file_id] != self[file_id]:
+            if old.get_entry(file_id) != self.get_entry(file_id):
                 delta.append((old.id2path(file_id), self.id2path(file_id),
-                    file_id, self[file_id]))
+                    file_id, self.get_entry(file_id)))
         return delta
 
     def make_entry(self, kind, name, parent_id, file_id=None):
@@ -943,7 +943,7 @@
     >>> inv = Inventory()
     >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
     InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None, revision=None)
-    >>> inv['123-123'].name
+    >>> inv.get_entry('123-123').name
     'hello.c'
 
     Id's may be looked up from paths:
@@ -1046,7 +1046,7 @@
         for old_path, file_id in sorted(((op, f) for op, np, f, e in delta
                                         if op is not None), reverse=True):
             # Preserve unaltered children of file_id for later reinsertion.
-            file_id_children = getattr(self[file_id], 'children', {})
+            file_id_children = getattr(self.get_entry(file_id), 'children', {})
             if len(file_id_children):
                 children[file_id] = file_id_children
             if self.id2path(file_id) != old_path:
@@ -1113,7 +1113,7 @@
             other.add(entry.copy())
         return other
 
-    def __iter__(self):
+    def iter_all_ids(self):
         """Iterate over all file-ids."""
         return iter(self._byid)
 
@@ -1133,13 +1133,13 @@
         """Returns number of entries."""
         return len(self._byid)
 
-    def __getitem__(self, file_id):
+    def get_entry(self, file_id):
         """Return the entry for given file_id.
 
         >>> inv = Inventory()
         >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
         InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None, revision=None)
-        >>> inv['123123'].name
+        >>> inv.get_entry('123123').name
         'hello.c'
         """
         try:
@@ -1152,7 +1152,7 @@
         return self._byid[file_id].kind
 
     def get_child(self, parent_id, filename):
-        return self[parent_id].children.get(filename)
+        return self.get_entry(parent_id).children.get(filename)
 
     def _add_child(self, entry):
         """Add an entry to the inventory, without adding it to its parent"""
@@ -1214,7 +1214,7 @@
         ie = make_entry(kind, parts[-1], parent_id, file_id)
         return self.add(ie)
 
-    def __delitem__(self, file_id):
+    def delete(self, file_id):
         """Remove entry by id.
 
         >>> inv = Inventory()
@@ -1222,14 +1222,14 @@
         InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None, revision=None)
         >>> inv.has_id('123')
         True
-        >>> del inv['123']
+        >>> inv.delete('123')
         >>> inv.has_id('123')
         False
         """
-        ie = self[file_id]
+        ie = self.get_entry(file_id)
         del self._byid[file_id]
         if ie.parent_id is not None:
-            del self[ie.parent_id].children[ie.name]
+            del self.get_entry(ie.parent_id).children[ie.name]
 
     def __eq__(self, other):
         """Compare two sets by comparing their contents.
@@ -1273,10 +1273,10 @@
 
     def _make_delta(self, old):
         """Make an inventory delta from two inventories."""
-        old_getter = getattr(old, '_byid', old)
-        new_getter = self._byid
-        old_ids = set(old_getter)
-        new_ids = set(new_getter)
+        old_getter = old.get_entry
+        new_getter = self.get_entry
+        old_ids = set(old.iter_all_ids())
+        new_ids = set(self.iter_all_ids())
         adds = new_ids - old_ids
         deletes = old_ids - new_ids
         if not adds and not deletes:
@@ -1287,10 +1287,10 @@
         for file_id in deletes:
             delta.append((old.id2path(file_id), None, file_id, None))
         for file_id in adds:
-            delta.append((None, self.id2path(file_id), file_id, self[file_id]))
+            delta.append((None, self.id2path(file_id), file_id, self.get_entry(file_id)))
         for file_id in common:
-            new_ie = new_getter[file_id]
-            old_ie = old_getter[file_id]
+            new_ie = new_getter(file_id)
+            old_ie = old_getter(file_id)
             # If xml_serializer returns the cached InventoryEntries (rather
             # than always doing .copy()), inlining the 'is' check saves 2.7M
             # calls to __eq__.  Under lsprof this saves 20s => 6s.
@@ -1315,10 +1315,10 @@
             if ie.kind == 'directory':
                 to_find_delete.extend(viewvalues(ie.children))
         for file_id in reversed(to_delete):
-            ie = self[file_id]
+            ie = self.get_entry(file_id)
             del self._byid[file_id]
         if ie.parent_id is not None:
-            del self[ie.parent_id].children[ie.name]
+            del self.get_entry(ie.parent_id).children[ie.name]
         else:
             self.root = None
 
@@ -1707,7 +1707,7 @@
                 if old_path is None:
                     old_key = None
                 else:
-                    old_entry = self[file_id]
+                    old_entry = self.get_entry(file_id)
                     old_key = self._parent_id_basename_key(old_entry)
                 if new_path is None:
                     new_key = None
@@ -1728,7 +1728,7 @@
                             new_key, [None, None])[1] = new_value
         # validate that deletes are complete.
         for file_id in deletes:
-            entry = self[file_id]
+            entry = self.get_entry(file_id)
             if entry.kind != 'directory':
                 continue
             # This loop could potentially be better by using the id_basename
@@ -1754,7 +1754,7 @@
         parents.discard(('', None))
         for parent_path, parent in parents:
             try:
-                if result[parent].kind != 'directory':
+                if result.get_entry(parent).kind != 'directory':
                     raise errors.InconsistentDelta(result.id2path(parent), parent,
                         'Not a directory, but given children')
             except errors.NoSuchId:
@@ -1880,7 +1880,7 @@
             parent_id = b''
         return StaticTuple(parent_id, entry.name.encode('utf8')).intern()
 
-    def __getitem__(self, file_id):
+    def get_entry(self, file_id):
         """map a single file_id -> InventoryEntry."""
         if file_id is None:
             raise errors.NoSuchId(self, file_id)
@@ -1895,7 +1895,7 @@
             raise errors.NoSuchId(self, file_id)
 
     def _getitems(self, file_ids):
-        """Similar to __getitem__, but lets you query for multiple.
+        """Similar to get_entry, but lets you query for multiple.
         
         The returned order is undefined. And currently if an item doesn't
         exist, it isn't included in the output.
@@ -1929,13 +1929,13 @@
         """Yield the parents of file_id up to the root."""
         while file_id is not None:
             try:
-                ie = self[file_id]
+                ie = self.get_entry(file_id)
             except KeyError:
                 raise errors.NoSuchId(tree=self, file_id=file_id)
             yield ie
             file_id = ie.parent_id
 
-    def __iter__(self):
+    def iter_all_ids(self):
         """Iterate over all file-ids."""
         for key, _ in self.id_to_entry.iteritems():
             yield key[-1]
@@ -2172,7 +2172,7 @@
     @property
     def root(self):
         """Get the root entry."""
-        return self[self.root_id]
+        return self.get_entry(self.root_id)
 
 
 class CHKInventoryDirectory(InventoryDirectory):

=== modified file 'breezy/bzr/inventorytree.py'
--- breezy/bzr/inventorytree.py	2018-03-24 23:49:53 +0000
+++ breezy/bzr/inventorytree.py	2018-03-25 02:37:06 +0000
@@ -300,7 +300,7 @@
         with self.lock_read():
             inv, inv_file_id = self._path2inv_file_id(path, file_id)
             try:
-                ie = inv[inv_file_id]
+                ie = inv.get_entry(inv_file_id)
             except errors.NoSuchId:
                 raise errors.NoSuchFile(path)
             else:
@@ -807,7 +807,7 @@
     def get_file_mtime(self, path, file_id=None):
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
         try:
-            ie = inv[inv_file_id]
+            ie = inv.get_entry(inv_file_id)
         except errors.NoSuchId:
             raise errors.NoSuchFile(path)
         try:
@@ -818,11 +818,11 @@
 
     def get_file_size(self, path, file_id=None):
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
-        return inv[inv_file_id].text_size
+        return inv.get_entry(inv_file_id).text_size
 
     def get_file_sha1(self, path, file_id=None, stat_value=None):
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
-        ie = inv[inv_file_id]
+        ie = inv.get_entry(inv_file_id)
         if ie.kind == "file":
             return ie.text_sha1
         return None
@@ -830,14 +830,14 @@
     def get_file_revision(self, path, file_id=None):
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
         try:
-            ie = inv[inv_file_id]
+            ie = inv.get_entry(inv_file_id)
         except errors.NoSuchId:
             raise errors.NoSuchFile(path)
         return ie.revision
 
     def is_executable(self, path, file_id=None):
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
-        ie = inv[inv_file_id]
+        ie = inv.get_entry(inv_file_id)
         if ie.kind != "file":
             return False
         return ie.executable
@@ -864,13 +864,13 @@
 
     def get_symlink_target(self, path, file_id=None):
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
-        ie = inv[inv_file_id]
+        ie = inv.get_entry(inv_file_id)
         # Inventories store symlink targets in unicode
         return ie.symlink_target
 
     def get_reference_revision(self, path, file_id=None):
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
-        return inv[inv_file_id].reference_revision
+        return inv.get_entry(inv_file_id).reference_revision
 
     def get_root_id(self):
         if self.root_inventory.root:
@@ -879,7 +879,7 @@
     def kind(self, path, file_id=None):
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
         try:
-            return inv[inv_file_id].kind
+            return inv.get_entry(inv_file_id).kind
         except errors.NoSuchId:
             raise errors.NoSuchFile(path)
 
@@ -888,7 +888,7 @@
         inv, file_id = self._path2inv_file_id(path)
         if file_id is None:
             return ('missing', None, None, None)
-        entry = inv[file_id]
+        entry = inv.get_entry(file_id)
         kind = entry.kind
         if kind == 'file':
             return (kind, entry.text_size, entry.executable, entry.text_sha1)
@@ -918,7 +918,7 @@
             else:
                 relroot = ""
             # FIXME: stash the node in pending
-            entry = inv[currentdir[4]]
+            entry = inv.get_entry(currentdir[4])
             for name, child in entry.sorted_children():
                 toppath = relroot + name
                 dirblock.append((toppath, name, child.kind, None,

=== modified file 'breezy/bzr/vf_repository.py'
--- breezy/bzr/vf_repository.py	2018-03-24 23:49:53 +0000
+++ breezy/bzr/vf_repository.py	2018-03-25 02:37:06 +0000
@@ -258,7 +258,7 @@
             result = (None, path, ie.file_id, ie)
             self._basis_delta.append(result)
             return result
-        elif ie != basis_inv[ie.file_id]:
+        elif ie != basis_inv.get_entry(ie.file_id):
             # common but altered
             # TODO: avoid tis id2path call.
             result = (basis_inv.id2path(ie.file_id), path, ie.file_id, ie)
@@ -345,7 +345,7 @@
                         continue
                     if change[2] not in merged_ids:
                         if change[0] is not None:
-                            basis_entry = basis_inv[change[2]]
+                            basis_entry = basis_inv.get_entry(change[2])
                             merged_ids[change[2]] = [
                                 # basis revid
                                 basis_entry.revision,
@@ -371,7 +371,7 @@
         for change in iter_changes:
             # This probably looks up in basis_inv way to much.
             if change[1][0] is not None:
-                head_candidate = [basis_inv[change[0]].revision]
+                head_candidate = [basis_inv.get_entry(change[0]).revision]
             else:
                 head_candidate = []
             changes[change[0]] = change, merged_ids.get(change[0],
@@ -391,7 +391,7 @@
             #   changed_content, versioned, parent, name, kind,
             #   executable)
             try:
-                basis_entry = basis_inv[file_id]
+                basis_entry = basis_inv.get_entry(file_id)
             except errors.NoSuchId:
                 # a change from basis->some_parents but file_id isn't in basis
                 # so was new in the merge, which means it must have changed
@@ -1330,7 +1330,7 @@
                                 inv = self.revision_tree(parent_id).root_inventory
                                 inventory_cache[parent_id] = inv
                             try:
-                                parent_entry = inv[text_key[0]]
+                                parent_entry = inv.get_entry(text_key[0])
                             except (KeyError, errors.NoSuchId):
                                 parent_entry = None
                             if parent_entry is not None:
@@ -2610,7 +2610,7 @@
                 for file_key in list(texts_possibly_new_in_tree):
                     file_id, file_revision = file_key
                     try:
-                        entry = basis_inv[file_id]
+                        entry = basis_inv.get_entry(file_id)
                     except errors.NoSuchId:
                         continue
                     if entry.revision == file_revision:

=== modified file 'breezy/bzr/workingtree.py'
--- breezy/bzr/workingtree.py	2018-03-24 17:48:04 +0000
+++ breezy/bzr/workingtree.py	2018-03-25 02:37:06 +0000
@@ -331,15 +331,15 @@
         self._inventory_is_modified = True
         # we preserve the root inventory entry object, but
         # unlinkit from the byid index
-        del inv._byid[inv.root.file_id]
+        inv.delete(inv.root.file_id)
         inv.root.file_id = file_id
         # and link it into the index with the new changed id.
         inv._byid[inv.root.file_id] = inv.root
         # and finally update all children to reference the new id.
         # XXX: this should be safe to just look at the root.children
         # list, not the WHOLE INVENTORY.
-        for fid in inv:
-            entry = inv[fid]
+        for fid in inv.iter_all_ids():
+            entry = inv.get_entry(fid)
             if entry.parent_id == orig_root_id:
                 entry.parent_id = inv.root.file_id
 
@@ -744,7 +744,7 @@
             # For unversioned files on win32, we just assume they are not
             # executable
             return False
-        return inv[file_id].executable
+        return inv.get_entry(file_id).executable
 
     def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
         mode = stat_result.st_mode
@@ -753,7 +753,7 @@
     def is_executable(self, path, file_id=None):
         if not self._supports_executable():
             inv, inv_file_id = self._path2inv_file_id(path, file_id)
-            return inv[inv_file_id].executable
+            return inv.get_entry(inv_file_id).executable
         else:
             mode = os.lstat(self.abspath(path)).st_mode
             return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
@@ -985,7 +985,7 @@
             child_inv = inventory.Inventory(root_id=None)
             if file_id is None:
                 file_id = self.path2id(sub_path)
-            new_root = my_inv[file_id]
+            new_root = my_inv.get_entry(file_id)
             my_inv.remove_recursive_id(file_id)
             new_root.parent_id = None
             child_inv.add(new_root)
@@ -1061,7 +1061,7 @@
                     # absolute path
                     fap = from_dir_abspath + '/' + f
 
-                    dir_ie = inv[from_dir_id]
+                    dir_ie = inv.get_entry(from_dir_id)
                     if dir_ie.kind == 'directory':
                         f_ie = dir_ie.children.get(f)
                     else:
@@ -1178,7 +1178,7 @@
                 raise errors.BzrMoveFailedError(
                         '', to_dir, errors.NotVersionedError(path=to_dir))
 
-            to_dir_ie = to_inv[to_dir_id]
+            to_dir_ie = to_inv.get_entry(to_dir_id)
             if to_dir_ie.kind != 'directory':
                 raise errors.BzrMoveFailedError(
                         '', to_dir, errors.NotADirectory(to_abs))
@@ -1191,7 +1191,7 @@
                     raise errors.BzrMoveFailedError(from_rel, to_dir,
                         errors.NotVersionedError(path=from_rel))
 
-                from_entry = from_inv[from_id]
+                from_entry = from_inv.get_entry(from_id)
                 from_parent_id = from_entry.parent_id
                 to_rel = osutils.pathjoin(to_dir, from_tail)
                 rename_entry = InventoryWorkingTree._RenameEntry(
@@ -1258,11 +1258,11 @@
                         from_rel, to_rel,
                         errors.NotVersionedError(path=from_rel))
                 # put entry back in the inventory so we can rename it
-                from_entry = basis_tree.root_inventory[from_id].copy()
+                from_entry = basis_tree.root_inventory.get_entry(from_id).copy()
                 from_inv.add(from_entry)
             else:
                 from_inv, from_inv_id = self._unpack_file_id(from_id)
-                from_entry = from_inv[from_inv_id]
+                from_entry = from_inv.get_entry(from_inv_id)
             from_parent_id = from_entry.parent_id
             to_dir, to_tail = os.path.split(to_rel)
             to_inv, to_dir_id = self._path2inv_file_id(to_dir)
@@ -1464,7 +1464,7 @@
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
         if inv_file_id is None:
             raise errors.NoSuchFile(self, path)
-        return inv[inv_file_id].kind
+        return inv.get_entry(inv_file_id).kind
 
     def extras(self):
         """Yield all unversioned files in this WorkingTree.
@@ -1658,7 +1658,7 @@
             else:
                 relroot = ""
             # FIXME: stash the node in pending
-            entry = inv[top_id]
+            entry = inv.get_entry(top_id)
             if entry.kind == 'directory':
                 for name, child in entry.sorted_children():
                     dirblock.append((relroot + name, name, child.kind, None,

=== modified file 'breezy/bzr/workingtree_4.py'
--- breezy/bzr/workingtree_4.py	2018-03-24 17:48:04 +0000
+++ breezy/bzr/workingtree_4.py	2018-03-25 02:37:06 +0000
@@ -693,7 +693,7 @@
                 update_inventory = True
                 inv = self.root_inventory
                 to_dir_id = to_entry[0][2]
-                to_dir_ie = inv[to_dir_id]
+                to_dir_ie = inv.get_entry(to_dir_id)
             else:
                 update_inventory = False
 
@@ -782,7 +782,7 @@
                     # to rollback
                     if update_inventory:
                         # rename the entry
-                        from_entry = inv[from_id]
+                        from_entry = inv.get_entry(from_id)
                         current_parent = from_entry.parent_id
                         inv.rename(from_id, to_dir_id, from_tail)
                         rollbacks.add_cleanup(
@@ -1885,7 +1885,7 @@
     def get_file_revision(self, path, file_id=None):
         with self.lock_read():
             inv, inv_file_id = self._path2inv_file_id(path, file_id)
-            return inv[inv_file_id].revision
+            return inv.get_entry(inv_file_id).revision
 
     def get_file(self, path, file_id=None):
         return BytesIO(self.get_file_text(path, file_id))
@@ -1893,7 +1893,7 @@
     def get_file_size(self, path, file_id=None):
         """See Tree.get_file_size"""
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
-        return inv[inv_file_id].text_size
+        return inv.get_entry(inv_file_id).text_size
 
     def get_file_text(self, path, file_id=None):
         content = None
@@ -1911,7 +1911,7 @@
 
     def get_reference_revision(self, path, file_id=None):
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
-        return inv[inv_file_id].reference_revision
+        return inv.get_entry(inv_file_id).reference_revision
 
     def iter_files_bytes(self, desired_files):
         """See Tree.iter_files_bytes.
@@ -1976,7 +1976,7 @@
         inv, inv_file_id = self._path2inv_file_id(path)
         if inv_file_id is None:
             return ('missing', None, None, None)
-        entry = inv[inv_file_id]
+        entry = inv.get_entry(inv_file_id)
         kind = entry.kind
         if kind == 'file':
             return (kind, entry.text_size, entry.executable, entry.text_sha1)
@@ -1987,7 +1987,7 @@
 
     def is_executable(self, path, file_id=None):
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
-        ie = inv[inv_file_id]
+        ie = inv.get_entry(inv_file_id)
         if ie.kind != "file":
             return False
         return ie.executable
@@ -2081,7 +2081,7 @@
             else:
                 relroot = ""
             # FIXME: stash the node in pending
-            entry = inv[file_id]
+            entry = inv.get_entry(file_id)
             for name, child in entry.sorted_children():
                 toppath = relroot + name
                 dirblock.append((toppath, name, child.kind, None,

=== modified file 'breezy/merge.py'
--- breezy/merge.py	2018-03-24 18:22:08 +0000
+++ breezy/merge.py	2018-03-25 02:37:06 +0000
@@ -956,7 +956,7 @@
                     lca_paths.append(path)
 
             try:
-                base_ie = base_inventory[file_id]
+                base_ie = base_inventory.get_entry(file_id)
             except errors.NoSuchId:
                 base_ie = _none_entry
                 base_path = None
@@ -964,7 +964,7 @@
                 base_path = self.base_tree.id2path(file_id)
 
             try:
-                this_ie = this_inventory[file_id]
+                this_ie = this_inventory.get_entry(file_id)
             except errors.NoSuchId:
                 this_ie = _none_entry
                 this_path = None
@@ -1193,7 +1193,7 @@
     def merge_names(self, file_id):
         def get_entry(tree):
             try:
-                return tree.root_inventory[file_id]
+                return tree.root_inventory.get_entry(file_id)
             except errors.NoSuchId:
                 return None
         this_entry = get_entry(self.this_tree)
@@ -1894,7 +1894,7 @@
             # XXX: The error would be clearer if it gave the URL of the source
             # branch, but we don't have a reference to that here.
             raise PathNotInTree(self._source_subpath, "Source tree")
-        subdir = other_inv[subdir_id]
+        subdir = other_inv.get_entry(subdir_id)
         parent_in_target = osutils.dirname(self._target_subdir)
         target_id = self.this_tree.path2id(parent_in_target)
         if target_id is None:

=== modified file 'breezy/plugins/fastimport/bzr_commit_handler.py'
--- breezy/plugins/fastimport/bzr_commit_handler.py	2018-03-24 23:49:53 +0000
+++ breezy/plugins/fastimport/bzr_commit_handler.py	2018-03-25 02:37:06 +0000
@@ -375,7 +375,7 @@
             return
         # Record it
         try:
-            old_ie = inv[file_id]
+            old_ie = inv.get_entry(file_id)
         except errors.NoSuchId:
             try:
                 self.record_new(path, ie)
@@ -438,7 +438,7 @@
                 raise KeyError
             if file_id is None:
                 raise KeyError
-            result = inv[file_id]
+            result = inv.get_entry(file_id)
             # dirname must be a directory for us to return it
             if result.kind == 'directory':
                 self.directory_entries[dirname] = result
@@ -459,7 +459,7 @@
                 self.mutter("ignoring delete of %s as not in inventory", path)
                 return
             try:
-                ie = inv[file_id]
+                ie = inv.get_entry(file_id)
             except errors.NoSuchId:
                 self.mutter("ignoring delete of %s as not in inventory", path)
                 return
@@ -479,7 +479,7 @@
                 self.warning("ignoring copy of %s to %s - source does not exist",
                     src_path, dest_path)
                 return
-            ie = inv[file_id]
+            ie = inv.get_entry(file_id)
         kind = ie.kind
         if kind == 'file':
             if newly_changed:
@@ -509,11 +509,11 @@
                 "ignoring rename of %s to %s - old path does not exist" %
                 (old_path, new_path))
             return
-        ie = inv[file_id]
+        ie = inv.get_entry(file_id)
         rev_id = ie.revision
         new_file_id = inv.path2id(new_path)
         if new_file_id is not None:
-            self.record_delete(new_path, inv[new_file_id])
+            self.record_delete(new_path, inv.get_entry(new_file_id))
         self.record_rename(old_path, new_path, file_id, ie)
 
         # The revision-id for this entry will be/has been updated and
@@ -713,7 +713,7 @@
             file_id = new_inv.path2id(dir)
             if file_id is None:
                 continue
-            ie = new_inv[file_id]
+            ie = new_inv.get_entry(file_id)
             if ie.kind != 'directory':
                 continue
             if len(ie.children) == 0:
@@ -734,7 +734,7 @@
         else:
             new_inv = inventory.Inventory(revision_id=self.revision_id)
             # This is set in the delta so remove it to prevent a duplicate
-            del new_inv[inventory.ROOT_ID]
+            new_inv.delete(inventory.ROOT_ID)
             try:
                 new_inv.apply_delta(delta)
             except errors.InconsistentDelta:

=== modified file 'breezy/plugins/fastimport/revision_store.py'
--- breezy/plugins/fastimport/revision_store.py	2018-03-10 13:56:26 +0000
+++ breezy/plugins/fastimport/revision_store.py	2018-03-25 02:37:06 +0000
@@ -79,7 +79,7 @@
         except KeyError:
             # The content wasn't shown as 'new'. Just validate this fact
             assert file_id not in self._new_info_by_id
-            old_ie = self._basis_inv[file_id]
+            old_ie = self._basis_inv.get_entry(file_id)
             old_text_key = (file_id, old_ie.revision)
             stream = self._repo.texts.get_record_stream([old_text_key],
                                                         'unordered', True)
@@ -91,7 +91,7 @@
         if file_id in self._new_info_by_id:
             ie = self._new_info_by_id[file_id][1]
             return ie.symlink_target
-        return self._basis_inv[file_id].symlink_target
+        return self._basis_inv.get_entry(file_id).symlink_target
 
     def get_reference_revision(self, path, file_id=None):
         raise NotImplementedError(_TreeShim.get_reference_revision)
@@ -114,7 +114,7 @@
             # Since the *very* common case is that the file already exists, it
             # probably is better to optimize for that
             try:
-                old_ie = basis_inv[file_id]
+                old_ie = basis_inv.get_entry(file_id)
             except errors.NoSuchId:
                 old_ie = None
                 if ie is None:
@@ -281,12 +281,12 @@
         heads = []
         for inv in self._rev_parent_invs:
             try:
-                old_rev = inv[ie.file_id].revision
+                old_rev = inv.get_entry(ie.file_id).revision
             except errors.NoSuchId:
                 pass
             else:
                 if old_rev in head_set:
-                    rev_id = inv[ie.file_id].revision
+                    rev_id = inv.get_entry(ie.file_id).revision
                     heads.append(rev_id)
                     head_set.remove(rev_id)
 
@@ -511,7 +511,7 @@
             else:
                 new_inv = inventory.Inventory(revision_id=revision_id)
                 # This is set in the delta so remove it to prevent a duplicate
-                del new_inv[inventory.ROOT_ID]
+                new_inv.delete(inventory.ROOT_ID)
                 new_inv.apply_delta(inv_delta)
             validator = self.repo.add_inventory(revision_id, new_inv, parents)
         return validator, new_inv

=== modified file 'breezy/plugins/repodebug/file_refs.py'
--- breezy/plugins/repodebug/file_refs.py	2017-09-07 08:21:29 +0000
+++ breezy/plugins/repodebug/file_refs.py	2018-03-25 02:37:06 +0000
@@ -42,7 +42,7 @@
         # print len(all_invs)
         for inv in repo.iter_inventories(all_invs, 'unordered'):
             try:
-                entry = inv[file_id]
+                entry = inv.get_entry(file_id)
             except errors.NoSuchId:
                 # This file doesn't even appear in this inv.
                 continue

=== modified file 'breezy/tests/per_interrepository/test_fetch.py'
--- breezy/tests/per_interrepository/test_fetch.py	2017-11-24 09:25:13 +0000
+++ breezy/tests/per_interrepository/test_fetch.py	2018-03-25 02:37:06 +0000
@@ -498,7 +498,7 @@
         source.lock_write()
         self.addCleanup(source.unlock)
         source.start_write_group()
-        inv['id'].revision = 'b'
+        inv.get_entry('id').revision = 'b'
         inv.revision_id = 'b'
         sha1 = source.add_inventory('b', inv, ['a'])
         rev = Revision(timestamp=0,

=== modified file 'breezy/tests/per_intertree/test_compare.py'
--- breezy/tests/per_intertree/test_compare.py	2018-03-24 23:49:53 +0000
+++ breezy/tests/per_intertree/test_compare.py	2018-03-25 02:37:06 +0000
@@ -590,7 +590,7 @@
             (from_basename, to_basename), (kind, None), (False, False))
 
     def deleted(self, tree, file_id):
-        entry = tree.root_inventory[file_id]
+        entry = tree.root_inventory.get_entry(file_id)
         path = tree.id2path(file_id)
         return (file_id, (path, None), True, (True, False), (entry.parent_id, None),
                 (entry.name, None), (entry.kind, None),

=== modified file 'breezy/tests/per_inventory/basics.py'
--- breezy/tests/per_inventory/basics.py	2018-02-17 00:06:35 +0000
+++ breezy/tests/per_inventory/basics.py	2018-03-25 02:37:06 +0000
@@ -107,7 +107,7 @@
             (None, "a", "a-id", self.make_file('a-id', 'a', 'tree-root')),
             ], 'new-rev-1')
         self.assertEqual('a', inv.id2path('a-id'))
-        a_ie = inv['a-id']
+        a_ie = inv.get_entry('a-id')
         b_ie = self.make_file(a_ie.file_id, "b", a_ie.parent_id)
         inv = inv.create_by_apply_delta([("a", "b", "a-id", b_ie)], 'new-rev-2')
         self.assertEqual("b", inv.id2path('a-id'))
@@ -128,7 +128,7 @@
         inv = self.make_init_inventory()
         self.assertTrue(inv.is_root('tree-root'))
         self.assertFalse(inv.is_root('booga'))
-        ie = inv['tree-root'].copy()
+        ie = inv.get_entry('tree-root').copy()
         ie.file_id = 'booga'
         inv = inv.create_by_apply_delta([("", None, "tree-root", None),
                                          (None, "", "booga", ie)], 'new-rev-2')

=== modified file 'breezy/tests/per_repository_reference/test_add_inventory.py'
--- breezy/tests/per_repository_reference/test_add_inventory.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_repository_reference/test_add_inventory.py	2018-03-25 02:37:06 +0000
@@ -49,7 +49,7 @@
         repo.lock_read()
         self.addCleanup(repo.unlock)
         inv2 = repo.get_inventory(revid)
-        content1 = dict((file_id, inv[file_id]) for file_id in inv)
-        content2 = dict((file_id, inv[file_id]) for file_id in inv2)
+        content1 = dict((file_id, inv.get_entry(file_id)) for file_id in inv.iter_all_ids())
+        content2 = dict((file_id, inv.get_entry(file_id)) for file_id in inv2.iter_all_ids())
         self.assertEqual(content1, content2)
         self.assertRaises(errors.NoSuchRevision, base.get_inventory, revid)

=== modified file 'breezy/tests/per_repository_vf/test_add_inventory_by_delta.py'
--- breezy/tests/per_repository_vf/test_add_inventory_by_delta.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_repository_vf/test_add_inventory_by_delta.py	2018-03-25 02:37:06 +0000
@@ -73,9 +73,9 @@
         for file_id in deletes:
             delta.append((old.id2path(file_id), None, file_id, None))
         for file_id in adds:
-            delta.append((None, new.id2path(file_id), file_id, new[file_id]))
+            delta.append((None, new.id2path(file_id), file_id, new.get_entry(file_id)))
         for file_id in common:
-            if old[file_id] != new[file_id]:
+            if old.get_entry(file_id) != new.get_entry(file_id):
                 delta.append((old.id2path(file_id), new.id2path(file_id),
                     file_id, new[file_id]))
         return delta

=== modified file 'breezy/tests/per_repository_vf/test_fileid_involved.py'
--- breezy/tests/per_repository_vf/test_fileid_involved.py	2018-03-20 00:30:39 +0000
+++ breezy/tests/per_repository_vf/test_fileid_involved.py	2018-03-25 02:37:06 +0000
@@ -51,7 +51,7 @@
         old_rt = b.repository.revision_tree('A-id')
         new_inv = inventory.mutable_inventory_from_tree(old_rt)
         new_inv.revision_id = 'B-id'
-        new_inv['a-file-id'].revision = 'ghost-id'
+        new_inv.get_entry('a-file-id').revision = 'ghost-id'
         new_rev = _mod_revision.Revision('B-id',
             timestamp=time.time(),
             timezone=0,

=== modified file 'breezy/tests/per_tree/test_tree.py'
--- breezy/tests/per_tree/test_tree.py	2018-03-24 23:49:53 +0000
+++ breezy/tests/per_tree/test_tree.py	2018-03-25 02:37:06 +0000
@@ -107,7 +107,7 @@
         tree = self.create_nested()
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        entry = tree.root_inventory['sub-root']
+        entry = tree.root_inventory.get_entry('sub-root')
         self.assertEqual([(u'subtree', 'sub-root')],
             list(tree.iter_references()))
 

=== modified file 'breezy/tests/per_workingtree/test_nested_specifics.py'
--- breezy/tests/per_workingtree/test_nested_specifics.py	2018-03-22 02:21:11 +0000
+++ breezy/tests/per_workingtree/test_nested_specifics.py	2018-03-25 02:37:06 +0000
@@ -44,7 +44,7 @@
         tree.lock_read()
         self.addCleanup(tree.unlock)
         self.assertEqual('subtree-revision',
-            tree.root_inventory['subtree-id'].reference_revision)
+            tree.root_inventory.get_entry('subtree-id').reference_revision)
 
     def test_extract_while_locked(self):
         tree = self.make_branch_and_tree('.')

=== modified file 'breezy/tests/per_workingtree/test_parents.py'
--- breezy/tests/per_workingtree/test_parents.py	2018-03-24 13:45:31 +0000
+++ breezy/tests/per_workingtree/test_parents.py	2018-03-25 02:37:06 +0000
@@ -419,11 +419,11 @@
         for file_id in deletes:
             delta.append((old.id2path(file_id), None, file_id, None))
         for file_id in adds:
-            delta.append((None, new.id2path(file_id), file_id, new[file_id]))
+            delta.append((None, new.id2path(file_id), file_id, new.get_entry(file_id)))
         for file_id in common:
-            if old[file_id] != new[file_id]:
+            if old.get_entry(file_id) != new.get_entry(file_id):
                 delta.append((old.id2path(file_id), new.id2path(file_id),
-                    file_id, new[file_id]))
+                    file_id, new.get_entry(file_id)))
         return delta
 
     def fake_up_revision(self, tree, revid, shape):
@@ -440,7 +440,7 @@
             def get_file_text(self, path, file_id=None):
                 if file_id is None:
                     file_id = self.path2id(path)
-                ie = self.root_inventory[file_id]
+                ie = self.root_inventory.get_entry(file_id)
                 if ie.kind != "file":
                     return ""
                 return 'a' * ie.text_size

=== modified file 'breezy/tests/test_commit.py'
--- breezy/tests/test_commit.py	2018-03-12 00:47:15 +0000
+++ breezy/tests/test_commit.py	2018-03-25 02:37:06 +0000
@@ -331,9 +331,9 @@
             wt.unlock()
 
         inv = b.repository.get_inventory(r4)
-        eq(inv['hello-id'].revision, r4)
-        eq(inv['a-id'].revision, r1)
-        eq(inv['b-id'].revision, r3)
+        eq(inv.get_entry('hello-id').revision, r4)
+        eq(inv.get_entry('a-id').revision, r1)
+        eq(inv.get_entry('b-id').revision, r3)
 
     def test_removed_commit(self):
         """Commit with a removed file"""
@@ -373,10 +373,10 @@
               ['dirid', 'file1id', 'file2id'])
         wt.commit('dir/file1', specific_files=['dir/file1'], rev_id='1')
         inv = b.repository.get_inventory('1')
-        self.assertEqual('1', inv['dirid'].revision)
-        self.assertEqual('1', inv['file1id'].revision)
+        self.assertEqual('1', inv.get_entry('dirid').revision)
+        self.assertEqual('1', inv.get_entry('file1id').revision)
         # FIXME: This should raise a KeyError I think, rbc20051006
-        self.assertRaises(BzrError, inv.__getitem__, 'file2id')
+        self.assertRaises(BzrError, inv.get_entry, 'file2id')
 
     def test_strict_commit(self):
         """Try and commit with unknown files and strict = True, should fail."""

=== modified file 'breezy/tests/test_dirstate.py'
--- breezy/tests/test_dirstate.py	2017-11-17 03:06:50 +0000
+++ breezy/tests/test_dirstate.py	2018-03-25 02:37:06 +0000
@@ -925,7 +925,7 @@
             for entry in state._iter_entries():
                 values.append(entry[0] + entry[1][0][:1])
             self.assertEqual(expected_result1, values)
-            del inv['b-id']
+            inv.delete('b-id')
             state.set_state_from_inventory(inv)
             values = []
             for entry in state._iter_entries():

=== modified file 'breezy/tests/test_inv.py'
--- breezy/tests/test_inv.py	2018-02-16 19:38:39 +0000
+++ breezy/tests/test_inv.py	2018-03-25 02:37:06 +0000
@@ -314,7 +314,7 @@
         inv.root.file_id = b'some-new-root'
         ie.name = u'file2'
         self.assertEqual(b'some-tree-root', inv2.root.file_id)
-        self.assertEqual(u'hello', inv2[b'hello-id'].name)
+        self.assertEqual(u'hello', inv2.get_entry(b'hello-id').name)
 
     def test_copy_empty(self):
         """Make sure an empty inventory can be copied."""
@@ -611,7 +611,7 @@
         file1.text_sha1 = ''
         delta = [(None, u'path', 'file-id', file1)]
         res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
-        self.assertEqual('file-id', res_inv['file-id'].file_id)
+        self.assertEqual('file-id', res_inv.get_entry('file-id').file_id)
 
     def test_remove_file(self):
         inv = self.get_empty_inventory()
@@ -940,18 +940,18 @@
         inv.revision_id = "revid"
         inv.root.revision = "rootrev"
         inv.add(InventoryFile("fileid", "file", inv.root.file_id))
-        inv["fileid"].revision = "filerev"
-        inv["fileid"].executable = True
-        inv["fileid"].text_sha1 = "ffff"
-        inv["fileid"].text_size = 1
+        inv.get_entry("fileid").revision = "filerev"
+        inv.get_entry("fileid").executable = True
+        inv.get_entry("fileid").text_sha1 = "ffff"
+        inv.get_entry("fileid").text_size = 1
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
         bytes = ''.join(chk_inv.to_lines())
         new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
-        root_entry = new_inv[inv.root.file_id]
+        root_entry = new_inv.get_entry(inv.root.file_id)
         self.assertEqual(None, root_entry._children)
         self.assertEqual({'file'}, set(root_entry.children))
-        file_direct = new_inv["fileid"]
+        file_direct = new_inv.get_entry("fileid")
         file_found = root_entry.children['file']
         self.assertEqual(file_direct.kind, file_found.kind)
         self.assertEqual(file_direct.file_id, file_found.file_id)
@@ -977,20 +977,20 @@
         self.assertEqual(120, p_id_basename._root_node.maximum_size)
         self.assertEqual(2, p_id_basename._root_node._key_width)
 
-    def test___iter__(self):
+    def test_iter_all_ids(self):
         inv = Inventory()
         inv.revision_id = "revid"
         inv.root.revision = "rootrev"
         inv.add(InventoryFile("fileid", "file", inv.root.file_id))
-        inv["fileid"].revision = "filerev"
-        inv["fileid"].executable = True
-        inv["fileid"].text_sha1 = "ffff"
-        inv["fileid"].text_size = 1
+        inv.get_entry("fileid").revision = "filerev"
+        inv.get_entry("fileid").executable = True
+        inv.get_entry("fileid").text_sha1 = "ffff"
+        inv.get_entry("fileid").text_size = 1
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
         bytes = ''.join(chk_inv.to_lines())
         new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
-        fileids = sorted(new_inv.__iter__())
+        fileids = sorted(new_inv.iter_all_ids())
         self.assertEqual([inv.root.file_id, "fileid"], fileids)
 
     def test__len__(self):
@@ -998,29 +998,29 @@
         inv.revision_id = "revid"
         inv.root.revision = "rootrev"
         inv.add(InventoryFile("fileid", "file", inv.root.file_id))
-        inv["fileid"].revision = "filerev"
-        inv["fileid"].executable = True
-        inv["fileid"].text_sha1 = "ffff"
-        inv["fileid"].text_size = 1
+        inv.get_entry("fileid").revision = "filerev"
+        inv.get_entry("fileid").executable = True
+        inv.get_entry("fileid").text_sha1 = "ffff"
+        inv.get_entry("fileid").text_size = 1
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
         self.assertEqual(2, len(chk_inv))
 
-    def test___getitem__(self):
+    def test_get_entry(self):
         inv = Inventory()
         inv.revision_id = b"revid"
         inv.root.revision = b"rootrev"
         inv.add(InventoryFile(b"fileid", u"file", inv.root.file_id))
-        inv[b"fileid"].revision = b"filerev"
-        inv[b"fileid"].executable = True
-        inv[b"fileid"].text_sha1 = b"ffff"
-        inv[b"fileid"].text_size = 1
+        inv.get_entry(b"fileid").revision = b"filerev"
+        inv.get_entry(b"fileid").executable = True
+        inv.get_entry(b"fileid").text_sha1 = b"ffff"
+        inv.get_entry(b"fileid").text_size = 1
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
         data = b''.join(chk_inv.to_lines())
         new_inv = CHKInventory.deserialise(chk_bytes, data, (b"revid",))
-        root_entry = new_inv[inv.root.file_id]
-        file_entry = new_inv[b"fileid"]
+        root_entry = new_inv.get_entry(inv.root.file_id)
+        file_entry = new_inv.get_entry(b"fileid")
         self.assertEqual("directory", root_entry.kind)
         self.assertEqual(inv.root.file_id, root_entry.file_id)
         self.assertEqual(inv.root.parent_id, root_entry.parent_id)
@@ -1034,17 +1034,17 @@
         self.assertEqual(b"ffff", file_entry.text_sha1)
         self.assertEqual(1, file_entry.text_size)
         self.assertEqual(True, file_entry.executable)
-        self.assertRaises(errors.NoSuchId, new_inv.__getitem__, 'missing')
+        self.assertRaises(errors.NoSuchId, new_inv.get_entry, 'missing')
 
     def test_has_id_true(self):
         inv = Inventory()
         inv.revision_id = "revid"
         inv.root.revision = "rootrev"
         inv.add(InventoryFile("fileid", "file", inv.root.file_id))
-        inv["fileid"].revision = "filerev"
-        inv["fileid"].executable = True
-        inv["fileid"].text_sha1 = "ffff"
-        inv["fileid"].text_size = 1
+        inv.get_entry("fileid").revision = "filerev"
+        inv.get_entry("fileid").executable = True
+        inv.get_entry("fileid").text_sha1 = "ffff"
+        inv.get_entry("fileid").text_size = 1
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
         self.assertTrue(chk_inv.has_id('fileid'))
@@ -1066,11 +1066,11 @@
         fileentry = InventoryFile("fileid", "file", "dirid")
         inv.add(direntry)
         inv.add(fileentry)
-        inv["fileid"].revision = "filerev"
-        inv["fileid"].executable = True
-        inv["fileid"].text_sha1 = "ffff"
-        inv["fileid"].text_size = 1
-        inv["dirid"].revision = "filerev"
+        inv.get_entry("fileid").revision = "filerev"
+        inv.get_entry("fileid").executable = True
+        inv.get_entry("fileid").text_sha1 = "ffff"
+        inv.get_entry("fileid").text_size = 1
+        inv.get_entry("dirid").revision = "filerev"
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
         bytes = ''.join(chk_inv.to_lines())
@@ -1087,11 +1087,11 @@
         fileentry = InventoryFile("fileid", "file", "dirid")
         inv.add(direntry)
         inv.add(fileentry)
-        inv["fileid"].revision = "filerev"
-        inv["fileid"].executable = True
-        inv["fileid"].text_sha1 = "ffff"
-        inv["fileid"].text_size = 1
-        inv["dirid"].revision = "filerev"
+        inv.get_entry("fileid").revision = "filerev"
+        inv.get_entry("fileid").executable = True
+        inv.get_entry("fileid").text_sha1 = "ffff"
+        inv.get_entry("fileid").text_size = 1
+        inv.get_entry("dirid").revision = "filerev"
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
         bytes = ''.join(chk_inv.to_lines())
@@ -1172,18 +1172,18 @@
         inv.revision_id = "revid"
         inv.root.revision = "rootrev"
         inv.add(InventoryFile("fileid", "file", inv.root.file_id))
-        inv["fileid"].revision = "filerev"
-        inv["fileid"].executable = True
-        inv["fileid"].text_sha1 = "ffff"
-        inv["fileid"].text_size = 1
+        inv.get_entry("fileid").revision = "filerev"
+        inv.get_entry("fileid").executable = True
+        inv.get_entry("fileid").text_sha1 = "ffff"
+        inv.get_entry("fileid").text_size = 1
         inv2 = Inventory()
         inv2.revision_id = "revid2"
         inv2.root.revision = "rootrev"
         inv2.add(InventoryFile("fileid", "file", inv.root.file_id))
-        inv2["fileid"].revision = "filerev2"
-        inv2["fileid"].executable = False
-        inv2["fileid"].text_sha1 = "bbbb"
-        inv2["fileid"].text_size = 2
+        inv2.get_entry("fileid").revision = "filerev2"
+        inv2.get_entry("fileid").executable = False
+        inv2.get_entry("fileid").text_sha1 = "bbbb"
+        inv2.get_entry("fileid").text_size = 2
         # get fresh objects.
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
@@ -1202,10 +1202,10 @@
         inv.revision_id = "revid"
         inv.root.revision = "rootrev"
         inv.add(InventoryFile("fileid", "file", inv.root.file_id))
-        inv["fileid"].revision = "filerev"
-        inv["fileid"].executable = True
-        inv["fileid"].text_sha1 = "ffff"
-        inv["fileid"].text_size = 1
+        inv.get_entry("fileid").revision = "filerev"
+        inv.get_entry("fileid").executable = True
+        inv.get_entry("fileid").text_sha1 = "ffff"
+        inv.get_entry("fileid").text_size = 1
         # get fresh objects.
         chk_bytes = self.get_chk_bytes()
         tmp_inv = CHKInventory.from_inventory(chk_bytes, inv)
@@ -1327,14 +1327,14 @@
         inv.root.revision = "rootrev"
         root_id = inv.root.file_id
         inv.add(InventoryFile("fileid", u'f\xefle', root_id))
-        inv["fileid"].revision = "filerev"
-        inv["fileid"].text_sha1 = "ffff"
-        inv["fileid"].text_size = 0
+        inv.get_entry("fileid").revision = "filerev"
+        inv.get_entry("fileid").text_sha1 = "ffff"
+        inv.get_entry("fileid").text_size = 0
         inv.add(InventoryDirectory("dirid", u'dir-\N{EURO SIGN}', root_id))
         inv.add(InventoryFile("childid", u'ch\xefld', "dirid"))
-        inv["childid"].revision = "filerev"
-        inv["childid"].text_sha1 = "ffff"
-        inv["childid"].text_size = 0
+        inv.get_entry("childid").revision = "filerev"
+        inv.get_entry("childid").text_sha1 = "ffff"
+        inv.get_entry("childid").text_size = 0
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
         bytes = ''.join(chk_inv.to_lines())
@@ -1360,16 +1360,16 @@
         inv.root.revision = "rootrev"
         root_id = inv.root.file_id
         inv.add(InventoryFile("fileid", "file", root_id))
-        inv["fileid"].revision = "filerev"
-        inv["fileid"].executable = True
-        inv["fileid"].text_sha1 = "ffff"
-        inv["fileid"].text_size = 1
+        inv.get_entry("fileid").revision = "filerev"
+        inv.get_entry("fileid").executable = True
+        inv.get_entry("fileid").text_sha1 = "ffff"
+        inv.get_entry("fileid").text_size = 1
         inv.add(InventoryDirectory("dirid", "dir", root_id))
         inv.add(InventoryFile("childid", "child", "dirid"))
-        inv["childid"].revision = "filerev"
-        inv["childid"].executable = False
-        inv["childid"].text_sha1 = "dddd"
-        inv["childid"].text_size = 1
+        inv.get_entry("childid").revision = "filerev"
+        inv.get_entry("childid").executable = False
+        inv.get_entry("childid").text_sha1 = "dddd"
+        inv.get_entry("childid").text_size = 1
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
         bytes = ''.join(chk_inv.to_lines())
@@ -1388,7 +1388,7 @@
 
     def test__preload_handles_partially_evaluated_inventory(self):
         new_inv = self.make_basic_utf8_inventory()
-        ie = new_inv[new_inv.root_id]
+        ie = new_inv.get_entry(new_inv.root_id)
         self.assertIs(None, ie._children)
         self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
                          sorted(ie.children.keys()))
@@ -1399,7 +1399,7 @@
         # No change
         self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
                          sorted(ie._children.keys()))
-        ie_dir = new_inv["dirid"]
+        ie_dir = new_inv.get_entry("dirid")
         self.assertEqual([u'ch\xefld'],
                          sorted(ie_dir._children.keys()))
 
@@ -1574,9 +1574,9 @@
         inv = mutable_inventory_from_tree(tree)
         self.assertEqual(revid, inv.revision_id)
         self.assertEqual(2, len(inv))
-        self.assertEqual("a", inv['thefileid'].name)
+        self.assertEqual("a", inv.get_entry('thefileid').name)
         # The inventory should be mutable and independent of
         # the original tree
-        self.assertFalse(tree.root_inventory['thefileid'].executable)
-        inv['thefileid'].executable = True
-        self.assertFalse(tree.root_inventory['thefileid'].executable)
+        self.assertFalse(tree.root_inventory.get_entry('thefileid').executable)
+        inv.get_entry('thefileid').executable = True
+        self.assertFalse(tree.root_inventory.get_entry('thefileid').executable)

=== modified file 'breezy/tests/test_revisiontree.py'
--- breezy/tests/test_revisiontree.py	2017-11-24 09:25:13 +0000
+++ breezy/tests/test_revisiontree.py	2018-03-25 02:37:06 +0000
@@ -76,6 +76,6 @@
 
     def test_get_file_mtime_ghost(self):
         path = next(iter(self.rev_tree.all_versioned_paths()))
-        self.rev_tree.root_inventory[self.rev_tree.path2id(path)].revision = 'ghostrev'
+        self.rev_tree.root_inventory.get_entry(self.rev_tree.path2id(path)).revision = 'ghostrev'
         self.assertRaises(FileTimestampUnavailable, 
             self.rev_tree.get_file_mtime, path)

=== modified file 'breezy/tests/test_transform.py'
--- breezy/tests/test_transform.py	2018-03-24 02:22:27 +0000
+++ breezy/tests/test_transform.py	2018-03-25 02:37:06 +0000
@@ -400,7 +400,7 @@
         tree.lock_read()
         self.addCleanup(tree.unlock)
         self.assertEqual('subtree-revision',
-                         tree.root_inventory['subtree-id'].reference_revision)
+                         tree.root_inventory.get_entry('subtree-id').reference_revision)
 
     def test_conflicts(self):
         transform, root = self.get_transform()

=== modified file 'breezy/tests/test_xml.py'
--- breezy/tests/test_xml.py	2018-02-17 02:02:38 +0000
+++ breezy/tests/test_xml.py	2018-03-25 02:37:06 +0000
@@ -227,11 +227,11 @@
         inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
         eq = self.assertEqual
         eq(len(inv), 4)
-        ie = inv['bar-20050824000535-6bc48cfad47ed134']
+        ie = inv.get_entry('bar-20050824000535-6bc48cfad47ed134')
         eq(ie.kind, 'file')
         eq(ie.revision, 'mbp@foo-00')
         eq(ie.name, 'bar')
-        eq(inv[ie.parent_id].kind, 'directory')
+        eq(inv.get_entry(ie.parent_id).kind, 'directory')
 
     def test_unpack_basis_inventory_5(self):
         """Unpack canned new-style inventory"""
@@ -240,11 +240,11 @@
         eq = self.assertEqual
         eq(len(inv), 4)
         eq(inv.revision_id, '[e-mail]-20050905063503-43948f59fa127d92')
-        ie = inv['bar-20050824000535-6bc48cfad47ed134']
+        ie = inv.get_entry('bar-20050824000535-6bc48cfad47ed134')
         eq(ie.kind, 'file')
         eq(ie.revision, 'mbp@foo-00')
         eq(ie.name, 'bar')
-        eq(inv[ie.parent_id].kind, 'directory')
+        eq(inv.get_entry(ie.parent_id).kind, 'directory')
 
     def test_unpack_inventory_5a(self):
         inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
@@ -357,13 +357,13 @@
         inv.add(inventory.InventoryDirectory('dir-id', 'dir',
                                              'tree-root-321'))
         inv.add(inventory.InventoryLink('link-id', 'link', 'tree-root-321'))
-        inv['tree-root-321'].revision = 'rev_outer'
-        inv['dir-id'].revision = 'rev_outer'
-        inv['file-id'].revision = 'rev_outer'
-        inv['file-id'].text_sha1 = 'A'
-        inv['file-id'].text_size = 1
-        inv['link-id'].revision = 'rev_outer'
-        inv['link-id'].symlink_target = 'a'
+        inv.get_entry('tree-root-321').revision = 'rev_outer'
+        inv.get_entry('dir-id').revision = 'rev_outer'
+        inv.get_entry('file-id').revision = 'rev_outer'
+        inv.get_entry('file-id').text_sha1 = 'A'
+        inv.get_entry('file-id').text_size = 1
+        inv.get_entry('link-id').revision = 'rev_outer'
+        inv.get_entry('link-id').symlink_target = 'a'
         return inv
 
     def test_roundtrip_inventory_v7(self):
@@ -377,7 +377,7 @@
         inv2 = xml7.serializer_v7.read_inventory_from_string(txt)
         self.assertEqual(5, len(inv2))
         for path, ie in inv.iter_entries():
-            self.assertEqual(ie, inv2[ie.file_id])
+            self.assertEqual(ie, inv2.get_entry(ie.file_id))
 
     def test_roundtrip_inventory_v6(self):
         inv = self.get_sample_inventory()
@@ -388,7 +388,7 @@
         inv2 = xml6.serializer_v6.read_inventory_from_string(txt)
         self.assertEqual(4, len(inv2))
         for path, ie in inv.iter_entries():
-            self.assertEqual(ie, inv2[ie.file_id])
+            self.assertEqual(ie, inv2.get_entry(ie.file_id))
 
     def test_wrong_format_v7(self):
         """Can't accidentally open a file with wrong serializer"""
@@ -415,9 +415,9 @@
         lines = s_v7.write_inventory_to_lines(inv)
         self.assertEqual(breezy.osutils.split_lines(txt), lines)
         inv2 = s_v7.read_inventory_from_string(txt)
-        self.assertEqual('tree-root-321', inv2['nested-id'].parent_id)
-        self.assertEqual('rev-outer', inv2['nested-id'].revision)
-        self.assertEqual('rev-inner', inv2['nested-id'].reference_revision)
+        self.assertEqual('tree-root-321', inv2.get_entry('nested-id').parent_id)
+        self.assertEqual('rev-outer', inv2.get_entry('nested-id').revision)
+        self.assertEqual('rev-inner', inv2.get_entry('nested-id').reference_revision)
 
     def test_roundtrip_inventory_v8(self):
         inv = self.get_sample_inventory()
@@ -425,7 +425,7 @@
         inv2 = xml8.serializer_v8.read_inventory_from_string(txt)
         self.assertEqual(4, len(inv2))
         for path, ie in inv.iter_entries():
-            self.assertEqual(ie, inv2[ie.file_id])
+            self.assertEqual(ie, inv2.get_entry(ie.file_id))
 
     def test_inventory_text_v8(self):
         inv = self.get_sample_inventory()

=== modified file 'breezy/tree.py'
--- breezy/tree.py	2018-03-24 10:24:48 +0000
+++ breezy/tree.py	2018-03-25 02:37:06 +0000
@@ -1186,7 +1186,7 @@
             return (None, None)
         else:
             self._out_of_order_processed.add(file_id)
-            cur_ie = other_tree.root_inventory[file_id]
+            cur_ie = other_tree.root_inventory.get_entry(file_id)
             return (cur_path, cur_ie)
 
     def iter_all(self):