biocutils 0.3.1.dev0__tar.gz → 0.3.2__tar.gz

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/CHANGELOG.md

@@ -1,8 +1,16 @@
 # Changelog
 
-## Version 0.3.0
+## Version 0.3.0 - 0.3.2
 
 - Provide a base `BiocObject` class similar to the `Annotated` class in Bioconductor. The class provides `metadata` slot, accessors and validation functions.
+- Renaming code files to follow pep guidelines
+- Update Github actions and workflow to the new biocsetup versions
+- Changes to improve `NamedList`, `Names` classes
+  - get name at index
+  - delete method for namedlist/names
+  - add is_unique
+  - add lint errors
+- linting documentation, typehints etc
 
 ## Version 0.2.3
 

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: biocutils
-Version: 0.3.1.dev0
+Version: 0.3.2
 Summary: Utilities to use across the biocpy packages.
 Home-page: https://github.com/biocpy/biocutils
 Author: Aaron Lun

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/setup.py

@@ -4,6 +4,7 @@ This file was generated with PyScaffold 4.5.
 PyScaffold helps you to put up the scaffold of your new Python project.
 Learn more under: https://pyscaffold.org/
 """
+
 from setuptools import setup
 
 if __name__ == "__main__":

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/src/biocutils/__init__.py

@@ -61,4 +61,5 @@ from .convert_to_dense import convert_to_dense
 from .get_height import get_height
 from .is_high_dimensional import is_high_dimensional
 
-from .bioc_object import BiocObject
+from .bioc_object import BiocObject
+from .table import table

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/src/biocutils/factor.py

@@ -424,8 +424,8 @@ class Factor:
             output._codes[index] = -1
             return output
 
-        for i, l in enumerate(output._levels):
-            if l == value:
+        for i, lev in enumerate(output._levels):
+            if lev == value:
                 output._codes[index] = i
                 return output
 
@@ -764,6 +764,60 @@ class Factor:
         levels, indices = factorize(x, levels=levels, sort_levels=sort_levels, **kwargs)
         return Factor(indices, levels=levels, ordered=ordered, names=names)
 
+    ################################
+    #####>>>> List methods <<<<#####
+    ################################
+
+    def as_list(self) -> list:
+        """
+        Returns:
+            List of strings corresponding to the factor elements.
+            Missing values are represented as None.
+        """
+        return [self._levels[c] if c >= 0 else None for c in self._codes]
+
+    def safe_delete(self, index: Union[int, str, slice], in_place: bool = False) -> Factor:
+        """
+        Args:
+            index:
+                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 ``Factor`` 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 = copy(self)
+            output._codes = copy(self._codes)
+            if output._names is not None:
+                output._names = output._names.copy()
+
+        if isinstance(index, str):
+            index = _name_to_position(output._names, index)
+
+        output._codes = numpy.delete(output._codes, 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)
+
 
 @subset_sequence.register
 def _subset_sequence_Factor(x: Factor, indices: Sequence[int]) -> Factor:

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/src/biocutils/float_list.py

@@ -12,7 +12,7 @@ def _coerce_to_float(x: Any):
         return None
     try:
         return float(x)
-    except:
+    except Exception as _:
         return None
 
 

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/src/biocutils/integer_list.py

@@ -12,7 +12,7 @@ def _coerce_to_int(x: Any):
         return None
     try:
         return int(x)
-    except:
+    except Exception as _:
         return None
 
 

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/src/biocutils/named_list.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from copy import deepcopy
-from typing import Any, Dict, Iterable, Optional, Sequence, Union
+from typing import Any, Dict, Iterable, Optional, Sequence, Tuple, Union
 
 from .assign_sequence import assign_sequence
 from .combine_sequences import combine_sequences
@@ -153,12 +153,27 @@ class NamedList:
         output._names = _sanitize_names(names, len(self))
         return output
 
+    def get_name(self, index: int) -> Optional[str]:
+        """Get name at an index.
+
+        Args:
+            index:
+                Integer index of the element.
+        Returns:
+            Names for the list elements.
+        """
+        if self._names is None:
+            return None
+
+        return self._names.get_value(index)
+
     #################################
     #####>>>> Get/set items <<<<#####
     #################################
 
     def get_value(self, index: Union[str, int]) -> Any:
-        """
+        """Get value at an index.
+
         Args:
             index:
                 Integer index of the element to obtain. Alternatively, a string
@@ -420,6 +435,95 @@ class NamedList:
         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)
+
+    #####################################
+    #####>>>> dict like methods <<<<#####
+    #####################################
+
+    def keys(self) -> Iterable[str]:
+        """
+        Returns:
+            Iterator over the names of the list elements.
+        """
+        if self._names is None:
+            return iter([])
+        return iter(self._names)
+
+    def values(self) -> Iterable[Any]:
+        """
+        Returns:
+            Iterator over the values of the list elements.
+        """
+        return iter(self._data)
+
+    def items(self) -> Iterable[Tuple[str, Any]]:
+        """
+        Returns:
+            Iterator over (name, value) pairs.
+            If names are missing, keys are returned as stringified indices.
+        """
+        if self._names is not None:
+            return zip(self._names, self._data)
+        else:
+            return zip((str(i) for i in range(len(self))), self._data)
+
+    def get(self, key: Union[str, int], default: Any = None) -> Any:
+        """
+        Args:
+            key:
+                Name or index of the element.
+
+            default:
+                Value to return if ``key`` is not found.
+
+        Returns:
+            Value at ``key`` or ``default``.
+        """
+        try:
+            return self.get_value(key)
+        except (KeyError, IndexError):
+            return default
+
     ################################
     #####>>>> Copy methods <<<<#####
     ################################

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/src/biocutils/names.py

@@ -121,6 +121,17 @@ class Names:
         else:
             return -1
 
+    def __contains__(self, name: str) -> bool:
+        """
+        Args:
+            name:
+                Name to check.
+
+        Returns:
+            True if ``name`` exists, otherwise False.
+        """
+        return self.map(name) >= 0
+
     #################################
     #####>>>> Get/set items <<<<#####
     #################################
@@ -328,6 +339,35 @@ class Names:
         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 <<<<#####
     ################################
@@ -359,6 +399,15 @@ class Names:
         """
         return type(self)(deepcopy(self._names, memo, _nil), _validate=False)
 
+    @property
+    def is_unique(self) -> bool:
+        """
+        Returns:
+            True if all names are unique, otherwise False.
+        """
+        self._populate_reverse_index()
+        return len(self._reverse) == len(self._names)
+
 
 @subset_sequence.register
 def _subset_sequence_Names(x: Names, indices: Sequence[int]) -> Names:

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/src/biocutils/show_as_cell.py

@@ -30,6 +30,6 @@ def show_as_cell(x: Any, indices: Sequence[int]) -> List[str]:
             if nl >= 0:
                 candidate = candidate[:nl] + "..."
             output.append(candidate)
-        except:
+        except Exception as _:
             output.append("####")
     return output

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/src/biocutils/which.py

@@ -23,7 +23,7 @@ def which(
     """
     if isinstance(x, numpy.ndarray):
         found = numpy.where(x)[0]
-        if not dtype is None:
+        if dtype is not None:
             found = found.astype(dtype=dtype, copy=False, order="A")
         return found
 

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/src/biocutils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: biocutils
-Version: 0.3.1.dev0
+Version: 0.3.2
 Summary: Utilities to use across the biocpy packages.
 Home-page: https://github.com/biocpy/biocutils
 Author: Aaron Lun

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/tests/test_BooleanList.py

@@ -44,7 +44,7 @@ def test_BooleanList_setitem():
     x = BooleanList([False, True, True, False])
     x[0] = None
     assert x.as_list() == [None, True, True, False]
-    x[0] = 12345 
+    x[0] = 12345
     assert x.as_list() == [True, True, True, False]
 
     x[1:3] = [False, False]
@@ -54,7 +54,7 @@ def test_BooleanList_setitem():
     assert x.as_list() == [None, False, None, False]
 
     x.set_names(["A", "B", "C", "D"], in_place=True)
-    x["C"] = True 
+    x["C"] = True
     assert x.as_list() == [None, False, True, False]
     x[["A", "B"]] = [False, True]
     assert x.as_list() == [False, True, True, False]

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/tests/test_Factor.py

@@ -17,13 +17,13 @@ def test_factor_init():
     assert len(f) == 6
     assert list(f) == ["A", "B", None, "A", None, "E"]
     assert list(f.get_codes()) == [0, 1, -1, 0, -1, 4]
-    
+
     f = Factor([None] * 10, levels=["A", "B", "C", "D", "E"])
     assert list(f) == [None] * 10
 
     # Works with NumPy inputs.
     f = Factor(numpy.array([4,3,2,1,0], dtype=numpy.uint8), levels=numpy.array(["A", "B", "C", "D", "E"]))
-    assert len(f) == 5 
+    assert len(f) == 5
     assert f.get_codes().dtype == numpy.int8
     assert isinstance(f.get_levels(), StringList)
 
@@ -98,7 +98,7 @@ def test_Factor_get_value():
 def test_Factor_get_slice():
     f = Factor([0, 1, 2, -1, 2, 4], levels=["A", "B", "C", "D", "E"])
 
-    sub = f.get_slice([0, 1]) 
+    sub = f.get_slice([0, 1])
     assert list(sub) == ["A", "B"]
     assert sub.get_levels() == f.get_levels()
 
@@ -176,7 +176,7 @@ def test_Factor_setitem():
     f[-1] = "D"
     assert list(f.get_codes()) == [1, 1, 0, 0, 2, 3]
 
-    f[2:5] = Factor([4, 3, 1], levels=["A", "B", "C", "D", "E"]) 
+    f[2:5] = Factor([4, 3, 1], levels=["A", "B", "C", "D", "E"])
     assert list(f.get_codes()) == [1, 1, 4, 3, 1, 3]
     assert f.get_levels() == f.get_levels()
 
@@ -339,3 +339,54 @@ def test_Factor_init_from_list():
     assert isinstance(f1, Factor)
     assert len(f1) == 5
     assert len(f1.get_levels()) == 3
+
+def test_Factor_as_list():
+    f = Factor([0, 1, -1, 0], levels=["A", "B"])
+    assert f.as_list() == ["A", "B", None, "A"]
+
+    empty = Factor([], levels=[])
+    assert empty.as_list() == []
+
+
+def test_Factor_safe_delete():
+    f = Factor([0, 1, 2, 0], levels=["A", "B", "C"], names=["x", "y", "z", "w"])
+
+    y = f.safe_delete(1)
+    assert y.as_list() == ["A", "C", "A"]
+    assert y.get_names().as_list() == ["x", "z", "w"]
+    assert f.as_list() == ["A", "B", "C", "A"]
+
+    y = f.safe_delete("y")
+    assert y.as_list() == ["A", "C", "A"]
+    assert y.get_names().as_list() == ["x", "z", "w"]
+
+    y = f.safe_delete(slice(1, 3))
+    assert y.as_list() == ["A", "A"]
+    assert y.get_names().as_list() == ["x", "w"]
+
+
+def test_Factor_delete():
+    f = Factor([0, 1, 2], levels=["A", "B", "C"], names=["x", "y", "z"])
+
+    f.delete(1)
+    assert f.as_list() == ["A", "C"]
+    assert f.get_names().as_list() == ["x", "z"]
+
+    f.delete("z")
+    assert f.as_list() == ["A"]
+    assert f.get_names().as_list() == ["x"]
+
+
+def test_Factor_delitem():
+    f = Factor([0, 1, 2, 0], levels=["A", "B", "C"], names=["x", "y", "z", "w"])
+
+    del f["y"]
+    assert f.as_list() == ["A", "C", "A"]
+    assert f.get_names().as_list() == ["x", "z", "w"]
+
+    del f[0]
+    assert f.as_list() == ["C", "A"]
+    assert f.get_names().as_list() == ["z", "w"]
+
+    del f[:]
+    assert len(f) == 0

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/tests/test_FloatList.py

@@ -44,7 +44,7 @@ def test_FloatList_setitem():
     x = FloatList([ 0.5, -2.1, -3.2, -4.5 ])
     x[0] = None
     assert x.as_list() == [None, -2.1, -3.2, -4.5]
-    x[0] = 12345 
+    x[0] = 12345
     assert x.as_list() == [12345.0, -2.1, -3.2, -4.5]
 
     x[1:3] = [10.1, 20.2]

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/tests/test_IntegerList.py

@@ -44,7 +44,7 @@ def test_IntegerList_setitem():
     x = IntegerList([1,2,3,4])
     x[0] = None
     assert x.as_list() == [None, 2, 3, 4]
-    x[0] = 12345 
+    x[0] = 12345
     assert x.as_list() == [12345, 2, 3, 4]
 
     x[1:3] = [10, 20]

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/tests/test_NamedList.py

@@ -10,6 +10,7 @@ def test_NamedList_init():
     assert x.as_list() == [ 1,2,3,4 ]
     assert x.get_names().as_list() == ["a", "b", "c", "d"]
     assert len(x) == 4
+    assert x.get_name(0) == "a"
 
     y = NamedList(x)
     assert y.as_list() == [1,2,3,4]
@@ -23,6 +24,7 @@ def test_NamedList_init():
     x = NamedList([1,2,3,4])
     assert x.as_list() == [1,2,3,4]
     assert x.get_names() is None
+    assert x.get_name(1) is None
 
 
 def test_Names_iter():
@@ -255,3 +257,76 @@ 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]
+
+def test_NamedList_dict_methods():
+    x = NamedList([1, 2, 3], names=["A", "B", "C"])
+
+    assert list(x.keys()) == ["A", "B", "C"]
+    assert list(x.values()) == [1, 2, 3]
+    assert list(x.items()) == [("A", 1), ("B", 2), ("C", 3)]
+
+    assert x.get("A") == 1
+    assert x.get("C") == 3
+    assert x.get("Missing") is None
+    assert x.get("Missing", 100) == 100
+    assert x.get(1) == 2  # Integer index access via get
+
+    y = NamedList([10, 20])
+    assert list(y.keys()) == []
+    assert list(y.values()) == [10, 20]
+    assert list(y.items()) == [("0", 10), ("1", 20)]

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/tests/test_Names.py

@@ -185,7 +185,7 @@ def test_Names_generics():
     sub = biocutils.subset_sequence(x, [0,3,2,1])
     assert isinstance(sub, Names)
     assert sub.as_list() == ["1", "4", "3", "2"]
-    
+
     y = ["a", "b", "c", "d"]
     com = biocutils.combine_sequences(x, y)
     assert isinstance(com, Names)
@@ -196,3 +196,64 @@ def test_Names_generics():
     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
+
+def test_Names_contains():
+    x = Names(["A", "B", "C"])
+    assert "A" in x
+    assert "B" in x
+    assert "Z" not in x
+
+    # Works with duplicates
+    y = Names(["A", "A", "B"])
+    assert "A" in y
+
+def test_Names_is_unique():
+    x = Names(["A", "B", "C"])
+    assert x.is_unique
+
+    y = Names(["A", "B", "A"])
+    assert not y.is_unique
+
+    empty = Names([])
+    assert empty.is_unique

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/tests/test_StringList.py

@@ -44,7 +44,7 @@ def test_StringList_setitem():
     x = StringList([1,2,3,4])
     x[0] = None
     assert x.as_list() == [None, "2", "3", "4"]
-    x[0] = 12345 
+    x[0] = 12345
     assert x.as_list() == ["12345", "2", "3", "4"]
 
     x[1:3] = [10, 20]
@@ -89,7 +89,7 @@ def test_StringList_generics():
     sub = biocutils.subset_sequence(x, [0,3,2,1])
     assert isinstance(sub, StringList)
     assert sub.as_list() == ["1", "4", "3", "2"]
-    
+
     y = ["a", "b", "c", "d"]
     com = biocutils.combine_sequences(x, y)
     assert isinstance(com, StringList)

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/tests/test_biocobject.py

@@ -3,7 +3,7 @@ from copy import copy
 from biocutils.bioc_object import BiocObject
 from biocutils.named_list import NamedList
 
-    
+
 def test_init_empty():
     """Test initialization with default values."""
     obj = BiocObject()
@@ -14,7 +14,7 @@ def test_init_with_dict():
     """Test initialization with a dictionary."""
     meta = {"author": "jkanche", "version": 1}
     obj = BiocObject(metadata=meta)
-    
+
     assert isinstance(obj.metadata, NamedList)
     assert len(obj.metadata) == 2
 
@@ -28,7 +28,7 @@ def test_metadata_property_setter():
     obj = BiocObject()
     new_meta = {"tag": "experiment_1"}
     obj.metadata = new_meta
-    
+
     assert len(obj.metadata) == 1
     assert isinstance(obj.metadata, NamedList)
 
@@ -36,21 +36,21 @@ def test_set_metadata_copy():
     """Test functional style set_metadata (copy-on-write)."""
     obj = BiocObject(metadata={"id": 1})
     original_id = id(obj)
-    
+
     new_obj = obj.set_metadata({"id": 2})
-    
+
     assert id(new_obj) != original_id
     assert len(new_obj.metadata) == 1
-    
-    assert len(obj.metadata) == 1 
+
+    assert len(obj.metadata) == 1
 
 def test_set_metadata_inplace():
     """Test imperative style set_metadata (in-place)."""
     obj = BiocObject(metadata={"id": 1})
     original_id = id(obj)
-    
+
     new_obj = obj.set_metadata({"id": 2}, in_place=True)
-    
+
     assert id(new_obj) == original_id
     assert new_obj is obj
     assert len(obj.metadata) == 1
@@ -59,18 +59,18 @@ def test_inheritance():
     """Test that subclasses maintain their type when copying."""
     class GenomicContainer(BiocObject):
         pass
-    
+
     obj = GenomicContainer(metadata={"genome": "hg38"})
     new_obj = obj.set_metadata({"genome": "mm10"})
-    
+
     assert isinstance(new_obj, GenomicContainer)
     assert new_obj is not obj
 
 def test_shallow_copy_behavior():
     heavy_data = ["large", "data"]
-    
+
     obj = BiocObject()
     obj._heavy_data = heavy_data
     new_obj = obj.set_metadata({"new": "meta"})
     assert new_obj is not obj
-    assert new_obj._heavy_data is obj._heavy_data
+    assert new_obj._heavy_data is obj._heavy_data

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/tests/test_combine_sequences.py

@@ -35,7 +35,7 @@ def test_basic_dense_masked():
     x = [1, 2, 3]
     y = [0.1, 0.2]
     xd = np.array(x)
-    yd = np.ma.array(y, mask=[True]*2) 
+    yd = np.ma.array(y, mask=[True]*2)
 
     zcomb = combine_sequences(xd, yd)
     z = x + y

{biocutils-0.3.1.dev0 → biocutils-0.3.2}/tests/test_factorize.py

@@ -52,7 +52,7 @@ def test_factorize_sorted():
 def test_factorize_factor():
     f = Factor([4, 3, 2, 1, 0], ["A", "B", "C", "D", "E"])
     lev, ind = factorize(f)
-    assert lev == ["E", "D", "C", "B", "A"] 
+    assert lev == ["E", "D", "C", "B", "A"]
     assert list(ind) == [0, 1, 2, 3, 4]
 
     lev, ind = factorize(f, sort_levels=True)