biocutils 0.3.1__tar.gz → 0.3.1.dev0__tar.gz

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

@@ -1,16 +1,8 @@
 # Changelog
 
-## Version 0.3.0 - 0.3.1
+## Version 0.3.0
 
 - 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 → biocutils-0.3.1.dev0}/PKG-INFO

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

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

@@ -4,7 +4,6 @@ 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 → biocutils-0.3.1.dev0}/src/biocutils/__init__.py

@@ -61,4 +61,4 @@ 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

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

@@ -424,8 +424,8 @@ class Factor:
             output._codes[index] = -1
             return output
 
-        for i, lev in enumerate(output._levels):
-            if lev == value:
+        for i, l in enumerate(output._levels):
+            if l == value:
                 output._codes[index] = i
                 return output
 
@@ -764,60 +764,6 @@ 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 → biocutils-0.3.1.dev0}/src/biocutils/float_list.py

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

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

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

{biocutils-0.3.1 → biocutils-0.3.1.dev0}/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, Tuple, Union
+from typing import Any, Dict, Iterable, Optional, Sequence, Union
 
 from .assign_sequence import assign_sequence
 from .combine_sequences import combine_sequences
@@ -153,27 +153,12 @@ 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
@@ -435,95 +420,6 @@ 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 → biocutils-0.3.1.dev0}/src/biocutils/names.py

@@ -121,17 +121,6 @@ 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 <<<<#####
     #################################
@@ -339,35 +328,6 @@ 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 <<<<#####
     ################################
@@ -399,15 +359,6 @@ 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 → biocutils-0.3.1.dev0}/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 Exception as _:
+        except:
             output.append("####")
     return output

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

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

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

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

{biocutils-0.3.1 → biocutils-0.3.1.dev0}/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 → biocutils-0.3.1.dev0}/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,54 +339,3 @@ 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 → biocutils-0.3.1.dev0}/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 → biocutils-0.3.1.dev0}/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 → biocutils-0.3.1.dev0}/tests/test_NamedList.py

@@ -10,7 +10,6 @@ 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]
@@ -24,7 +23,6 @@ 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():
@@ -257,76 +255,3 @@ 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 → biocutils-0.3.1.dev0}/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,64 +196,3 @@ 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 → biocutils-0.3.1.dev0}/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 → biocutils-0.3.1.dev0}/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 → biocutils-0.3.1.dev0}/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 → biocutils-0.3.1.dev0}/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)