tests for compressed lists

Author: jkanche

setup.cfg

@@ -70,7 +70,7 @@ optional =
     summarizedexperiment>=0.4.1
     singlecellexperiment>=0.4.1
     multiassayexperiment
-    compressed_lists>=0.1.1
+    compressed_lists>=0.3.0
 
 # Add here test requirements (semicolon/line-separated)
 testing =

src/rds2py/generics.py

@@ -63,6 +63,11 @@
     # compressed lists
     "CompressedIntegerList": "rds2py.read_compressed_list.read_compressed_integer_list",
     "PartitioningByEnd": "rds2py.read_compressed_list.read_partitioning_by_end",
+    "CompressedCharacterList": "rds2py.read_compressed_list.read_compressed_string_list",
+    "CompressedLogicalList": "rds2py.read_compressed_list.read_compressed_boolean_list",
+    "CompressedNumericList": "rds2py.read_compressed_list.read_compressed_float_list",
+    "CompressedSplitDataFrameList": "rds2py.read_compressed_list.read_compressed_frame_list",
+    "CompressedSplitDFrameList": "rds2py.read_compressed_list.read_compressed_frame_list",
 }
 
 

src/rds2py/read_compressed_list.py

@@ -35,8 +35,28 @@ def read_partitioning_by_end(robject: dict, **kwargs):
     return Partitioning(ends=np.asarray(ends))
 
 
+def _get_compressed_common_attrs(robject, **kwargs):
+    if "unlistData" not in robject["attributes"]:
+        raise ValueError("Object does not contain unlistData, is it really a `CompressedList`?")
+    unlist_data = _dispatcher(robject["attributes"]["unlistData"], **kwargs)
+
+    element_metadata = None
+    if "elementMetadata" in robject["attributes"]:
+        element_metadata = _dispatcher(robject["attributes"]["elementMetadata"], **kwargs)
+
+    metadata = None
+    if "metadata" in robject["attributes"]:
+        metadata = _dispatcher(robject["attributes"]["metadata"], **kwargs)
+
+    partition = None
+    if "partitioning" in robject["attributes"]:
+        partition = _dispatcher(robject["attributes"]["partitioning"], **kwargs)
+
+    return unlist_data, element_metadata, metadata, partition
+
+
 def read_compressed_integer_list(robject: dict, **kwargs):
-    """Read an R compressed list.
+    """Read an R compressed integer list.
 
     Args:
         robject:
@@ -53,24 +73,134 @@ def read_compressed_integer_list(robject: dict, **kwargs):
     if _cls not in ["CompressedIntegerList"]:
         raise RuntimeError(f"`robject` does not contain not a compressed integer list object, contains `{_cls}`.")
 
-    if "unlistData" not in robject["attributes"]:
-        raise ValueError("Object does not contain unlistData, is it really a `compressedList`?")
-    unlist_data = _dispatcher(robject["attributes"]["unlistData"], **kwargs)
+    unlist_data, element_metadata, metadata, partition = _get_compressed_common_attrs(robject=robject, **kwargs)
 
-    element_metadata = None
-    if "elementMetadata" in robject["attributes"]:
-        element_metadata = _dispatcher(robject["attributes"]["elementMetadata"], **kwargs)
+    from compressed_lists import CompressedIntegerList
 
-    metadata = None
-    if "metadata" in robject["attributes"]:
-        metadata = _dispatcher(robject["attributes"]["metadata"], **kwargs)
+    return CompressedIntegerList(
+        unlist_data=unlist_data, partitioning=partition, element_metadata=element_metadata, metadata=metadata
+    )
 
-    partition = None
-    if "partitioning" in robject["attributes"]:
-        partition = _dispatcher(robject["attributes"]["partitioning"], **kwargs)
 
-    from compressed_lists import CompressedIntegerList
+def read_compressed_string_list(robject: dict, **kwargs):
+    """Read an R compressed string/character list.
 
-    return CompressedIntegerList(
+    Args:
+        robject:
+            Dictionary containing parsed compressed list.
+
+        **kwargs:
+            Additional arguments.
+
+    Returns:
+       A `CompressedList` from the 'compressed_lists' package.
+    """
+    _cls = get_class(robject)
+
+    if _cls not in ["CompressedCharacterList"]:
+        raise RuntimeError(f"`robject` does not contain not a compressed string list object, contains `{_cls}`.")
+
+    unlist_data, element_metadata, metadata, partition = _get_compressed_common_attrs(robject=robject, **kwargs)
+
+    from compressed_lists import CompressedCharacterList
+
+    return CompressedCharacterList(
+        unlist_data=unlist_data, partitioning=partition, element_metadata=element_metadata, metadata=metadata
+    )
+
+
+def read_compressed_character_list(robject: dict, **kwargs):
+    """Read an R compressed string/character list.
+
+    Args:
+        robject:
+            Dictionary containing parsed compressed string list.
+
+        **kwargs:
+            Additional arguments.
+
+    Returns:
+       A `CompressedList` from the 'compressed_lists' package.
+    """
+    return read_compressed_string_list(robject, **kwargs)
+
+
+def read_compressed_boolean_list(robject: dict, **kwargs):
+    """Read an R compressed boolean list.
+
+    Args:
+        robject:
+            Dictionary containing parsed compressed list.
+
+        **kwargs:
+            Additional arguments.
+
+    Returns:
+       A `CompressedList` from the 'compressed_lists' package.
+    """
+    _cls = get_class(robject)
+
+    if _cls not in ["CompressedLogicalList"]:
+        raise RuntimeError(f"`robject` does not contain not a compressed boolean list object, contains `{_cls}`.")
+
+    unlist_data, element_metadata, metadata, partition = _get_compressed_common_attrs(robject=robject, **kwargs)
+
+    from compressed_lists import CompressedBooleanList
+
+    return CompressedBooleanList(
+        unlist_data=unlist_data, partitioning=partition, element_metadata=element_metadata, metadata=metadata
+    )
+
+
+def read_compressed_float_list(robject: dict, **kwargs):
+    """Read an R compressed float list.
+
+    Args:
+        robject:
+            Dictionary containing parsed compressed list.
+
+        **kwargs:
+            Additional arguments.
+
+    Returns:
+       A `CompressedList` from the 'compressed_lists' package.
+    """
+    _cls = get_class(robject)
+
+    if _cls not in ["CompressedNumericList"]:
+        raise RuntimeError(f"`robject` does not contain not a compressed float list object, contains `{_cls}`.")
+
+    unlist_data, element_metadata, metadata, partition = _get_compressed_common_attrs(robject=robject, **kwargs)
+
+    from compressed_lists import CompressedFloatList
+
+    return CompressedFloatList(
+        unlist_data=unlist_data, partitioning=partition, element_metadata=element_metadata, metadata=metadata
+    )
+
+
+def read_compressed_frame_list(robject: dict, **kwargs):
+    """Read an R compressed dataframe list.
+
+    Args:
+        robject:
+            Dictionary containing parsed compressed list.
+
+        **kwargs:
+            Additional arguments.
+
+    Returns:
+       A `CompressedList` from the 'compressed_lists' package.
+    """
+    _cls = get_class(robject)
+
+    if _cls not in ["CompressedSplitDataFrameList", "CompressedSplitDFrameList"]:
+        raise RuntimeError(f"`robject` does not contain not a compressed dataframe list object, contains `{_cls}`.")
+
+    unlist_data, element_metadata, metadata, partition = _get_compressed_common_attrs(robject=robject, **kwargs)
+
+    from compressed_lists import CompressedSplitBiocFrameList
+
+    return CompressedSplitBiocFrameList(
         unlist_data=unlist_data, partitioning=partition, element_metadata=element_metadata, metadata=metadata
     )

tests/data/compressedlist_char.rds

@@ -201,4 +201,18 @@ x <- IntegerList(11:12, integer(0), 3:-2, compress=TRUE)
 saveRDS(x, "compressedlist_int.rds")
 
 clist <- CharacterList(LETTERS[1:5], LETTERS[20:24], compress=TRUE)
-clist
+saveRDS(clist, "compressedlist_char.rds")
+
+x <- NumericList(11.1, 12.2, 13.3, 14.4, 15.5, compress=TRUE)
+saveRDS(x, "compressedlist_numeric.rds")
+
+
+x <- LogicalList(TRUE, FALSE, TRUE, compress=TRUE)
+saveRDS(x, "compressedlist_logical.rds")
+
+data("airquality")
+aq <- DataFrame(airquality)
+aqsplit <-
+  SplitDataFrameList(as.list(split(aq, aq[["Ozone"]])),
+                     compress = TRUE)
+saveRDS(aqsplit, "compressedlist_splitdframe.rds")

tests/data/compressedlist_int.rds

@@ -1,6 +1,6 @@
 import biocutils as ut
+import compressed_lists as clist
 import pytest
-from compressed_lists import CompressedIntegerList
 
 from rds2py import read_rds
 
@@ -15,5 +15,45 @@ def test_compressed_lists_int():
     assert obj is not None
     assert len(obj) > 0
 
-    assert isinstance(obj, CompressedIntegerList)
-    assert obj.to_list().as_list() == [11, 12, 3, 2, 1, 0, -1, -2]
+    assert isinstance(obj, clist.CompressedIntegerList)
+    assert obj.to_list() == [[11, 12], [None], [3, 2, 1, 0, -1, -2]]
+
+
+def test_compressed_lists_char():
+    obj = read_rds("tests/data/compressedlist_char.rds")
+
+    assert obj is not None
+    assert len(obj) > 0
+
+    assert isinstance(obj, clist.CompressedCharacterList)
+    assert obj.to_list() == [["A", "B", "C", "D", "E"], ["T", "U", "V", "W", "X"]]
+
+
+def test_compressed_lists_floats():
+    obj = read_rds("tests/data/compressedlist_numeric.rds")
+
+    assert obj is not None
+    assert len(obj) > 0
+
+    assert isinstance(obj, clist.CompressedFloatList)
+    assert obj.to_list() == [[11.1], [12.2], [13.3], [14.4], [15.5]]
+
+
+def test_compressed_lists_bool():
+    obj = read_rds("tests/data/compressedlist_logical.rds")
+
+    assert obj is not None
+    assert len(obj) > 0
+
+    assert isinstance(obj, clist.CompressedBooleanList)
+    assert obj.to_list() == [[True], [False], [True]]
+
+
+def test_compressed_lists_dframe():
+    obj = read_rds("tests/data/compressedlist_splitdframe.rds")
+
+    assert obj is not None
+    assert len(obj) > 0
+
+    assert isinstance(obj, clist.CompressedSplitBiocFrameList)
+    assert obj.unlist().shape == (153, 6)