itemtree: Rename _Item to Item

Author: kamilburda

export_layers/exporter.py

@@ -69,7 +69,7 @@ class LayerExporter(object):
     Setting this to `False` allows e.g. the export procedure to export multiple
     layers at once instead of each layer individually.
   
-  * `current_item` (read-only) - An `itemtree._Item` instance currently being
+  * `current_item` (read-only) - An `itemtree.Item` instance currently being
     processed.
   
   * `current_raw_item` - Raw item (`gimp.Layer`) currently being processed.
@@ -84,10 +84,10 @@ class LayerExporter(object):
   
   * `process_names` (read-only) - See `export()`.
   
-  * `tagged_items` - Dictionary of (tag name, `itemtree._Item`) pairs containing
+  * `tagged_items` - Dictionary of (tag name, `itemtree.Item`) pairs containing
     tagged items.
   
-  * `inserted_tagged_items` - Dictionary of (tag name, `itemtree._Item`) pairs
+  * `inserted_tagged_items` - Dictionary of (tag name, `itemtree.Item`) pairs
     containing tagged items currently inserted in `current_image`.
   
   * `invoker` - `pygimplib.invoker.Invoker` instance to

export_layers/gui/preview_name.py

@@ -84,7 +84,7 @@ def __init__(
 
     self.is_filtering = False
 
-    # key: `_Item.raw.ID` or (`_Item.raw.ID`, 'folder') instance
+    # key: `Item.raw.ID` or (`Item.raw.ID`, 'folder') instance
     # value: `gtk.TreeIter` instance
     self._tree_iters = collections.defaultdict(pg.utils.return_none_func)
 

export_layers/pygimplib/itemtree.py

@@ -42,7 +42,7 @@ class ItemTree(future.utils.with_metaclass(abc.ABCMeta, object)):
     
     * `VectorTree` for vectors (paths).
   
-  Each item in the tree is an `_Item` instance. Each item contains `gimp.Item`
+  Each item in the tree is an `Item` instance. Each item contains `gimp.Item`
   attributes and additional derived attributes.
   
   Items can be directly accessed via their ID or name. Both ID and name are
@@ -62,7 +62,7 @@ class ItemTree(future.utils.with_metaclass(abc.ABCMeta, object)):
   
   * `name` (read-only) - Optional name of the item tree. The name is currently
     used as an identifier of the persistent source for tags in items. See
-    `_Item.tags` for more information.
+    `Item.tags` for more information.
   
   * `is_filtered` - If `True`, ignore items that do not match the filter
     (`ObjectFilter`) in this object when iterating.
@@ -86,14 +86,14 @@ def __init__(
     self.filter = pgobjectfilter.ObjectFilter(self._filter_match_type)
 
     # Contains all items in the item tree (including item groups).
-    # key: `_Item.raw.ID` or (`_Item.raw.ID`, `FOLDER_KEY`) in case of folders
-    # value: `_Item` instance
+    # key: `Item.raw.ID` or (`Item.raw.ID`, `FOLDER_KEY`) in case of folders
+    # value: `Item` instance
     self._itemtree = collections.OrderedDict()
 
     # key:
-    #  `_Item.orig_name` (derived from `_Item.raw.name`)
-    #   or (`_Item.raw.ID`, `FOLDER_KEY`) in case of folders
-    # value: `_Item` instance
+    #  `Item.orig_name` (derived from `Item.raw.name`)
+    #   or (`Item.raw.ID`, `FOLDER_KEY`) in case of folders
+    # value: `Item` instance
     self._itemtree_names = {}
 
     self._build_tree()
@@ -107,10 +107,10 @@ def name(self):
     return self._name
 
   def __getitem__(self, id_or_name):
-    """Returns an `_Item` object by its ID or original name.
+    """Returns an `Item` object by its ID or original name.
     
-    An item's ID is the `_Item.raw.ID` attribute. An item's original name is the
-    `_Item.orig_name` attribute.
+    An item's ID is the `Item.raw.ID` attribute. An item's original name is the
+    `Item.orig_name` attribute.
     
     To access an item group as a folder, pass a tuple `(ID or name, 'folder')`.
     For example:
@@ -123,9 +123,9 @@ def __getitem__(self, id_or_name):
       return self._itemtree_names[id_or_name]
 
   def __contains__(self, id_or_name):
-    """Returns `True` if an `_Item` object is in the item tree, regardless of
-    filters. Return `False` otherwise. The `_Item` object is specified by its
-    `_Item.raw.ID` attribute or its `orig_name` attribute.
+    """Returns `True` if an `Item` object is in the item tree, regardless of
+    filters. Return `False` otherwise. The `Item` object is specified by its
+    `Item.raw.ID` attribute or its `orig_name` attribute.
     """
     return id_or_name in self._itemtree or id_or_name in self._itemtree_names
 
@@ -148,7 +148,7 @@ def __iter__(self):
     
     Yields:
     
-    * `item` - The current `_Item` object.
+    * `item` - The current `Item` object.
     """
     return self.iter(with_folders=False, with_empty_groups=False)
 
@@ -169,7 +169,7 @@ def iter(self, with_folders=True, with_empty_groups=False, filtered=True):
     
     Yields:
     
-    * `item` - The current `_Item` object.
+    * `item` - The current `Item` object.
     """
     for item in self._itemtree.values():
       should_yield_item = True
@@ -196,7 +196,7 @@ def iter_all(self):
     
     Yields:
     
-    * `item` - The current `_Item` object.
+    * `item` - The current `Item` object.
     """
     for item in self._itemtree.values():
       yield item
@@ -258,10 +258,10 @@ def _build_tree(self):
     child_items = []
     for raw_item in self._get_children_from_image(self._image):
       if self._is_group(raw_item):
-        child_items.append(_Item(raw_item, TYPE_FOLDER, [], [], None, None, self._name))
-        child_items.append(_Item(raw_item, TYPE_GROUP, [], [], None, None, self._name))
+        child_items.append(Item(raw_item, TYPE_FOLDER, [], [], None, None, self._name))
+        child_items.append(Item(raw_item, TYPE_GROUP, [], [], None, None, self._name))
       else:
-        child_items.append(_Item(raw_item, TYPE_ITEM, [], [], None, None, self._name))
+        child_items.append(Item(raw_item, TYPE_ITEM, [], [], None, None, self._name))
 
     item_tree = child_items
     item_list = []
@@ -281,14 +281,14 @@ def _build_tree(self):
         for raw_item in self._get_children_from_raw_item(item.raw):
           if self._is_group(raw_item):
             child_items.append(
-              _Item(raw_item, TYPE_FOLDER, parents_for_child, [], None, None, self._name))
+              Item(raw_item, TYPE_FOLDER, parents_for_child, [], None, None, self._name))
             child_items.append(
-              _Item(raw_item, TYPE_GROUP, parents_for_child, [], None, None, self._name))
+              Item(raw_item, TYPE_GROUP, parents_for_child, [], None, None, self._name))
           else:
             child_items.append(
-              _Item(raw_item, TYPE_ITEM, parents_for_child, [], None, None, self._name))
+              Item(raw_item, TYPE_ITEM, parents_for_child, [], None, None, self._name))
 
-        # We break the convention here and access a private attribute from `_Item`.
+        # We break the convention here and access a private attribute from `Item`.
         item._orig_children = child_items
         item.children = child_items
 
@@ -299,7 +299,7 @@ def _build_tree(self):
         self._itemtree_names[item.orig_name] = item
 
     for i in range(1, len(item_list) - 1):
-      # We break the convention here and access private attributes from `_Item`.
+      # We break the convention here and access private attributes from `Item`.
       item_list[i]._prev_item = item_list[i - 1]
       item_list[i]._next_item = item_list[i + 1]
 
@@ -351,7 +351,7 @@ def _get_children_from_image(self, image):
 
 
 @future.utils.python_2_unicode_compatible
-class _Item(object):
+class Item(object):
   """Wrapper for a `gimp.Item` object containing additional attributes.
   
   Note that the attributes will not be up to date if changes were made to the
@@ -364,29 +364,29 @@ class _Item(object):
   * `type` (read-only) - Item type - one of the following:
       * `TYPE_ITEM` - regular item
       * `TYPE_GROUP` - item group (item whose raw `gimp.Item` is a group with
-        children; this `_Item` has no children and acts as a regular item)
+        children; this `Item` has no children and acts as a regular item)
       * `TYPE_FOLDER` - item containing children (raw item is a group with
         children)
   
-  * `parents` - List of `_Item` parents for this item, sorted from the topmost
+  * `parents` - List of `Item` parents for this item, sorted from the topmost
     parent to the bottommost (immediate) parent.
   
-  * `children` - List of `_Item` children for this item.
+  * `children` - List of `Item` children for this item.
   
   * `depth` (read-only) - Integer indicating the depth of the item in the item
     tree. 0 means the item is at the top level. The greater the depth, the lower
     the item is in the item tree.
   
-  * `parent` (read-only) - Immediate `_Item` parent of this object.
+  * `parent` (read-only) - Immediate `Item` parent of this object.
     If this object has no parent, return `None`.
   
   * `name` - Item name as a string, initially equal to `orig_name`. Modify this
      attribute instead of `gimp.Item.name` to avoid modifying the original item.
   
-  * `prev` - Previous `_Item` in the `ItemTree`, or `None` if there is no
+  * `prev` - Previous `Item` in the `ItemTree`, or `None` if there is no
     previous item.
   
-  * `next` - Next `_Item` in the `ItemTree`, or `None` if there is no next item.
+  * `next` - Next `Item` in the `ItemTree`, or `None` if there is no next item.
   
   * `tags` - Set of arbitrary strings attached to the item. Tags can be used for
     a variety of purposes, such as special handling of items with specific tags.
@@ -395,7 +395,7 @@ class _Item(object):
     `tags_source_name` attribute.
   
   * `orig_name` (read-only) - Original `gimp.Item.name` as a string. This
-    attribute may be used to access `_Item`s in `ItemTree`.
+    attribute may be used to access `Item`s in `ItemTree`.
   
   * `orig_parents` (read-only) - Initial `parents` of this item.
   

export_layers/pygimplib/tests/test_itemtree.py

@@ -258,20 +258,20 @@ def setUp(self):
     self.GROUP = pgitemtree.TYPE_GROUP
     self.FOLDER = pgitemtree.TYPE_FOLDER
 
-    self.item = pgitemtree._Item(
+    self.item = pgitemtree.Item(
       stubs_gimp.LayerStub('main-background.jpg'), self.ITEM)
 
   def test_str(self):
-    self.assertEqual(str(self.item), '<_Item "main-background.jpg">')
+    self.assertEqual(str(self.item), '<Item "main-background.jpg">')
 
     self.item.name = 'main-background'
 
-    self.assertEqual(str(self.item), '<_Item "main-background.jpg">')
+    self.assertEqual(str(self.item), '<Item "main-background.jpg">')
 
   def test_repr(self):
     self.assertEqual(
       repr(self.item),
-      '<pygimplib.itemtree._Item "main-background.jpg {}" at {}>'.format(
+      '<pygimplib.itemtree.Item "main-background.jpg {}" at {}>'.format(
         type(self.item.raw),
         hex(id(self.item)).rstrip('L'),
       ),
@@ -356,7 +356,7 @@ def test_initial_tags(self):
     layer.parasite_attach(
       stubs_gimp.ParasiteStub(item_tags_source_name, 0, pickle.dumps(set(['background']))))
 
-    item = pgitemtree._Item(layer, self.ITEM, tags_source_name=item_tags_source_name)
+    item = pgitemtree.Item(layer, self.ITEM, tags_source_name=item_tags_source_name)
     self.assertIn('background', item.tags)
 
   @mock.patch(
@@ -369,7 +369,7 @@ def test_initial_tags_with_invalid_data(self):
     layer.parasite_attach(
       stubs_gimp.ParasiteStub(item_tags_source_name, 0, 'invalid_data'))
 
-    item = pgitemtree._Item(layer, self.ITEM, tags_source_name=item_tags_source_name)
+    item = pgitemtree.Item(layer, self.ITEM, tags_source_name=item_tags_source_name)
     self.assertFalse(item.tags)
 
   @mock.patch(
@@ -383,7 +383,7 @@ def test_initial_tags_for_item_as_folder(self):
     layer.parasite_attach(
       stubs_gimp.ParasiteStub(folder_tags_source_name, 0, pickle.dumps(set(['background']))))
 
-    item = pgitemtree._Item(layer, self.FOLDER, tags_source_name=item_tags_source_name)
+    item = pgitemtree.Item(layer, self.FOLDER, tags_source_name=item_tags_source_name)
     self.assertEqual(item.tags_source_name, folder_tags_source_name)
     self.assertIn('background', item.tags)
 
@@ -398,6 +398,6 @@ def test_initial_tags_for_item_as_folder_unrecognized_source_name(self):
     layer.parasite_attach(
       stubs_gimp.ParasiteStub(item_tags_source_name, 0, pickle.dumps(set(['background']))))
 
-    item = pgitemtree._Item(layer, self.FOLDER, tags_source_name=item_tags_source_name)
+    item = pgitemtree.Item(layer, self.FOLDER, tags_source_name=item_tags_source_name)
     self.assertEqual(item.tags_source_name, folder_tags_source_name)
     self.assertNotIn('background', item.tags)

export_layers/uniquifier.py

@@ -10,35 +10,35 @@
 
 
 class ItemUniquifier(object):
-  """Class renaming `pygimplib.ItemTree._Item` instances to be unique under the
+  """Class renaming `pygimplib.ItemTree.Item` instances to be unique under the
   same parent.
   """
 
   def __init__(self, generator=None):
     self.generator = generator
 
-    # key: `_Item` instance (parent) or None (item tree root)
-    # value: set of `_Item` instances
+    # key: `Item` instance (parent) or None (item tree root)
+    # value: set of `Item` instances
     self._uniquified_items = {}
 
-    # key: `_Item` instance (parent) or None (item tree root)
-    # value: set of `_Item.name` strings
+    # key: `Item` instance (parent) or None (item tree root)
+    # value: set of `Item.name` strings
     self._uniquified_item_names = {}
 
   def uniquify(self, item, position=None):
-    """Renames the `_Item` instance by making it unique among all other `_Item`
-    instances under the same parent `_Item`.
+    """Renames the `Item` instance by making it unique among all other `Item`
+    instances under the same parent `Item`.
     
     To achieve uniquification, a substring in the form of `' (<number>)'` is
     inserted at the end of the item names.
     
-    Calling the method with the same `_Item` instance will have no effect as
+    Calling the method with the same `Item` instance will have no effect as
     that instance will be marked as visited. Call `reset()` to clear cache of
     items that were passed to this function.
     
     Parameters:
     
-    * `item` - `_Item` instance whose `name` attribute will be uniquified.
+    * `item` - `Item` instance whose `name` attribute will be uniquified.
     
     * `position` - Position (index) where a unique substring is inserted into
       the item's name. If `None`, insert the substring at the end of the name