cap-anndata 0.3.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

cap_anndata/backed_df.py

@@ -1,13 +1,10 @@
 import pandas as pd
 import numpy as np
 from typing import List, Any, Union
-import logging
 
 from pandas._typing import Self
 from pandas.core.generic import bool_t
 
-logger = logging.getLogger(__name__)
-
 
 class CapAnnDataDF(pd.DataFrame):
     """
@@ -19,26 +16,37 @@ class CapAnnDataDF(pd.DataFrame):
 
     _metadata = ["column_order"]
 
+    def column_order_array(self) -> np.array:
+        order = self.column_order
+        if order is not None and isinstance(order, List):
+            # Convert it to numpy array of str elements
+            return np.array(order, dtype=object)
+        else:
+            return order
+
     def rename_column(self, old_name: str, new_name: str) -> None:
-        i = np.where(self.column_order == old_name)[0]
-        self.column_order[i] = new_name
+        i = np.where(self.column_order_array() == old_name)[0]
+        tmp_array = self.column_order_array().copy()
+        tmp_array[i] = new_name
+        self.column_order = tmp_array.copy()
         self.rename(columns={old_name: new_name}, inplace=True)
 
     def remove_column(self, col_name: str) -> None:
-        i = np.where(self.column_order == col_name)[0]
-        self.column_order = np.delete(self.column_order, i)
+        i = np.where(self.column_order_array() == col_name)[0]
+        self.column_order = np.delete(self.column_order_array(), i)
         self.drop(columns=[col_name], inplace=True)
 
     def __setitem__(self, key, value) -> None:
-        if key not in self.column_order:
-            self.column_order = np.append(self.column_order, key)
+        if key not in self.column_order_array():
+            self.column_order = np.append(self.column_order_array(), key)
         return super().__setitem__(key, value)
 
     @classmethod
-    def from_df(cls, df: pd.DataFrame, column_order: List[str] = None) -> Self:
+    def from_df(cls, df: pd.DataFrame, column_order: Union[np.array, List[str], None] = None) -> Self:
         if column_order is None:
             column_order = df.columns.to_numpy()
-
+        elif isinstance(column_order, List):
+            column_order = np.array(column_order)
         new_inst = cls(df)
         new_inst.column_order = column_order
         return new_inst
@@ -47,23 +55,27 @@ class CapAnnDataDF(pd.DataFrame):
         result = super().join(other=other, **kwargs)
         if isinstance(other, CapAnnDataDF):
             new_columns = [
-                col for col in other.column_order if col not in self.column_order
+                col for col in other.column_order_array() if col not in self.column_order_array()
             ]
         else:
-            new_columns = [col for col in other.columns if col not in self.column_order]
-        column_order = np.append(self.column_order, new_columns)
-        return self.from_df(result, column_order=column_order)
+            new_columns = [col for col in other.columns if col not in self.column_order_array()]
+        column_order = np.append(self.column_order_array(), new_columns)
+        df = self.from_df(result, column_order=column_order)
+        return df
 
     def merge(self, right, **kwargs) -> Self:
         result = super().merge(right=right, **kwargs)
         if isinstance(right, CapAnnDataDF):
             new_columns = [
-                col for col in right.column_order if col not in self.column_order
+                col for col in right.column_order_array() if col not in self.column_order_array()
             ]
         else:
-            new_columns = [col for col in right.columns if col not in self.column_order]
-        column_order = np.append(self.column_order, new_columns)
-        return self.from_df(result, column_order=column_order)
+            new_columns = [col for col in right.columns if col not in self.column_order_array()]
+        column_order = np.append(self.column_order_array(), new_columns)
+        df = self.from_df(result, column_order=column_order)
+        return df
 
     def copy(self, deep: Union[bool_t, None] = True) -> Self:
-        return self.from_df(super().copy(deep=deep), column_order=self.column_order)
+        column_order = self.column_order_array()
+        df = self.from_df(super().copy(deep=deep), column_order=column_order)
+        return df

cap_anndata/cap_anndata.py

@@ -7,19 +7,33 @@ import scipy.sparse as ss
 from packaging import version
 
 if version.parse(ad.__version__) < version.parse("0.11.0"):
-    from anndata.experimental import sparse_dataset, read_elem, write_elem
+    from anndata.experimental import (
+        sparse_dataset,
+        read_elem,
+        write_elem,
+        CSRDataset,
+        CSCDataset,
+    )
 else:
-    from anndata.io import sparse_dataset, read_elem, write_elem
+    from anndata.io import (
+        sparse_dataset,
+        read_elem,
+        write_elem,
+    )
+    from anndata.abc import (
+        CSRDataset,
+        CSCDataset,
+    )
 
 from cap_anndata import CapAnnDataDF, CapAnnDataDict
 
 logger = logging.getLogger(__name__)
 
 X_NOTATION = Union[
-    h5py.Dataset, ad.experimental.CSRDataset, ad.experimental.CSCDataset, None
+    h5py.Dataset, CSRDataset, CSCDataset, None
 ]
 ARRAY_MAPPING_NOTATION = CapAnnDataDict[str, X_NOTATION]
-
+FIELDS_SUPPORTED_TO_OVERWRITE = ["obs", "var", "raw.var", "uns", "layers", "obsm", "varm", "obsp", "varp"]
 NotLinkedObject: Final = "__NotLinkedObject"
 
 
@@ -57,15 +71,7 @@ class BaseLayerMatrixAndDf:
         return shape
 
     def _lazy_df_load(self, key: str) -> CapAnnDataDF:
-        df = CapAnnDataDF()
-        attribute = self._path_to_content + key
-        column_order = self._read_attr(self._file[attribute], "column-order")
-        df.column_order = column_order
-        if df.column_order.dtype != object:
-            # empty DataFrame will have column_order as float64
-            # which leads to failure in overwrite method
-            df.column_order = df.column_order.astype(object)
-        return df
+        return self._read_df(key=key, columns=[])
 
     @staticmethod
     def _read_attr(obj: Union[h5py.Group, h5py.Dataset], attr_name: str) -> any:
@@ -93,8 +99,10 @@ class BaseLayerMatrixAndDf:
             cols_to_read = [c for c in columns if c in column_order]
             df = CapAnnDataDF()
             df.column_order = column_order
+
             index_col = self._read_attr(h5_group, "_index")
-            df.index = read_elem(h5_group[index_col])
+            index = read_elem(h5_group[index_col])
+            df.index = index
 
             for col in cols_to_read:
                 df[col] = read_elem(h5_group[col])
@@ -135,15 +143,19 @@ class BaseLayerMatrixAndDf:
         if not isinstance(group, h5py.Group):
             raise ValueError(f"The object {key} must be a group!")
 
-        for array_name in group.keys():
-            array = group[array_name]
-            if isinstance(array, h5py.Dataset):
-                cap_dict[array_name] = array
-            elif isinstance(array, h5py.Group):
-                cap_dict[array_name] = sparse_dataset(array)
+        for entity_name in group.keys():
+            entity = group[entity_name]
+            if isinstance(entity, h5py.Dataset):
+                cap_dict[entity_name] = entity
+            elif isinstance(entity, h5py.Group):
+                enc_type = dict(entity.attrs).get("encoding-type")
+                if enc_type == "dataframe":
+                    cap_dict[entity_name] = self._read_df(key="/".join([key, entity_name]), columns=None)
+                elif enc_type in ["csc_matrix", "csr_matrix"]:
+                    cap_dict[entity_name] = sparse_dataset(entity)
             else:
                 raise ValueError(
-                    f"Can't link array in {key} due to unsupported type of object: {type(array)}"
+                    f"Can't link array in {key} due to unsupported type of object: {type(entity)}"
                 )
 
     def _create_new_matrix(
@@ -252,11 +264,11 @@ class CapAnnData(BaseLayerMatrixAndDf):
     def raw(self) -> RawLayer:
         if self._raw is None:
             if "raw" not in self._file.keys():
-                logger.warning("Can't read raw.var since raw layer doesn't exist!")
+                logger.debug("Can't read raw.var since raw layer doesn't exist!")
                 return
 
             if len(self._file["raw"].keys()) == 0:
-                logger.warning("The raw layer is empty!")
+                logger.debug("The raw layer is empty!")
                 return
 
             self._raw = RawLayer(self._file)
@@ -366,37 +378,43 @@ class CapAnnData(BaseLayerMatrixAndDf):
         return list(self.obsm.keys())
 
     def obs_keys(self) -> List[str]:
-        return self.obs.column_order.tolist()
+        return self.obs.column_order_array().tolist()
 
     def var_keys(self) -> List[str]:
-        return self.var.column_order.tolist()
+        return self.var.column_order_array().tolist()
+    
+    def field_to_entity(self, key):
+        if key == "obs":
+            return self.obs
+        elif key == "var":
+            return self.var
+        elif key == "raw.var":
+            return self.raw.var if self.raw is not None else None
+        elif key == "uns":
+            return self.uns
+        elif key == "layers":
+            return self.layers
+        elif key == "obsm":
+            return self.obsm
+        elif key == "varm":
+            return self.varm
+        elif key == "obsp":
+            return self.obsp
+        elif key == "varp":
+            return self.varp
+        else:
+            raise KeyError(
+                f"The field {key} is not supported! The list of supported fields are equal to {FIELDS_SUPPORTED_TO_OVERWRITE} "
+                f"attributes of the CapAnnData class."
+            )
 
     def overwrite(self, fields: List[str] = None, compression: str = "lzf") -> None:
-        field_to_entity = {
-            "obs": self.obs,
-            "var": self.var,
-            "raw.var": self.raw.var if self.raw is not None else None,
-            "uns": self.uns,
-            "layers": self.layers,
-            "obsm": self.obsm,
-            "varm": self.varm,
-            "obsp": self.obsp,
-            "varp": self.varp,
-        }
-
         if fields is None:
-            fields = list(field_to_entity.keys())
-        else:
-            for f in fields:
-                if f not in field_to_entity.keys():
-                    raise KeyError(
-                        f"The field {f} is not supported! The list of supported fields are equal to supported "
-                        f"attributes of the CapAnnData class: obs, var, raw.var and uns."
-                    )
+            fields = FIELDS_SUPPORTED_TO_OVERWRITE
 
         for key in ["obs", "var", "raw.var"]:
             if key in fields:
-                entity: CapAnnDataDF = field_to_entity[key]
+                entity: CapAnnDataDF = self.field_to_entity(key)
                 if entity is None:
                     continue
 
@@ -407,11 +425,22 @@ class CapAnnData(BaseLayerMatrixAndDf):
                         f"{key}/{col}", entity[col].values, compression=compression
                     )
 
-                column_order = entity.column_order
+                column_order = entity.column_order_array()
                 if (
                     column_order.size == 0
                 ):  # Refs https://github.com/cellannotation/cap-anndata/issues/6
                     column_order = np.array([], dtype=np.float64)
+
+                # Index update
+                index_name = entity.index.name
+                if not index_name:
+                    index_name = "_index"
+                self._file[key].attrs["_index"] = index_name
+                index_col = self._read_attr(self._file[key], "_index")
+                self._write_elem(
+                    f"{key}/{index_col}", entity.index.to_numpy(), compression=compression
+                )
+
                 self._file[key].attrs["column-order"] = column_order
 
         if "uns" in fields:
@@ -424,7 +453,7 @@ class CapAnnData(BaseLayerMatrixAndDf):
 
         for field in ["layers", "obsm", "varm", "obsp", "varp"]:
             if field in fields:
-                for key in field_to_entity[field].keys_to_remove:
+                for key in self.field_to_entity(field).keys_to_remove:
                     del self._file[f"{field}/{key}"]
 
     def create_layer(

{cap_anndata-0.3.1.dist-info → cap_anndata-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: cap_anndata
-Version: 0.3.1
+Version: 0.5.0
 Summary: Partial read/write of AnnData (h5ad) files for low-memory operations with large datasets.
 Home-page: https://github.com/cellannotation/cap-anndata
 Author: R. Mukhin, A. Isaev
@@ -14,15 +14,29 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy >=1.23.5
-Requires-Dist: pandas >=2.2.0
-Requires-Dist: anndata >=0.10.0
+Requires-Dist: numpy>=1.23.5
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: anndata>=0.10.0
 Provides-Extra: dev
-Requires-Dist: pytest >=8.0.0 ; extra == 'dev'
-Requires-Dist: setuptools ~=69.1.1 ; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: setuptools~=69.1.1; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # CAP-AnnData: Partial I/O for AnnData (.h5ad) Files
 
+[![PyPI version](https://img.shields.io/pypi/v/cap-anndata)](https://pypi.org/project/cap-anndata/) [![Build Status](https://github.com/cellannotation/cap-anndata/actions/workflows/python-app.yml/badge.svg)](https://github.com/cellannotation/cap-anndata/actions)
+
 ## Overview
 CAP-AnnData offering functionalities for selective reading and writing of [AnnData](https://pypi.org/project/anndata/) 
 file fields without the need for loading entire dataset (or even entire field) into memory. 

cap_anndata-0.5.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+cap_anndata/__init__.py,sha256=WRAQEDsWTvLbJWVUA5FmKCVrD2GN4oRd5I3c8jc9ajo,197
+cap_anndata/backed_df.py,sha256=2OVomvTY51V05sYwEXg-4JYBgd9iJCA2-Lt7nEAL1Ug,3255
+cap_anndata/backed_dict.py,sha256=Hb1SjnKuQ13mBUitQ5sL3kmcQ1j3GgB19r3yXkC0oIo,1019
+cap_anndata/cap_anndata.py,sha256=4sro4BIsaOuTBHrRXYCi0WlGtxsql_bnqIDEpT2tRhQ,21371
+cap_anndata/reader.py,sha256=UpZBCjaS4-K2w_9m6IuYetO9LwmEEJ5KvAw9aAoMRno,1609
+cap_anndata-0.5.0.dist-info/licenses/LICENSE,sha256=XXTH6JikkxH7Gqy9VEj4crSizuwxzv04ROzkQ-ZS6o4,1532
+cap_anndata-0.5.0.dist-info/METADATA,sha256=CbdJemeEOB1hIJ7tPrVOT7JldkVNOiJ6zkW8AFqTjqU,2825
+cap_anndata-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cap_anndata-0.5.0.dist-info/top_level.txt,sha256=GKi_Uk4LUhXwWBfFCTIyJvEoJqFREt_4uH4CWgeLsg4,12
+cap_anndata-0.5.0.dist-info/RECORD,,

{cap_anndata-0.3.1.dist-info → cap_anndata-0.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

cap_anndata-0.3.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-cap_anndata/__init__.py,sha256=WRAQEDsWTvLbJWVUA5FmKCVrD2GN4oRd5I3c8jc9ajo,197
-cap_anndata/backed_df.py,sha256=bMNsArbPjA-TN7eQB4-9Y2l3s8o03-dM4hPnOR9tROc,2622
-cap_anndata/backed_dict.py,sha256=Hb1SjnKuQ13mBUitQ5sL3kmcQ1j3GgB19r3yXkC0oIo,1019
-cap_anndata/cap_anndata.py,sha256=uQh49Kwu2cE4-ebgOvb78mMGA_afkZcsr71j6f8EX2I,20600
-cap_anndata/reader.py,sha256=UpZBCjaS4-K2w_9m6IuYetO9LwmEEJ5KvAw9aAoMRno,1609
-cap_anndata-0.3.1.dist-info/LICENSE,sha256=XXTH6JikkxH7Gqy9VEj4crSizuwxzv04ROzkQ-ZS6o4,1532
-cap_anndata-0.3.1.dist-info/METADATA,sha256=688YuF45IuOvu1Hqxbt_O1aeYkoMX4tjV0b2hb1WY8I,2304
-cap_anndata-0.3.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-cap_anndata-0.3.1.dist-info/top_level.txt,sha256=GKi_Uk4LUhXwWBfFCTIyJvEoJqFREt_4uH4CWgeLsg4,12
-cap_anndata-0.3.1.dist-info/RECORD,,