smftools 0.2.4__py3-none-any.whl → 0.3.0__py3-none-any.whl

smftools/readwrite.py

@@ -1,15 +1,14 @@
 ## readwrite ##
 from __future__ import annotations
 
+import warnings
 from pathlib import Path
-from typing import Union, Iterable
-
-from pathlib import Path
-from typing import Iterable, Sequence, Optional
+from typing import Iterable, List, Sequence, Union
 
-import warnings
-import pandas as pd
 import anndata as ad
+import pandas as pd
+from Bio import SeqIO
+
 
 ######################################################################################################
 ## Datetime functionality
@@ -18,20 +17,26 @@ def date_string():
     Each time this is called, it returns the current date string
     """
     from datetime import datetime
+
     current_date = datetime.now()
     date_string = current_date.strftime("%Y%m%d")
     date_string = date_string[2:]
     return date_string
 
+
 def time_string():
     """
     Each time this is called, it returns the current time string
     """
     from datetime import datetime
+
     current_time = datetime.now()
     return current_time.strftime("%H:%M:%S")
+
+
 ######################################################################################################
 
+
 ######################################################################################################
 ## General file and directory handling
 def make_dirs(directories: Union[str, Path, Iterable[Union[str, Path]]]) -> None:
@@ -57,11 +62,12 @@ def make_dirs(directories: Union[str, Path, Iterable[Union[str, Path]]]) -> None
         p = Path(d)
 
         # If someone passes in a file path, make its parent
-        if p.suffix:      # p.suffix != "" means it's a file
+        if p.suffix:  # p.suffix != "" means it's a file
             p = p.parent
 
         p.mkdir(parents=True, exist_ok=True)
 
+
 def add_or_update_column_in_csv(
     csv_path: str | Path,
     column_name: str,
@@ -117,19 +123,20 @@ def add_or_update_column_in_csv(
     # Sequence case: lengths must match
     if len(values) != len(df):
         raise ValueError(
-            f"Length mismatch: CSV has {len(df)} rows "
-            f"but values has {len(values)} entries."
+            f"Length mismatch: CSV has {len(df)} rows but values has {len(values)} entries."
         )
 
     df[column_name] = list(values)
     df.to_csv(csv_path, index=index)
     return df
 
+
 ######################################################################################################
 
 ######################################################################################################
 ## Numpy, Pandas, Anndata functionality
 
+
 def adata_to_df(adata, layer=None):
     """
     Convert an AnnData object into a Pandas DataFrame.
@@ -142,8 +149,6 @@ def adata_to_df(adata, layer=None):
         pd.DataFrame: A DataFrame where rows are observations and columns are positions.
     """
     import pandas as pd
-    import anndata as ad
-    import numpy as np
 
     # Validate that the requested layer exists
     if layer and layer not in adata.layers:
@@ -153,28 +158,83 @@ def adata_to_df(adata, layer=None):
     data_matrix = adata.layers.get(layer, adata.X)
 
     # Ensure matrix is dense (handle sparse formats)
-    if hasattr(data_matrix, "toarray"):  
+    if hasattr(data_matrix, "toarray"):
         data_matrix = data_matrix.toarray()
 
     # Ensure obs and var have unique indices
     if adata.obs.index.duplicated().any():
-        raise ValueError("Duplicate values found in `adata.obs.index`. Ensure unique observation indices.")
-    
+        raise ValueError(
+            "Duplicate values found in `adata.obs.index`. Ensure unique observation indices."
+        )
+
     if adata.var.index.duplicated().any():
-        raise ValueError("Duplicate values found in `adata.var.index`. Ensure unique variable indices.")
+        raise ValueError(
+            "Duplicate values found in `adata.var.index`. Ensure unique variable indices."
+        )
 
     # Convert to DataFrame
     df = pd.DataFrame(data_matrix, index=adata.obs.index, columns=adata.var.index)
 
     return df
 
+
 def save_matrix(matrix, save_name):
     """
     Input: A numpy matrix and a save_name
     Output: A txt file representation of the data matrix
     """
     import numpy as np
-    np.savetxt(f'{save_name}.txt', matrix)
+
+    np.savetxt(f"{save_name}.txt", matrix)
+
+
+def _harmonize_var_schema(adatas: List[ad.AnnData]) -> None:
+    """
+    In-place:
+      - Make every AnnData.var have the *union* of columns.
+      - Normalize dtypes so columns can hold NaN and round-trip via HDF5:
+          * ints -> float64 (to support NaN)
+          * objects -> try numeric->float64, else pandas 'string'
+    """
+    import numpy as np
+
+    # 1) Union of all .var columns
+    all_cols = set()
+    for a in adatas:
+        all_cols.update(a.var.columns)
+    all_cols = list(all_cols)
+
+    # 2) Add any missing columns as float64 NaN
+    for a in adatas:
+        missing = [c for c in all_cols if c not in a.var.columns]
+        for c in missing:
+            a.var[c] = np.nan  # becomes float64 by default
+
+    # 3) Normalize dtypes per AnnData so concat doesn't create mixed/object columns
+    for a in adatas:
+        for c in a.var.columns:
+            s = a.var[c]
+            dt = s.dtype
+
+            # Integer/unsigned -> float64 (so NaN fits)
+            if dt.kind in ("i", "u"):
+                a.var[c] = s.astype("float64")
+                continue
+
+            # Object -> numeric if possible; else pandas 'string'
+            if dt == "O":
+                try:
+                    s_num = pd.to_numeric(s, errors="raise")
+                    a.var[c] = s_num.astype("float64")
+                except Exception:
+                    a.var[c] = s.astype("string")
+
+    # Optional: ensure consistent column order (sorted + stable)
+    # Not required, but can make diffs easier to read:
+    all_cols_sorted = sorted(all_cols)
+    for a in adatas:
+        a.var = a.var.reindex(columns=all_cols_sorted)
+
 
 def concatenate_h5ads(
     output_path: str | Path,
@@ -243,8 +303,7 @@ def concatenate_h5ads(
         # collect all *.h5ad / *.h5ad.gz (or whatever file_suffixes specify)
         suffixes_lower = tuple(s.lower() for s in file_suffixes)
         h5_paths = sorted(
-            p for p in input_dir.iterdir()
-            if p.is_file() and p.suffix.lower() in suffixes_lower
+            p for p in input_dir.iterdir() if p.is_file() and p.suffix.lower() in suffixes_lower
         )
 
     else:
@@ -255,9 +314,7 @@ def concatenate_h5ads(
 
         df = pd.read_csv(csv_path, dtype=str)
         if csv_column not in df.columns:
-            raise ValueError(
-                f"CSV {csv_path} must contain column '{csv_column}' with .h5ad paths."
-            )
+            raise ValueError(f"CSV {csv_path} must contain column '{csv_column}' with .h5ad paths.")
         paths = df[csv_column].dropna().astype(str).tolist()
         if not paths:
             raise ValueError(f"No non-empty paths in column '{csv_column}' of {csv_path}.")
@@ -280,27 +337,41 @@ def concatenate_h5ads(
     for p in h5_paths:
         print(f"  - {p}")
 
-    final_adata: Optional[ad.AnnData] = None
-
+    # Load all first so we can harmonize schemas before concat
+    loaded: List[ad.AnnData] = []
     for p in h5_paths:
         print(f"{time_string()}: Reading {p}")
-        temp_adata, read_report = safe_read_h5ad(p, restore_backups=restore_backups)
-
-        if final_adata is None:
-            print(f"{time_string()}: Initializing final AnnData with {p}")
-            final_adata = temp_adata
-        else:
-            print(f"{time_string()}: Concatenating {p} into final AnnData")
-            final_adata = ad.concat(
-                [final_adata, temp_adata],
-                join="outer",
-                merge='unique',
-                uns_merge='unique',
-                index_unique=None,
-            )
+        a, _ = safe_read_h5ad(p, restore_backups=restore_backups)
+        loaded.append(a)
+
+    # Critical: make every .var share the same columns + safe dtypes
+    _harmonize_var_schema(loaded)
+
+    print(f"{time_string()}: Concatenating {len(loaded)} AnnData objects")
+    final_adata = ad.concat(
+        loaded,
+        axis=0,  # stack observations
+        join="outer",  # keep union of variables
+        merge="unique",
+        uns_merge="unique",
+        index_unique=None,
+    )
+
+    # Defensive pass: ensure final var dtypes are write-safe
+    for c in final_adata.var.columns:
+        s = final_adata.var[c]
+        dt = s.dtype
+        if dt.kind in ("i", "u"):
+            final_adata.var[c] = s.astype("float64")
+        elif dt == "O":
+            try:
+                s_num = pd.to_numeric(s, errors="raise")
+                final_adata.var[c] = s_num.astype("float64")
+            except Exception:
+                final_adata.var[c] = s.astype("string")
 
-    if final_adata is None:
-        raise RuntimeError("Unexpected: no AnnData objects loaded.")
+    # Let anndata write pandas StringArray reliably
+    ad.settings.allow_write_nullable_strings = True
 
     print(f"{time_string()}: Writing concatenated AnnData to {output_path}")
     safe_write_h5ad(final_adata, output_path, backup=restore_backups)
@@ -325,18 +396,21 @@ def concatenate_h5ads(
 
     return output_path
 
+
 def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=None, verbose=True):
     """
     Save an AnnData safely by sanitizing .obs, .var, .uns, .layers, and .obsm.
 
     Returns a report dict and prints a summary of what was converted/backed up/skipped.
     """
-    import os, json, pickle
+    import json
+    import os
+    import pickle
     from pathlib import Path
+
+    import anndata as _ad
     import numpy as np
     import pandas as pd
-    import warnings
-    import anndata as _ad
 
     path = Path(path)
 
@@ -413,7 +487,9 @@ def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=No
                             report["var_backed_up_columns"].append(col)
                     df[col] = ser.astype(str)
                     if verbose:
-                        print(f"  coerced categorical column '{which}.{col}' -> strings (backup={backup})")
+                        print(
+                            f"  coerced categorical column '{which}.{col}' -> strings (backup={backup})"
+                        )
                 continue
 
             # object dtype handling: try to coerce each element to string
@@ -434,7 +510,9 @@ def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=No
                             report["var_backed_up_columns"].append(col)
                     df[col] = ser.values.astype(str)
                     if verbose:
-                        print(f"  converted object column '{which}.{col}' -> strings (backup={backup})")
+                        print(
+                            f"  converted object column '{which}.{col}' -> strings (backup={backup})"
+                        )
                     if which == "obs":
                         report["obs_converted_columns"].append(col)
                     else:
@@ -457,7 +535,9 @@ def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=No
                                 report["var_backed_up_columns"].append(col)
                         df[col] = [json.dumps(v, default=str) for v in ser.values]
                         if verbose:
-                            print(f"  json-stringified object column '{which}.{col}' (backup={backup})")
+                            print(
+                                f"  json-stringified object column '{which}.{col}' (backup={backup})"
+                            )
                         if which == "obs":
                             report["obs_converted_columns"].append(col)
                         else:
@@ -472,7 +552,9 @@ def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=No
                                 report["var_backed_up_columns"].append(col)
                         df[col] = ser.astype(str)
                         if verbose:
-                            print(f"  WARNING: column '{which}.{col}' was complex; coerced via str() (backed up).")
+                            print(
+                                f"  WARNING: column '{which}.{col}' was complex; coerced via str() (backed up)."
+                            )
                         if which == "obs":
                             report["obs_converted_columns"].append(col)
                         else:
@@ -499,7 +581,9 @@ def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=No
                         _backup(v, f"uns_{k}_backup")
                     backed_up.append(k)
                     if verbose:
-                        print(f"  uns['{k}'] non-JSON -> stored '{k}_json' and backed up (backup={backup})")
+                        print(
+                            f"  uns['{k}'] non-JSON -> stored '{k}_json' and backed up (backup={backup})"
+                        )
                     report["uns_json_keys"].append(k)
                 except Exception:
                     try:
@@ -534,7 +618,9 @@ def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=No
                         arr_f = arr.astype(float)
                         cleaned[k] = arr_f
                         report_key = f"{which}.{k}"
-                        report["layers_converted"].append(report_key) if which == "layers" else report["obsm_converted"].append(report_key)
+                        report["layers_converted"].append(
+                            report_key
+                        ) if which == "layers" else report["obsm_converted"].append(report_key)
                         if verbose:
                             print(f"  {which}.{k} object array coerced to float.")
                     except Exception:
@@ -542,7 +628,9 @@ def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=No
                             arr_i = arr.astype(int)
                             cleaned[k] = arr_i
                             report_key = f"{which}.{k}"
-                            report["layers_converted"].append(report_key) if which == "layers" else report["obsm_converted"].append(report_key)
+                            report["layers_converted"].append(
+                                report_key
+                            ) if which == "layers" else report["obsm_converted"].append(report_key)
                             if verbose:
                                 print(f"  {which}.{k} object array coerced to int.")
                         except Exception:
@@ -553,7 +641,9 @@ def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=No
                             else:
                                 report["obsm_skipped"].append(k)
                             if verbose:
-                                print(f"  SKIPPING {which}.{k} (object dtype not numeric). Backed up: {backup}")
+                                print(
+                                    f"  SKIPPING {which}.{k} (object dtype not numeric). Backed up: {backup}"
+                                )
                             continue
                 else:
                     cleaned[k] = arr
@@ -638,7 +728,9 @@ def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=No
                 X_to_use = np.zeros_like(X_arr, dtype=float)
                 report["X_replaced_or_converted"] = "replaced_with_zeros_backup"
                 if verbose:
-                    print("adata.X had object dtype and couldn't be converted; replaced with zeros (backup set).")
+                    print(
+                        "adata.X had object dtype and couldn't be converted; replaced with zeros (backup set)."
+                    )
     except Exception as e:
         msg = f"Error handling adata.X: {e}"
         report["errors"].append(msg)
@@ -731,7 +823,7 @@ def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=No
             print(f"CSV outputs will be written to: {csv_dir}")
     except Exception as e:
         msg = f"Failed to create CSV output directory: {e}"
-        report['errors'].append(msg)
+        report["errors"].append(msg)
         if verbose:
             print(msg)
         csv_dir = path.parent  # fallback just in case
@@ -742,48 +834,58 @@ def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=No
 
         # obs columns
         for col in adata_copy.obs.columns:
-            meta_rows.append({
-                "kind": "obs",
-                "name": col,
-                "dtype": str(adata_copy.obs[col].dtype),
-            })
+            meta_rows.append(
+                {
+                    "kind": "obs",
+                    "name": col,
+                    "dtype": str(adata_copy.obs[col].dtype),
+                }
+            )
 
         # var columns
         for col in adata_copy.var.columns:
-            meta_rows.append({
-                "kind": "var",
-                "name": col,
-                "dtype": str(adata_copy.var[col].dtype),
-            })
+            meta_rows.append(
+                {
+                    "kind": "var",
+                    "name": col,
+                    "dtype": str(adata_copy.var[col].dtype),
+                }
+            )
 
         # layers
         for k, v in adata_copy.layers.items():
-            meta_rows.append({
-                "kind": "layer",
-                "name": k,
-                "dtype": str(np.asarray(v).dtype),
-            })
+            meta_rows.append(
+                {
+                    "kind": "layer",
+                    "name": k,
+                    "dtype": str(np.asarray(v).dtype),
+                }
+            )
 
         # obsm
         for k, v in adata_copy.obsm.items():
-            meta_rows.append({
-                "kind": "obsm",
-                "name": k,
-                "dtype": str(np.asarray(v).dtype),
-            })
+            meta_rows.append(
+                {
+                    "kind": "obsm",
+                    "name": k,
+                    "dtype": str(np.asarray(v).dtype),
+                }
+            )
 
         # uns
         for k, v in adata_copy.uns.items():
-            meta_rows.append({
-                "kind": "uns",
-                "name": k,
-                "dtype": type(v).__name__,
-            })
+            meta_rows.append(
+                {
+                    "kind": "uns",
+                    "name": k,
+                    "dtype": type(v).__name__,
+                }
+            )
 
         meta_df = pd.DataFrame(meta_rows)
 
         # same base name, inside csvs/
-        base = path.stem    # removes .h5ad
+        base = path.stem  # removes .h5ad
         meta_path = csv_dir / f"{base}.keys.csv"
 
         meta_df.to_csv(meta_path, index=False)
@@ -818,7 +920,15 @@ def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir=No
 
     return report
 
-def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=True, categorical_threshold=100, verbose=True):
+
+def safe_read_h5ad(
+    path,
+    backup_dir=None,
+    restore_backups=True,
+    re_categorize=True,
+    categorical_threshold=100,
+    verbose=True,
+):
     """
     Safely load an AnnData saved by safe_write_h5ad and attempt to restore complex objects
     from the backup_dir produced during save.
@@ -846,13 +956,14 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
         report : dict
             A report describing restored items, parsed JSON keys, and any failures.
     """
-    import os
-    from pathlib import Path
     import json
+    import os
     import pickle
+    from pathlib import Path
+
+    import anndata as _ad
     import numpy as np
     import pandas as pd
-    import anndata as _ad
 
     path = Path(path)
 
@@ -931,7 +1042,9 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
                         if hasattr(val, "shape") and (len(val) == adata.shape[0]):
                             adata.obs[col] = pd.Series(val, index=adata.obs.index)
                         else:
-                            adata.obs[col] = pd.Series([val] * adata.shape[0], index=adata.obs.index)
+                            adata.obs[col] = pd.Series(
+                                [val] * adata.shape[0], index=adata.obs.index
+                            )
                         report["restored_obs_columns"].append((col, bname1))
                         restored = True
                         if verbose:
@@ -946,7 +1059,9 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
             looks_like_json = False
             for sv in sample_vals:
                 svs = sv.strip()
-                if (svs.startswith("{") and svs.endswith("}")) or (svs.startswith("[") and svs.endswith("]")):
+                if (svs.startswith("{") and svs.endswith("}")) or (
+                    svs.startswith("[") and svs.endswith("]")
+                ):
                     looks_like_json = True
                     break
             if looks_like_json:
@@ -964,7 +1079,9 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
                     report["restored_obs_columns"].append((col, "parsed_json"))
                     restored = True
                     if verbose:
-                        print(f"[safe_read_h5ad] parsed obs.{col} JSON strings back to Python objects")
+                        print(
+                            f"[safe_read_h5ad] parsed obs.{col} JSON strings back to Python objects"
+                        )
 
         # If still not restored and re_categorize=True, try to convert small unique string columns back to categorical
         if (not restored) and re_categorize and adata.obs[col].dtype == object:
@@ -975,7 +1092,9 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
                     adata.obs[col] = adata.obs[col].astype(str).astype("category")
                     report["recategorized_obs"].append(col)
                     if verbose:
-                        print(f"[safe_read_h5ad] recast obs.{col} -> categorical (n_unique={nunique})")
+                        print(
+                            f"[safe_read_h5ad] recast obs.{col} -> categorical (n_unique={nunique})"
+                        )
             except Exception as e:
                 report["errors"].append(f"Failed to recategorize obs.{col}: {e}")
 
@@ -1007,7 +1126,9 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
                         if hasattr(val, "shape") and (len(val) == adata.shape[1]):
                             adata.var[col] = pd.Series(val, index=adata.var.index)
                         else:
-                            adata.var[col] = pd.Series([val] * adata.shape[1], index=adata.var.index)
+                            adata.var[col] = pd.Series(
+                                [val] * adata.shape[1], index=adata.var.index
+                            )
                         report["restored_var_columns"].append((col, bname1))
                         restored = True
                         if verbose:
@@ -1021,7 +1142,9 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
             looks_like_json = False
             for sv in sample_vals:
                 svs = sv.strip()
-                if (svs.startswith("{") and svs.endswith("}")) or (svs.startswith("[") and svs.endswith("]")):
+                if (svs.startswith("{") and svs.endswith("}")) or (
+                    svs.startswith("[") and svs.endswith("]")
+                ):
                     looks_like_json = True
                     break
             if looks_like_json:
@@ -1037,7 +1160,9 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
                     adata.var[col] = pd.Series(parsed, index=adata.var.index)
                     report["restored_var_columns"].append((col, "parsed_json"))
                     if verbose:
-                        print(f"[safe_read_h5ad] parsed var.{col} JSON strings back to Python objects")
+                        print(
+                            f"[safe_read_h5ad] parsed var.{col} JSON strings back to Python objects"
+                        )
 
         if (not restored) and re_categorize and adata.var[col].dtype == object:
             try:
@@ -1046,7 +1171,9 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
                     adata.var[col] = adata.var[col].astype(str).astype("category")
                     report["recategorized_var"].append(col)
                     if verbose:
-                        print(f"[safe_read_h5ad] recast var.{col} -> categorical (n_unique={nunique})")
+                        print(
+                            f"[safe_read_h5ad] recast var.{col} -> categorical (n_unique={nunique})"
+                        )
             except Exception as e:
                 report["errors"].append(f"Failed to recategorize var.{col}: {e}")
 
@@ -1078,7 +1205,7 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
         if not fname.startswith("uns_") or not fname.endswith("_backup.pkl"):
             continue
         # fname example: "uns_clustermap_results_backup.pkl" -> key name between 'uns_' and '_backup.pkl'
-        key = fname[len("uns_"):-len("_backup.pkl")]
+        key = fname[len("uns_") : -len("_backup.pkl")]
         full = os.path.join(backup_dir, fname)
         val = _load_pickle_if_exists(full)
         if val is not None:
@@ -1092,7 +1219,7 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
     if os.path.isdir(backup_dir):
         for fname in os.listdir(backup_dir):
             if fname.startswith("layers_") and fname.endswith("_backup.pkl"):
-                layer_name = fname[len("layers_"):-len("_backup.pkl")]
+                layer_name = fname[len("layers_") : -len("_backup.pkl")]
                 full = os.path.join(backup_dir, fname)
                 val = _load_pickle_if_exists(full)
                 if val is not None:
@@ -1102,10 +1229,12 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
                         if verbose:
                             print(f"[safe_read_h5ad] restored layers['{layer_name}'] from {full}")
                     except Exception as e:
-                        report["errors"].append(f"Failed to restore layers['{layer_name}'] from {full}: {e}")
+                        report["errors"].append(
+                            f"Failed to restore layers['{layer_name}'] from {full}: {e}"
+                        )
 
             if fname.startswith("obsm_") and fname.endswith("_backup.pkl"):
-                obsm_name = fname[len("obsm_"):-len("_backup.pkl")]
+                obsm_name = fname[len("obsm_") : -len("_backup.pkl")]
                 full = os.path.join(backup_dir, fname)
                 val = _load_pickle_if_exists(full)
                 if val is not None:
@@ -1115,7 +1244,9 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
                         if verbose:
                             print(f"[safe_read_h5ad] restored obsm['{obsm_name}'] from {full}")
                     except Exception as e:
-                        report["errors"].append(f"Failed to restore obsm['{obsm_name}'] from {full}: {e}")
+                        report["errors"].append(
+                            f"Failed to restore obsm['{obsm_name}'] from {full}: {e}"
+                        )
 
     # 6) If restore_backups True but some expected backups missing, note them
     if restore_backups and os.path.isdir(backup_dir):
@@ -1145,7 +1276,9 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
         if expected_missing and verbose:
             n = len(expected_missing)
             if verbose:
-                print(f"[safe_read_h5ad] note: {n} obs/var object columns may not have backups; check if their content is acceptable.")
+                print(
+                    f"[safe_read_h5ad] note: {n} obs/var object columns may not have backups; check if their content is acceptable."
+                )
             # add to report
             report["missing_backups"].extend(expected_missing)
 
@@ -1165,9 +1298,16 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
         if report["restored_obsm"]:
             print("Restored obsm:", report["restored_obsm"])
         if report["recategorized_obs"] or report["recategorized_var"]:
-            print("Recategorized columns (obs/var):", report["recategorized_obs"], report["recategorized_var"])
+            print(
+                "Recategorized columns (obs/var):",
+                report["recategorized_obs"],
+                report["recategorized_var"],
+            )
         if report["missing_backups"]:
-            print("Missing backups or object columns without backups (investigate):", report["missing_backups"])
+            print(
+                "Missing backups or object columns without backups (investigate):",
+                report["missing_backups"],
+            )
         if report["errors"]:
             print("Errors encountered (see report['errors']):")
             for e in report["errors"]:
@@ -1176,9 +1316,10 @@ def safe_read_h5ad(path, backup_dir=None, restore_backups=True, re_categorize=Tr
 
     return adata, report
 
+
 def merge_barcoded_anndatas_core(adata_single, adata_double):
-    import numpy as np
     import anndata as ad
+    import numpy as np
 
     # Step 1: Identify overlap
     overlap = np.intersect1d(adata_single.obs_names, adata_double.obs_names)
@@ -1187,24 +1328,25 @@ def merge_barcoded_anndatas_core(adata_single, adata_double):
     adata_single_filtered = adata_single[~adata_single.obs_names.isin(overlap)].copy()
 
     # Step 3: Add source tag
-    adata_single_filtered.obs['source'] = 'single_barcode'
-    adata_double.obs['source'] = 'double_barcode'
+    adata_single_filtered.obs["source"] = "single_barcode"
+    adata_double.obs["source"] = "double_barcode"
 
     # Step 4: Concatenate all components
-    adata_merged = ad.concat([
-        adata_single_filtered,
-        adata_double
-    ], join='outer', merge='same')  # merge='same' preserves matching layers, obsm, etc.
+    adata_merged = ad.concat(
+        [adata_single_filtered, adata_double], join="outer", merge="same"
+    )  # merge='same' preserves matching layers, obsm, etc.
 
     # Step 5: Merge `.uns`
     adata_merged.uns = {**adata_single.uns, **adata_double.uns}
 
     return adata_merged
+
+
 ######################################################################################################
 
 ### File conversion misc ###
-import argparse
-from Bio import SeqIO
+
+
 def genbank_to_gff(genbank_file, output_file, record_id):
     with open(output_file, "w") as out:
         for record in SeqIO.parse(genbank_file, "genbank"):
@@ -1220,5 +1362,18 @@ def genbank_to_gff(genbank_file, output_file, record_id):
                 # Format attributes
                 attributes = ";".join(f"{k}={v}" for k, v in feature.qualifiers.items())
                 # Write GFF3 line
-                gff3_line = "\t".join(str(x) for x in [record_id, feature.type, feature_type, start, end, ".", strand, ".", attributes])
-                out.write(gff3_line + "\n")
+                gff3_line = "\t".join(
+                    str(x)
+                    for x in [
+                        record_id,
+                        feature.type,
+                        feature_type,
+                        start,
+                        end,
+                        ".",
+                        strand,
+                        ".",
+                        attributes,
+                    ]
+                )
+                out.write(gff3_line + "\n")