recode-h5ad 0.1.0__tar.gz

recode_h5ad-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: recode_h5ad
+Version: 0.1.0
+Summary: Recode H5AD file changing sparsity format and cell sorting
+Author-email: Gabriel Hoffman <gabriel.hoffman@gmail.com>
+Project-URL: Homepage, https://github.com/GabrielHoffman/recode_h5ad
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+
+We developed the recode_h5ad script that uses the AnnData library in order to:
+
+- Convert read count matrix to gene-major format
+- Sort cells by annotated class and biological sample identifier
+- Create variable libSize storing the number of reads for each cell. If raw/X exists, computed from this. Otherwise computed from X
+- Write to new H5AD file using LZF compression
+
+The result is a valid H5AD file supported by standard tools, but just optimized for gene-centric access.
+
+Here, we download the script and examine the arguments:
+
+```sh
+recode_h5ad -h
+usage: recode_h5ad [-h] --input INPUT --output OUTPUT [--ondisk]
+                   [--sortBy SORTBY] [--compression {None,None,gzip,lzf,zstd}]
+                   [--format {CSR,CSC}] [--noLibSize]
+
+Convert an AnnData .h5ad file so that X (and raw/X) is stored in CSC sparse
+format (v aug.26.2026)
+
+options:
+  -h, --help            show this help message and exit
+  --input INPUT         Input .h5ad file
+  --output OUTPUT       Output .h5ad file
+  --ondisk              Use file-backed mode to reduce memory usage
+  --sortBy SORTBY       Cols to sort by in _decreasing_ order of importance
+  --compression {None,None,gzip,lzf,zstd}
+                        Optional compression for output file (gzip, lzf,
+                        zstd). Default: None
+  --format {CSR,CSC}    Store sparse count matrix (X and raw/X) in CSR or CSC
+                        format. CSR allows faster access to cells, CSC gives
+                        faster access to genes. Default: CSR
+  --noLibSize           Skip computing libSize for each cell
+```
+
+### Example
+Now, we convert an H5AD file to CSC (i.e. gene-major) format, sorting the cells by class, subclass and SampleID, and saving using LZF compression.
+
+```bash
+# H5AD=(Original H5AD file)
+# OUTFILE=(New H5AD file)
+
+recode_h5ad.py \
+  --input $H5AD \
+  --sortBy class,subclass,SampleID \
+  --format CSC \
+  --compression lzf \
+  --out $OUTFILE
+```

recode_h5ad-0.1.0/README.md

@@ -0,0 +1,50 @@
+
+We developed the recode_h5ad script that uses the AnnData library in order to:
+
+- Convert read count matrix to gene-major format
+- Sort cells by annotated class and biological sample identifier
+- Create variable libSize storing the number of reads for each cell. If raw/X exists, computed from this. Otherwise computed from X
+- Write to new H5AD file using LZF compression
+
+The result is a valid H5AD file supported by standard tools, but just optimized for gene-centric access.
+
+Here, we download the script and examine the arguments:
+
+```sh
+recode_h5ad -h
+usage: recode_h5ad [-h] --input INPUT --output OUTPUT [--ondisk]
+                   [--sortBy SORTBY] [--compression {None,None,gzip,lzf,zstd}]
+                   [--format {CSR,CSC}] [--noLibSize]
+
+Convert an AnnData .h5ad file so that X (and raw/X) is stored in CSC sparse
+format (v aug.26.2026)
+
+options:
+  -h, --help            show this help message and exit
+  --input INPUT         Input .h5ad file
+  --output OUTPUT       Output .h5ad file
+  --ondisk              Use file-backed mode to reduce memory usage
+  --sortBy SORTBY       Cols to sort by in _decreasing_ order of importance
+  --compression {None,None,gzip,lzf,zstd}
+                        Optional compression for output file (gzip, lzf,
+                        zstd). Default: None
+  --format {CSR,CSC}    Store sparse count matrix (X and raw/X) in CSR or CSC
+                        format. CSR allows faster access to cells, CSC gives
+                        faster access to genes. Default: CSR
+  --noLibSize           Skip computing libSize for each cell
+```
+
+### Example
+Now, we convert an H5AD file to CSC (i.e. gene-major) format, sorting the cells by class, subclass and SampleID, and saving using LZF compression.
+
+```bash
+# H5AD=(Original H5AD file)
+# OUTFILE=(New H5AD file)
+
+recode_h5ad.py \
+  --input $H5AD \
+  --sortBy class,subclass,SampleID \
+  --format CSC \
+  --compression lzf \
+  --out $OUTFILE
+```

recode_h5ad-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0", "anndata>=0.13.0", "hdf5plugin>=7.0.0", "argparse", "numpy", "scipy", "pathlib", "importlib", "packaging"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "recode_h5ad"
+version = "0.1.0"
+authors = [
+  { name="Gabriel Hoffman", email="gabriel.hoffman@gmail.com" },
+]
+description = "Recode H5AD file changing sparsity format and cell sorting"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.scripts]
+recode_h5ad = "recode_h5ad.main:main"
+
+[project.urls]
+Homepage = "https://github.com/GabrielHoffman/recode_h5ad"
+

recode_h5ad-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

recode_h5ad-0.1.0/src/recode_h5ad/main.py

@@ -0,0 +1,184 @@
+##!/usr/bin/env python3
+
+import sys
+import argparse
+import anndata as ad
+import numpy as np
+import scipy.sparse as sp
+from pathlib import Path
+import importlib
+from packaging.version import parse
+import hdf5plugin
+
+def main():
+
+  # Define arguments
+  #-------------------
+
+  parser = argparse.ArgumentParser(
+      description="Convert an AnnData .h5ad file so that X (and raw/X) is stored in CSC sparse format (v aug.26.2026)"
+  )
+
+  parser.add_argument("--input",
+      type=Path, 
+      required=True,
+      help="Input .h5ad file")
+
+  parser.add_argument("--output",      
+      type=Path, 
+      required=True,
+      help="Output .h5ad file")
+
+  parser.add_argument("--ondisk", 
+      action="store_true",
+      help="Use file-backed mode to reduce memory usage")
+
+  parser.add_argument("--sortBy", 
+      default=None,
+      help="Cols to sort by in _decreasing_ order of importance")
+
+  parser.add_argument(
+      "--compression",
+      default=None,
+      choices=[None, "None", "gzip", "lzf", "zstd"],
+      help="Optional compression for output file (gzip, lzf, zstd). Default: None")
+
+  parser.add_argument(
+      "--format",
+      default="CSR",
+      choices=["CSR", "CSC"],
+      help="Store sparse count matrix (X and raw/X) in CSR or CSC format.  CSR allows faster access to cells, CSC gives faster access to genes. Default: CSR")
+
+  parser.add_argument("--noLibSize", 
+      action="store_true",
+      help="Skip computing libSize for each cell")
+
+  # parse args
+  args = parser.parse_args()
+
+  # if --ondisk set backed to "r"
+  backed = None
+  if args.ondisk:
+    backed = "r"
+
+  if args.compression == "None":
+    args.compression = None
+
+  print("Script version:", "aug.26.2026")
+
+  version = importlib.metadata.version("anndata")
+  print("AnnData version:", version) 
+
+  if parse(version) >= parse("0.13.0"):
+    # for compatibility with anndataR
+    ad.settings.allow_write_nullable_strings = False
+
+  # read file
+  print("Read file...") 
+  adata = ad.read_h5ad(args.input, backed=backed) 
+
+  # Replace forward slashes in column names of data.obs
+  adata.obs.columns = adata.obs.columns.str.replace("/", "_", regex=False)
+
+  # Find counts entry
+  if adata.X is not None:
+      print("Using AnnData X matrix...")
+  else:
+    if 'X' in adata.layers: 
+      print("Using AnnData layers/X matrix...")
+      adata.X = adata.layers['X']
+    elif 'counts' in adata.layers: 
+      print("Using AnnData layers/counts matrix...")
+      adata.X = adata.layers['counts']
+
+  # sort cells by type  
+  if args.sortBy != None:
+
+    print("Sorting...") 
+    fields = args.sortBy.split(",")
+
+    # check if all fields are present
+    missing = set(fields) - set(adata.obs.columns)
+
+    if missing:
+      print(f"Missing columns: {missing}")
+      sys.exit(2)     
+
+    # get sorted order
+    # reverse since 1st sorted index is the last one for lexsort
+    idx = np.lexsort( 
+      keys = tuple(adata.obs[c].to_numpy() for c in fields[::-1]) )
+
+    # apply reordering
+    adata = adata[idx,:]
+
+  if args.format == "CSC":
+
+    if not args.noLibSize or not sp.isspmatrix_csc(adata.X):
+      if backed is None:
+        adata = adata.copy()
+      else:
+        adata = adata.to_memory()
+
+    if not args.noLibSize:
+      # compute library size for each cell
+      print("Compute libSize...")
+      if adata.raw is not None:
+        adata.obs['libSize'] = adata.raw.X.sum(axis=1)
+      else:
+        adata.obs['libSize'] = adata.X.sum(axis=1)
+
+    # if matrix is not a CSC of doubles
+    if not (sp.isspmatrix_csc(adata.X) and adata.X.dtype == np.float64):
+      print("Converting .X to CSC sparse format...")
+      # convert matrix type
+      adata.X = sp.csc_matrix(adata.X, dtype=np.float64)
+
+      if adata.raw is not None:
+        print("Converting .row.X to CSC sparse format...")
+        raw = adata.raw.to_adata()
+        raw.X = sp.csc_matrix(raw.X, dtype=np.float64)
+        adata.raw = raw
+
+  if args.format == "CSR":
+    # X
+    if not sp.isspmatrix_csr(adata.X):
+      print("Converting .X to CSR sparse format...")
+      if backed is None:
+        adata = adata.copy()
+      else:
+        adata = adata.to_memory()
+      
+      # convert matrix type
+      adata.X = sp.csr_matrix(adata.X, dtype=np.float64)
+
+      if adata.raw is not None:
+        print("Converting .row.X to CSR sparse format...")
+        raw = adata.raw.to_adata()
+        raw.X = sp.csr_matrix(raw.X, dtype=np.float64)
+        adata.raw = raw
+
+      if not args.noLibSize:
+        # compute library size for each cell
+        print("Compute libSize...")
+        if adata.raw is not None:
+          adata.obs['libSize'] = adata.raw.X.sum(axis=1)
+        else:
+          adata.obs['libSize'] = adata.X.sum(axis=1)
+
+  if args.output.is_file():
+    args.output.unlink(missing_ok=True)
+
+  print("Writing H5AD...") 
+
+  compressMethod = args.compression
+
+  if compressMethod == "zstd":
+    compressMethod = hdf5plugin.FILTERS["zstd"]
+
+  adata.write_h5ad( args.output, compression=compressMethod )
+
+
+
+if __name__ == "__main__":
+  main()

recode_h5ad-0.1.0/src/recode_h5ad.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: recode_h5ad
+Version: 0.1.0
+Summary: Recode H5AD file changing sparsity format and cell sorting
+Author-email: Gabriel Hoffman <gabriel.hoffman@gmail.com>
+Project-URL: Homepage, https://github.com/GabrielHoffman/recode_h5ad
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+
+We developed the recode_h5ad script that uses the AnnData library in order to:
+
+- Convert read count matrix to gene-major format
+- Sort cells by annotated class and biological sample identifier
+- Create variable libSize storing the number of reads for each cell. If raw/X exists, computed from this. Otherwise computed from X
+- Write to new H5AD file using LZF compression
+
+The result is a valid H5AD file supported by standard tools, but just optimized for gene-centric access.
+
+Here, we download the script and examine the arguments:
+
+```sh
+recode_h5ad -h
+usage: recode_h5ad [-h] --input INPUT --output OUTPUT [--ondisk]
+                   [--sortBy SORTBY] [--compression {None,None,gzip,lzf,zstd}]
+                   [--format {CSR,CSC}] [--noLibSize]
+
+Convert an AnnData .h5ad file so that X (and raw/X) is stored in CSC sparse
+format (v aug.26.2026)
+
+options:
+  -h, --help            show this help message and exit
+  --input INPUT         Input .h5ad file
+  --output OUTPUT       Output .h5ad file
+  --ondisk              Use file-backed mode to reduce memory usage
+  --sortBy SORTBY       Cols to sort by in _decreasing_ order of importance
+  --compression {None,None,gzip,lzf,zstd}
+                        Optional compression for output file (gzip, lzf,
+                        zstd). Default: None
+  --format {CSR,CSC}    Store sparse count matrix (X and raw/X) in CSR or CSC
+                        format. CSR allows faster access to cells, CSC gives
+                        faster access to genes. Default: CSR
+  --noLibSize           Skip computing libSize for each cell
+```
+
+### Example
+Now, we convert an H5AD file to CSC (i.e. gene-major) format, sorting the cells by class, subclass and SampleID, and saving using LZF compression.
+
+```bash
+# H5AD=(Original H5AD file)
+# OUTFILE=(New H5AD file)
+
+recode_h5ad.py \
+  --input $H5AD \
+  --sortBy class,subclass,SampleID \
+  --format CSC \
+  --compression lzf \
+  --out $OUTFILE
+```

recode_h5ad-0.1.0/src/recode_h5ad.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/recode_h5ad/__init__.py
+src/recode_h5ad/main.py
+src/recode_h5ad.egg-info/PKG-INFO
+src/recode_h5ad.egg-info/SOURCES.txt
+src/recode_h5ad.egg-info/dependency_links.txt
+src/recode_h5ad.egg-info/entry_points.txt
+src/recode_h5ad.egg-info/top_level.txt

recode_h5ad-0.1.0/src/recode_h5ad.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

recode_h5ad-0.1.0/src/recode_h5ad.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+recode_h5ad = recode_h5ad.main:main

recode_h5ad-0.1.0/src/recode_h5ad.egg-info/top_level.txt

@@ -0,0 +1 @@
+recode_h5ad