More robust testing and operations on compressed lists (#8)

- Renamed `CompressedBiocFrameList` to `CompressedSplitBiocFrameList` since the current implementation can only handle dataframes with the same number and names of columns.
- Correctly link some of the annoying typehint errors.
- `to_list` and `unlist` now perform same operation as the R implementation.
- `splitAsCompressedList` has a more abstract implementation if no generic is implemented. If it fails, returns an error.

Author: jkanche

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## Version 0.3.0
+
+- Renamed `CompressedBiocFrameList` to `CompressedSplitBiocFrameList` since the current implementation can only handle dataframes with the same number and names of columns.
+- Correctly link some of the annoying typehint errors.
+- `to_list` and `unlist` now perform same operation as the R implementation.
+- `splitAsCompressedList` has a more abstract implementation if no generic is implemented. If it fails, returns an error.
+
 ## Version 0.2.0
 
 - Major changes to the package; Switch to typed lists from the biocutils package.

docs/tutorial.md

@@ -192,4 +192,4 @@ class CompressedMyObjectList(CompressedList):
         # ...
 ```
 
-Check out the `CompressedBiocFrameList` for a complete example of this usecase.
+Check out the `CompressedSplitBiocFrameList` for a complete example of this usecase.

src/compressed_lists/__init__.py

@@ -22,5 +22,5 @@
 from .bool_list import CompressedBooleanList
 from .float_list import CompressedFloatList
 from .numpy_list import CompressedNumpyList
-from .biocframe_list import CompressedBiocFrameList
+from .biocframe_list import CompressedSplitBiocFrameList
 from .split_generic import splitAsCompressedList

src/compressed_lists/base.py

@@ -144,7 +144,13 @@ def __repr__(self) -> str:
         output = f"{type(self).__name__}(number_of_elements={len(self)}"
         output += ", unlist_data=" + ut.print_truncated_list(self._unlist_data)
         output += ", partitioning=" + self._partitioning.__repr__()
-        output += ", element_type=" + self._element_type
+
+        _etype_name = "__unknown_class__"
+        if isinstance(self._element_type, str):
+            _etype_name = self._element_type
+        elif hasattr(self._element_type, "__name__"):
+            _etype_name = self._element_type.__name__
+        output += ", element_type=" + _etype_name
 
         if len(self._element_metadata) > 0:
             output += ", element_metadata=" + ut.print_truncated_dict(self._element_metadata)
@@ -162,7 +168,13 @@ def __str__(self) -> str:
         """
         output = f"class: {type(self).__name__}\n"
 
-        output += f"number of elements: ({len(self)}) of type: {self._element_type}\n"
+        _etype_name = "__unknown_class__"
+        if isinstance(self._element_type, str):
+            _etype_name = self._element_type
+        elif hasattr(self._element_type, "__name__"):
+            _etype_name = self._element_type.__name__
+
+        output += f"number of elements: ({len(self)}) of type: {_etype_name}\n"
 
         output += f"unlist_data: {ut.print_truncated_list(self._unlist_data)}\n"
 
@@ -203,11 +215,11 @@ def paritioning(self) -> Partitioning:
     ######>> names <<######
     #######################
 
-    def get_names(self) -> Optional[ut.NamedList]:
+    def get_names(self) -> Optional[ut.Names]:
         """Get the names of list elements."""
         return self._partitioning.get_names()
 
-    def set_names(self, names: List[str], in_place: bool = False) -> "CompressedList":
+    def set_names(self, names: Sequence[str], in_place: bool = False) -> "CompressedList":
         """Set the names of list elements.
 
         names:
@@ -227,7 +239,7 @@ def set_names(self, names: List[str], in_place: bool = False) -> "CompressedList
         return output
 
     @property
-    def names(self) -> Optional[ut.NamedList]:
+    def names(self) -> Optional[ut.Names]:
         """Alias for :py:attr:`~get_names`."""
         return self._partitioning.get_names()
 
@@ -460,7 +472,7 @@ def extract_range(self, start: int, end: int) -> Any:
 
     @classmethod
     def from_list(
-        cls, lst: List[Any], names: Optional[Sequence[str]] = None, metadata: Optional[dict] = None
+        cls, lst: Any, names: Optional[Union[ut.Names, Sequence[str]]] = None, metadata: Optional[dict] = None
     ) -> "CompressedList":
         """Create a CompressedList from a regular list.
 
@@ -497,27 +509,40 @@ def from_list(
     ######>> coercions <<######
     ###########################
 
-    def to_list(self) -> List[Any]:
+    def to_list(self) -> List[List[Any]]:
         """Convert to a regular Python list.
 
         Returns:
             A regular Python list with all elements.
         """
-        return list(self)
+        result = []
+        for i in range(len(self)):
+            _subset = list(self[i])
+            if len(_subset) == 0:
+                _subset = [None]
+            result.append(_subset)
+
+        return result
 
-    def unlist(self, use_names: bool = True) -> Any:
+    def as_list(self) -> List[List[Any]]:
+        """Alias to :py:meth:`~to_list`"""
+        return self.to_list()
+
+    def unlist(self, use_names: bool = False) -> Any:
         """Get the underlying unlisted data.
 
         Args:
             use_names:
                 Whether to include names in the result if applicable.
 
-                Currently not used.
-
         Returns:
             The unlisted data.
         """
-        return self._unlist_data
+        return (
+            self._unlist_data
+            if use_names is False
+            else self._unlist_data.set_names(self.get_partitioning().get_names(), in_place=False)
+        )
 
     def relist(self, unlist_data: Any) -> "CompressedList":
         """Create a new `CompressedList` with the same partitioning but different data.

src/compressed_lists/biocframe_list.py

@@ -12,8 +12,10 @@
 __license__ = "MIT"
 
 
-class CompressedBiocFrameList(CompressedList):
-    """CompressedList for BiocFrames."""
+class CompressedSplitBiocFrameList(CompressedList):
+    """CompressedList for BiocFrames.
+
+    All BiocFrames are expected to have the same number and names of columns."""
 
     def __init__(
         self,
@@ -23,7 +25,7 @@ def __init__(
         metadata: Optional[dict] = None,
         **kwargs,
     ):
-        """Initialize a CompressedBiocFrameList.
+        """Initialize a CompressedSplitBiocFrameList.
 
         Args:
             unlist_data:
@@ -50,16 +52,21 @@ def __init__(
 
     @classmethod
     def from_list(
-        cls, lst: List[BiocFrame], names: Optional[Sequence[str]] = None, metadata: Optional[dict] = None
-    ) -> "CompressedBiocFrameList":
-        """Create a `CompressedBiocFrameList` from a regular list.
+        cls,
+        lst: List[BiocFrame],
+        names: Optional[Union[ut.Names, Sequence[str]]] = None,
+        metadata: Optional[dict] = None,
+    ) -> "CompressedSplitBiocFrameList":
+        """Create a `CompressedSplitBiocFrameList` from a regular list.
 
         This concatenates the list of `BiocFrame` objects.
 
         Args:
             lst:
                 List of `BiocFrame` objects.
 
+                Must have the same number and names of columns.
+
             names:
                 Optional names for list elements.
 
@@ -106,21 +113,68 @@ def extract_range(self, start: int, end: int) -> BiocFrame:
                 "Custom classes should implement their own `extract_range` method for slice operations"
             ) from e
 
+    ##########################
+    ######>> Printing <<######
+    ##########################
+
+    def __repr__(self) -> str:
+        """
+        Returns:
+            A string representation.
+        """
+        output = f"{type(self).__name__}(number_of_elements={len(self)}"
+        output += ", unlist_data=" + self._unlist_data.__repr__()
+        output += ", partitioning=" + self._partitioning.__repr__()
+        output += (
+            ", element_type=" + self._element_type.__name__
+            if not isinstance(self._element_type, str)
+            else self._element_type
+        )
+
+        if len(self._element_metadata) > 0:
+            output += ", element_metadata=" + ut.print_truncated_dict(self._element_metadata)
+
+        if len(self._metadata) > 0:
+            output += ", metadata=" + ut.print_truncated_dict(self._metadata)
+
+        output += ")"
+        return output
+
+    def __str__(self) -> str:
+        """
+        Returns:
+            A pretty-printed string containing the contents of this object.
+        """
+        output = f"class: {type(self).__name__}\n"
+
+        output += f"number of elements: ({len(self)}) of type: {self._element_type.__name__ if not isinstance(self._element_type, str) else self._element_type}\n"
+
+        output += f"unlist_data: {ut.print_truncated_list(self._unlist_data.get_column_names())}\n"
+
+        output += f"partitioning: {ut.print_truncated_list(self._partitioning)}\n"
+
+        output += f"element_metadata({str(len(self._element_metadata))}): {ut.print_truncated_list(list(self._element_metadata.keys()), sep=' ', include_brackets=False, transform=lambda y: y)}\n"
+        output += f"metadata({str(len(self._metadata))}): {ut.print_truncated_list(list(self._metadata.keys()), sep=' ', include_brackets=False, transform=lambda y: y)}\n"
+
+        return output
+
 
 @splitAsCompressedList.register
 def _(
     data: BiocFrame,
     groups_or_partitions: Union[list, Partitioning],
-    names: Optional[Sequence[str]] = None,
+    names: Optional[Union[ut.Names, Sequence[str]]] = None,
     metadata: Optional[dict] = None,
-) -> CompressedBiocFrameList:
+) -> CompressedSplitBiocFrameList:
     """Handle lists of BiocFrame objects."""
 
     partitioned_data, groups_or_partitions = _generic_register_helper(
         data=data, groups_or_partitions=groups_or_partitions, names=names
     )
 
-    if not isinstance(partitioned_data, BiocFrame):
+    if not isinstance(partitioned_data, BiocFrame) and len(partitioned_data) != 0:
         partitioned_data = ut.relaxed_combine_rows(*partitioned_data)
 
-    return CompressedBiocFrameList(unlist_data=partitioned_data, partitioning=groups_or_partitions, metadata=metadata)
+    return CompressedSplitBiocFrameList(
+        unlist_data=partitioned_data, partitioning=groups_or_partitions, metadata=metadata
+    )

src/compressed_lists/bool_list.py

@@ -58,7 +58,7 @@ def __init__(
 def _(
     data: ut.BooleanList,
     groups_or_partitions: Union[list, Partitioning],
-    names: Optional[Sequence[str]] = None,
+    names: Optional[Union[ut.Names, Sequence[str]]] = None,
     metadata: Optional[dict] = None,
 ) -> CompressedBooleanList:
     """Handle lists of booleans."""
@@ -67,7 +67,7 @@ def _(
         data=data, groups_or_partitions=groups_or_partitions, names=names
     )
 
-    if not isinstance(partitioned_data, ut.BooleanList):
+    if not isinstance(partitioned_data, ut.BooleanList) and len(partitioned_data) != 0:
         partitioned_data = ut.combine_sequences(*partitioned_data)
 
     return CompressedBooleanList(unlist_data=partitioned_data, partitioning=groups_or_partitions, metadata=metadata)

src/compressed_lists/float_list.py

@@ -58,7 +58,7 @@ def __init__(
 def _(
     data: ut.FloatList,
     groups_or_partitions: Union[list, Partitioning],
-    names: Optional[Sequence[str]] = None,
+    names: Optional[Union[ut.Names, Sequence[str]]] = None,
     metadata: Optional[dict] = None,
 ) -> CompressedFloatList:
     """Handle lists of floats."""
@@ -67,7 +67,7 @@ def _(
         data=data, groups_or_partitions=groups_or_partitions, names=names
     )
 
-    if not isinstance(partitioned_data, ut.FloatList):
+    if not isinstance(partitioned_data, ut.FloatList) and len(partitioned_data) != 0:
         partitioned_data = ut.combine_sequences(*partitioned_data)
 
     return CompressedFloatList(unlist_data=partitioned_data, partitioning=groups_or_partitions, metadata=metadata)

src/compressed_lists/integer_list.py

@@ -58,7 +58,7 @@ def __init__(
 def _(
     data: ut.IntegerList,
     groups_or_partitions: Union[list, Partitioning],
-    names: Optional[Sequence[str]] = None,
+    names: Optional[Union[ut.Names, Sequence[str]]] = None,
     metadata: Optional[dict] = None,
 ) -> CompressedIntegerList:
     """Handle lists of integers."""
@@ -67,7 +67,7 @@ def _(
         data=data, groups_or_partitions=groups_or_partitions, names=names
     )
 
-    if not isinstance(partitioned_data, ut.IntegerList):
+    if not isinstance(partitioned_data, ut.IntegerList) and len(partitioned_data) != 0:
         partitioned_data = ut.combine_sequences(*partitioned_data)
 
     return CompressedIntegerList(unlist_data=partitioned_data, partitioning=groups_or_partitions, metadata=metadata)

src/compressed_lists/numpy_list.py

@@ -44,19 +44,25 @@ def __init__(
         """
 
         if not isinstance(unlist_data, np.ndarray):
-            try:
-                warn("trying to concatenate/coerce 'unlist_data' to a `np.ndarray`..")
-                unlist_data = np.concatenate(unlist_data)
-            except Exception as e:
-                raise TypeError("'unlist_data' must be an `np.ndarray`, provided ", type(unlist_data)) from e
+            if len(unlist_data) == 0:
+                unlist_data = np.asarray([])
+            else:
+                try:
+                    warn("trying to concatenate/coerce 'unlist_data' to a `np.ndarray`..")
+                    unlist_data = np.concatenate(unlist_data)
+                except Exception as e:
+                    raise TypeError("'unlist_data' must be an `np.ndarray`, provided ", type(unlist_data)) from e
 
         super().__init__(
             unlist_data, partitioning, element_type=np.ndarray, element_metadata=element_metadata, metadata=metadata
         )
 
     @classmethod
     def from_list(
-        cls, lst: List[np.ndarray], names: Optional[Sequence[str]] = None, metadata: Optional[dict] = None
+        cls,
+        lst: List[np.ndarray],
+        names: Optional[Union[ut.Names, Sequence[str]]] = None,
+        metadata: Optional[dict] = None,
     ) -> "CompressedNumpyList":
         """
         Create a `CompressedNumpyList` from a list of NumPy vectors.
@@ -88,7 +94,7 @@ def from_list(
 def _(
     data: np.ndarray,
     groups_or_partitions: Union[list, Partitioning],
-    names: Optional[Sequence[str]] = None,
+    names: Optional[Union[ut.Names, Sequence[str]]] = None,
     metadata: Optional[dict] = None,
 ) -> CompressedNumpyList:
     """Handle NumPy arrays."""
@@ -97,7 +103,7 @@ def _(
         data=data, groups_or_partitions=groups_or_partitions, names=names
     )
 
-    if not isinstance(partitioned_data, np.ndarray):
+    if not isinstance(partitioned_data, np.ndarray) and len(partitioned_data) != 0:
         partitioned_data = ut.combine_sequences(*partitioned_data)
 
     return CompressedNumpyList(unlist_data=partitioned_data, partitioning=groups_or_partitions, metadata=metadata)