delete method for namedlist/names

Author: jkanche

src/biocutils/named_list.py

@@ -435,6 +435,47 @@ def __iadd__(self, other: list):
         self.extend(other)
         return self
 
+    def safe_delete(self, index: Union[int, str, slice], in_place: bool = False) -> NamedList:
+        """
+        Args:
+            index:
+                An integer index or slice containing position(s) to delete.
+                Alternatively, the name of the value to delete (the first
+                occurrence of the name is used).
+
+            in_place:
+                Whether to modify the current object in place.
+
+        Returns:
+            A ``NamedList`` where the item at ``index`` is removed. This is a
+            new object if ``in_place = False``, otherwise it is a reference to
+            the current object.
+        """
+        if in_place:
+            output = self
+        else:
+            output = self._shallow_copy()
+            output._data = output._data[:]  # Shallow copy of the list
+            if output._names is not None:
+                output._names = output._names.copy()
+
+        if isinstance(index, str):
+            index = _name_to_position(self._names, index)
+
+        del output._data[index]
+        if output._names is not None:
+            output._names.delete(index)
+
+        return output
+
+    def delete(self, index: Union[int, str, slice]):
+        """Alias for :py:meth:`~safe_delete` with ``in_place = True``."""
+        self.safe_delete(index, in_place=True)
+
+    def __delitem__(self, index: Union[int, str, slice]):
+        """Alias for :py:meth:`~delete`."""
+        self.delete(index)
+
     ################################
     #####>>>> Copy methods <<<<#####
     ################################

src/biocutils/names.py

@@ -328,6 +328,35 @@ def __iadd__(self, other: list):
         self.extend(other)
         return self
 
+    def safe_delete(self, index: Union[int, slice], in_place: bool = False) -> Names:
+        """
+        Args:
+            index:
+                Position(s) of the name(s) to delete.
+
+            in_place:
+                Whether to perform this deletion in-place.
+
+        Returns:
+            A ``Names`` object with the deleted name(s). This is a new object
+            if ``in_place = False``, otherwise it is a reference to the current
+            object.
+        """
+        output = self._define_output(in_place)
+        if in_place:
+            output._wipe_reverse_index()
+
+        del output._names[index]
+        return output
+
+    def delete(self, index: Union[int, slice]):
+        """Alias for :py:attr:`~safe_delete` with ``in_place = True``."""
+        self.safe_delete(index, in_place=True)
+
+    def __delitem__(self, index: Union[int, slice]):
+        """Alias for :py:attr:`~delete`."""
+        self.delete(index)
+
     ################################
     #####>>>> Copy methods <<<<#####
     ################################

tests/test_NamedList.py

@@ -257,3 +257,58 @@ def test_NamedList_generics():
     y = biocutils.assign_sequence(x, [1, 3], NamedList([ 20, 40 ], names=["b", "d" ]))
     assert y.as_list() == [ 1, 20, 3, 40 ]
     assert y.get_names().as_list() == [ "A", "B", "C", "D" ] # doesn't set the names, as per policy.
+
+def test_NamedList_safe_delete():
+    x = NamedList([1, 2, 3, 4], names=["A", "B", "C", "D"])
+
+    y = x.safe_delete(1)
+    assert y.as_list() == [1, 3, 4]
+    assert y.get_names().as_list() == ["A", "C", "D"]
+    assert x.as_list() == [1, 2, 3, 4]
+
+    y = x.safe_delete("C")
+    assert y.as_list() == [1, 2, 4]
+    assert y.get_names().as_list() == ["A", "B", "D"]
+
+    y = x.safe_delete(slice(1, 3))
+    assert y.as_list() == [1, 4]
+    assert y.get_names().as_list() == ["A", "D"]
+
+    y = x.safe_delete(-1)
+    assert y.as_list() == [1, 2, 3]
+    assert y.get_names().as_list() == ["A", "B", "C"]
+
+
+def test_NamedList_delete():
+    x = NamedList([1, 2, 3, 4], names=["A", "B", "C", "D"])
+
+    x.delete(0)
+    assert x.as_list() == [2, 3, 4]
+    assert x.get_names().as_list() == ["B", "C", "D"]
+
+    x.delete("D")
+    assert x.as_list() == [2, 3]
+    assert x.get_names().as_list() == ["B", "C"]
+
+
+def test_NamedList_delitem():
+    x = NamedList([1, 2, 3, 4], names=["A", "B", "C", "D"])
+
+    del x[1]
+    assert x.as_list() == [1, 3, 4]
+    assert x.get_names().as_list() == ["A", "C", "D"]
+
+    del x["A"]
+    assert x.as_list() == [3, 4]
+    assert x.get_names().as_list() == ["C", "D"]
+
+    x = NamedList([1, 2, 3, 4], names=["A", "B", "C", "D"])
+    del x[0:2]
+    assert x.as_list() == [3, 4]
+    assert x.get_names().as_list() == ["C", "D"]
+
+    with pytest.raises(KeyError):
+        del x["Missing"]
+    
+    with pytest.raises(IndexError):
+        del x[10]

tests/test_Names.py

@@ -195,3 +195,45 @@ def test_Names_generics():
     ass = biocutils.assign_sequence(x, range(1, 3), y)
     assert isinstance(ass, Names)
     assert ass.as_list() == ["1", "b", "c", "4"]
+
+def test_Names_safe_delete():
+    x = Names(["A", "B", "C", "D"])
+
+    y = x.safe_delete(1)
+    assert y.as_list() == ["A", "C", "D"]
+    assert y.map("B") == -1
+    assert y.map("C") == 1
+    assert x.as_list() == ["A", "B", "C", "D"]
+
+    y = x.safe_delete(slice(0, 2))
+    assert y.as_list() == ["C", "D"]
+    assert y.map("A") == -1
+    assert y.map("C") == 0
+
+
+def test_Names_delete():
+    x = Names(["A", "B", "C", "D"])
+
+    x.delete(2)
+    assert x.as_list() == ["A", "B", "D"]
+    assert x.map("C") == -1
+    assert x.map("D") == 2
+
+    x.delete(0)
+    assert x.as_list() == ["B", "D"]
+    assert x.map("A") == -1
+    assert x.map("B") == 0
+
+
+def test_Names_delitem():
+    x = Names(["1", "2", "3", "4"])
+
+    del x[1]
+    assert x.as_list() == ["1", "3", "4"]
+    assert x.map("2") == -1
+    assert x.map("3") == 1
+
+    del x[0:2]
+    assert x.as_list() == ["4"]
+    assert x.map("1") == -1
+    assert x.map("4") == 0