omicverse 2.2.2__tar.gz → 2.2.3__tar.gz

{omicverse-2.2.2/omicverse.egg-info → omicverse-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omicverse
-Version: 2.2.2
+Version: 2.2.3
 Summary: OmicVerse: A single pipeline for exploring the entire transcriptome universe
 Author-email: Zehua Zeng <starlitnightly@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{omicverse-2.2.2 → omicverse-2.2.3}/omicverse/_registry.py

@@ -74,6 +74,26 @@ class FunctionRegistry:
         self._registry: Dict[str, Dict[str, Any]] = {}
         self._function_map: Dict[Callable, str] = {}  # Maps functions to their primary keys
         self._categories: Dict[str, List[str]] = {}  # Category to function mapping
+        self._hydrated: bool = False  # Whether full module hydration has run
+
+    def _ensure_hydrated(self) -> None:
+        """Force-import OmicVerse submodules once so queries see all functions.
+
+        The registry is populated lazily through ``@register_function`` import
+        side effects, so a fresh process that only did ``import omicverse`` sees
+        a near-empty registry. Run the export hydration pass on first query and
+        memoize it. The flag is set *before* hydrating to guard against
+        re-entrancy if a submodule import triggers another query.
+        """
+        if self._hydrated:
+            return
+        self._hydrated = True
+        try:
+            _hydrate_registry_for_export()
+        except Exception:
+            # Never let a hydration hiccup break a lookup — partial registry is
+            # still better than crashing the query path.
+            pass
 
     def _store_entry(
         self,
@@ -624,6 +644,7 @@ class FunctionRegistry:
         List[Dict[str, Any]]
             List of matching function entries, sorted by relevance
         """
+        self._ensure_hydrated()
         query_lower = query.lower()
         results = []
         

{omicverse-2.2.2 → omicverse-2.2.3}/omicverse/utils/ovagent/registry_scanner.py

@@ -90,11 +90,19 @@ class RegistryScanner:
         runtime.
         """
 
-        if getattr(_global_registry, "_registry", None):
+        # A partially-populated registry (e.g. just the handful of functions
+        # whose modules happened to import at ``import omicverse`` time) must
+        # NOT skip full hydration — otherwise every lookup only ever sees those
+        # few. Gate on a *hydration-done* memo, not on emptiness.
+        if getattr(_global_registry, "_hydrated", False):
             return
 
         try:
-            _hydrate_registry_for_export()
+            ensure = getattr(_global_registry, "_ensure_hydrated", None)
+            if callable(ensure):
+                ensure()
+            else:
+                _hydrate_registry_for_export()
         except Exception:
             logger.warning(
                 "Failed to hydrate the runtime registry via full package import",

{omicverse-2.2.2 → omicverse-2.2.3/omicverse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omicverse
-Version: 2.2.2
+Version: 2.2.3
 Summary: OmicVerse: A single pipeline for exploring the entire transcriptome universe
 Author-email: Zehua Zeng <starlitnightly@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{omicverse-2.2.2 → omicverse-2.2.3}/omicverse.egg-info/SOURCES.txt

@@ -65,7 +65,6 @@ omicverse/bulk/_network.py
 omicverse/bulk/_ora.py
 omicverse/bulk/_tcga.py
 omicverse/bulk/_wgcna.py
-omicverse/bulk/.ipynb_checkpoints/_wgcna-checkpoint.py
 omicverse/bulk/_alignment/__init__.py
 omicverse/bulk2single/__init__.py
 omicverse/bulk2single/_bulk2single.py
@@ -820,10 +819,6 @@ omicverse/external/scTenifold/core/_networks.py
 omicverse/external/scTenifold/core/_norm.py
 omicverse/external/scTenifold/core/_types.py
 omicverse/external/scTenifold/core/_utils.py
-omicverse/external/scTenifold/data/__init__.py
-omicverse/external/scTenifold/data/_get.py
-omicverse/external/scTenifold/data/_io.py
-omicverse/external/scTenifold/data/_sim.py
 omicverse/external/scTenifold/plotting/__init__.py
 omicverse/external/scTenifold/plotting/_dim_reduction.py
 omicverse/external/scTenifold/plotting/_plotting.py

{omicverse-2.2.2 → omicverse-2.2.3}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "omicverse"
-version = "2.2.2"
+version = "2.2.3"
 description = "OmicVerse: A single pipeline for exploring the entire transcriptome universe"
 readme = "README.md"
 requires-python = ">=3.9"

omicverse-2.2.2/omicverse/bulk/.ipynb_checkpoints/_wgcna-checkpoint.py

@@ -1,138 +0,0 @@
-"""Weighted Gene Co-expression Network Analysis registry shim.
-
-The full implementation lives in :mod:`omicverse.external.PyWGCNA` (vendored
-from the upstream PyWGCNA package). The registry scanner intentionally
-ignores everything under ``external/`` to keep third-party code out of the
-public API surface, so a class registered there is invisible to
-``ov.utils.registry_lookup``.
-
-This module re-publishes :class:`pyWGCNA` under the canonical
-``ov.bulk.pyWGCNA`` namespace and attaches the ``@register_function``
-metadata that the scanner indexes — making the function discoverable to
-agents searching for ``"wgcna"`` / ``"co-expression"`` / similar queries.
-The runtime behaviour is identical to ``ov.external.PyWGCNA.wgcna.pyWGCNA``;
-this is purely a discovery shim.
-"""
-
-from __future__ import annotations
-
-from .._registry import register_function
-
-# Real implementation. Imported under an alias so we can publish a
-# decorated ``pyWGCNA`` symbol whose AST signature the scanner can pick up.
-from ..external.PyWGCNA.wgcna import pyWGCNA as _pyWGCNA_impl
-from ..external.PyWGCNA.utils import readWGCNA as _readWGCNA_impl
-
-
-@register_function(
-    aliases=[
-        "pyWGCNA",
-        "WGCNA",
-        "wgcna",
-        "wgcna_analysis",
-        "co-expression network",
-        "gene co-expression",
-        "weighted gene co-expression network analysis",
-        "module detection",
-        "WGCNA分析",
-        "加权基因共表达网络",
-    ],
-    category="bulk",
-    description=(
-        "Weighted Gene Co-expression Network Analysis. Detects co-expression "
-        "modules from a samples × genes expression matrix, computes module "
-        "eigengenes and module-trait correlations. Wraps the vendored "
-        "PyWGCNA implementation."
-    ),
-    examples=[
-        "import omicverse as ov, pandas as pd",
-        "data = pd.read_csv('expressionList.csv', index_col=0)  # rows=samples, cols=genes",
-        "wgcna = ov.bulk.pyWGCNA(name='MyAnalysis', species='mus musculus', geneExp=data.T, save=True)",
-        "wgcna.preprocess()       # filter low-expressed genes / outlier samples",
-        "wgcna.findModules()      # soft-threshold + dynamic tree cut",
-        "wgcna.analyseWGCNA()     # module-trait correlations against sample metadata",
-    ],
-    related=["ov.bulk.readWGCNA", "ov.bulk.pyDEG", "ov.bulk.geneset_enrichment"],
-)
-class pyWGCNA(_pyWGCNA_impl):
-    """Weighted Gene Co-expression Network Analysis.
-
-    Identifies highly co-expressed gene modules and relates them to clinical
-    traits / sample metadata. Standard WGCNA workflow:
-
-    1. **Preprocess** — remove low-expressed genes (TPM cutoff) and outlier
-       samples (Euclidean distance to mean).
-    2. **Soft-thresholding** — pick a power that yields scale-free topology
-       in the gene-gene correlation network.
-    3. **Adjacency + TOM** — adjacency = ``|cor|^power``; topological
-       overlap matrix (TOM) measures shared neighbourhood.
-    4. **Dynamic tree cut** — hierarchical clustering on ``1 - TOM``; tree
-       cut yields gene modules (named by colour).
-    5. **Module eigengenes** — first principal component of each module's
-       expression matrix.
-    6. **Module-trait correlation** — Pearson correlation of each module
-       eigengene against numeric sample traits, with FDR-corrected p-values.
-
-    Parameters
-    ----------
-    name : str
-        Analysis label, used for output file names.
-    species : str
-        Organism (e.g. ``"mus musculus"``, ``"homo sapiens"``).
-    geneExp : pandas.DataFrame
-        Expression matrix shaped (genes × samples). Sample identifiers are
-        the column names, gene identifiers are the index. Note this is the
-        TRANSPOSE of the typical samples × genes layout used by AnnData.
-    TPMcutoff : float, default 1
-        Per-gene TPM threshold; genes whose maximum across samples falls
-        below this are dropped during ``preprocess``.
-    powers : list[int], optional
-        Candidate soft-threshold powers. Defaults to a 1–30 sweep.
-    networkType : {"signed", "unsigned", "signed hybrid"}
-        How adjacency is computed from correlation.
-    minModuleSize : int, default 50
-        Smallest module size kept by the dynamic tree cut.
-    save : bool, default False
-        Whether to persist results to disk.
-
-    Notes
-    -----
-    Wide expression CSVs are usually shaped samples × genes; remember to
-    pass ``data.T`` so the constructor receives genes × samples.
-
-    Inputs
-    ------
-    - ``geneExp``: ``pandas.DataFrame`` (genes × samples)
-    - sample-trait metadata: optional ``pandas.DataFrame`` indexed by
-      sample id, used by ``analyseWGCNA``.
-
-    Outputs
-    -------
-    - ``self.datExpr.var['moduleColors']``: per-gene module colour string.
-    - ``self.MEs``: module eigengene matrix (samples × modules).
-    - ``self.moduleTraitCor`` / ``self.moduleTraitPvalue``: module × trait
-      correlation tables (after ``analyseWGCNA``).
-
-    Examples
-    --------
-    >>> import pandas as pd, omicverse as ov
-    >>> data = pd.read_csv('expressionList.csv', index_col=0)
-    >>> wgcna = ov.bulk.pyWGCNA(
-    ...     name='5xFAD',
-    ...     species='mus musculus',
-    ...     geneExp=data.T,            # transpose to genes × samples
-    ...     TPMcutoff=1,
-    ...     networkType='signed hybrid',
-    ... )
-    >>> wgcna.preprocess()
-    >>> wgcna.findModules()
-    """
-
-
-# `readWGCNA` is a function, not a class — re-export under the same name.
-# Aliased here so the bulk namespace exposes it without round-tripping
-# through `external/`.
-readWGCNA = _readWGCNA_impl
-
-
-__all__ = ["pyWGCNA", "readWGCNA"]

omicverse-2.2.2/omicverse/external/scTenifold/data/__init__.py

@@ -1,6 +0,0 @@
-from ._io import *
-from ._sim import *
-from ._get import *
-
-
-__all__ = ["read_mtx", "read_folder", "get_test_df", "TestDataGenerator", "list_data", "fetch_data"]

omicverse-2.2.2/omicverse/external/scTenifold/data/_get.py

@@ -1,122 +0,0 @@
-from typing import Dict, List, Union
-import zipfile
-from io import BytesIO
-import re
-from pathlib import Path
-
-import requests
-import pandas as pd
-
-
-from ._io import read_mtx
-
-
-_valid_ds_names = ["AD", "Nkx2_KO", "aging", "cetuximab", "dsRNA", "morphine"]
-_repo_url = "https://raw.githubusercontent.com/{owner}/scTenifold-data/main/{ds_name}"
-_repo_tree_url = "https://api.github.com/repos/{owner}/scTenifold-data/git/trees/main?recursive=1"
-
-
-__all__ = ["list_data", "fetch_data"]
-
-
-def fetch_and_extract(url: str, saved_path: Union[str, Path]) -> None:
-    """Download a zip archive and extract it to ``saved_path``."""
-    resp = requests.get(url, stream=True)
-    resp.raise_for_status()
-    content = resp.content
-    zf = zipfile.ZipFile(BytesIO(content))
-    with zf as f:
-        f.extractall(saved_path)
-
-
-def download_url(url: str, save_path: Union[str, Path], chunk_size: int = 128) -> None:
-    """Stream ``url`` to disk at ``save_path``."""
-    r = requests.get(url, stream=True)
-    r.raise_for_status()
-    with open(save_path, 'wb') as fd:
-        for chunk in r.iter_content(chunk_size=chunk_size):
-            fd.write(chunk)
-
-
-def list_data(owner: str = "qwerty239qwe",
-              return_list: bool = True) -> Union[Dict[str, Dict[str, List[str]]], List[str]]:
-    """
-
-    Parameters
-    ----------
-    owner: str, default = 'qwerty239qwe'
-        owner name of dataset repo
-    return_list: bool, default = True
-        To return list of data name or return a dict indicating repo structure
-    Returns
-    -------
-    data_info_tree: list or dict
-        The obtainable data store in a dict, structure {'data_name': {'group': ['file_names']}}
-        or in a list of data_names
-    """
-    response = requests.get(_repo_tree_url.format(owner=owner))
-    response.raise_for_status()
-    tree = response.json()['tree']
-    ds_list = [p["path"] for p in tree if "/" not in p["path"] and p["type"] == "tree"]
-    if return_list:
-        return ds_list
-
-    s_pattern = re.compile(r"/")
-    lv1, lv2 = {}, []
-    for t in tree:
-        if len(re.findall(s_pattern, t['path'])) == 1:
-            lv1[t["path"]] = []
-        elif len(re.findall(s_pattern, t['path'])) == 2:
-            lv2.append(t["path"])
-    for b in lv2:
-        lv1[re.findall(r"(.*)/", b)[0]].append(b)
-
-    ds_dic = {ds: {} for ds in ds_list}
-    for k, v in lv1.items():
-        ds_dic[re.findall(r"(.*)/", k)[0]][k] = v
-    return ds_dic
-
-
-def fetch_data(ds_name: str,
-               dataset_path: Path = Path(__file__).parent.parent.parent / Path("datasets"),
-               owner: str = "qwerty239qwe") -> Dict[str, pd.DataFrame]:
-    """Fetch and load a remote scTenifold dataset by name.
-
-    Parameters
-    ----------
-    ds_name
-        Dataset name (one of :data:`_valid_ds_names`).
-    dataset_path
-        Local directory to cache downloads.
-    owner
-        GitHub owner of the ``scTenifold-data`` mirror.
-
-    Returns
-    -------
-    Mapping from sample-group name to a genes-by-cells DataFrame.
-    """
-    if not dataset_path.is_dir():
-        dataset_path.mkdir(parents=True)
-    if ds_name not in _valid_ds_names:
-        raise ValueError(f"Unknown dataset {ds_name!r}; expected one of {_valid_ds_names}")
-    ds_dic = list_data(owner=owner, return_list=False)
-    if ds_name not in ds_dic:
-        raise ValueError(f"Dataset {ds_name!r} was not found in the remote data repository")
-
-    result_df = {}
-
-    for lv_1, files in ds_dic[ds_name].items():
-        fn_names = {k: None for k in ["matrix", "genes", "barcodes"]}
-        for f in files:
-            if not (dataset_path / Path(lv_1)).is_dir():
-                (dataset_path / Path(lv_1)).mkdir(parents=True, exist_ok=True)
-            for fn_name in fn_names:
-                if fn_name in f:
-                    fn_names[fn_name] = f
-            if not (dataset_path / Path(f)).exists():
-                download_url(url=_repo_url.format(owner=owner, ds_name=f), save_path=(dataset_path / Path(f)))
-        result_df[re.findall(r".*/(.*)", lv_1)[0]] = read_mtx(mtx_file_name=str((dataset_path / Path(fn_names["matrix"]))),
-                                                              gene_file_name=str((dataset_path / Path(fn_names["genes"]))),
-                                                              barcode_file_name=str((dataset_path / Path(fn_names["barcodes"])))
-                                                              if fn_names["barcodes"] is not None else None) # optional
-    return result_df

omicverse-2.2.2/omicverse/external/scTenifold/data/_io.py

@@ -1,162 +0,0 @@
-import re
-from pathlib import Path
-import zipfile
-from typing import Optional, Union
-from warnings import warn
-
-from scipy.sparse import csr_matrix
-import pandas as pd
-
-
-__all__ = ["read_mtx", "read_folder"]
-
-
-def _get_mtx_body(rows, decode=None, print_header=True):
-    find_header_btn, row_ptr = False, 0
-    while not find_header_btn:
-        m = re.match(r"\d*\s\d*\s\d*", rows[row_ptr].strip()
-            if decode is None else rows[row_ptr].decode(decode).strip())
-        if m is not None:
-            find_header_btn = True
-        row_ptr += 1
-    if decode is None:
-        header, body = rows[:row_ptr], rows[row_ptr:]
-    else:
-        header, body = [r.decode(decode) for r in rows[:row_ptr]], [r.decode(decode) for r in rows[row_ptr:]]
-    if print_header:
-        print(header)
-    return body, header[-1].strip().split(" ")
-
-
-def _build_matrix_from_sparse(sparse_data, shape):
-    row, col, data = [], [], []
-    for data_row in sparse_data:
-        r, c, d = data_row.strip().split(" ")
-        row.append(int(r) - 1)
-        col.append(int(c) - 1)
-        data.append(float(d))
-    return csr_matrix((data, (row, col)), shape=shape).toarray()
-
-
-def _parse_mtx(mtx_file_name):
-    suffix = Path(mtx_file_name).suffix
-    if suffix == ".txt":
-        with open(mtx_file_name) as f:
-            rows = f.readlines()
-            body, header = _get_mtx_body(rows)
-            n_rows, n_cols = int(header[0]), int(header[1])
-        is_dense = False
-    elif suffix == ".tsv":
-        body = pd.read_csv(mtx_file_name, sep='\t', header=None, index_col=False).values
-        n_rows, n_cols = body.shape
-        is_dense = True
-    elif suffix == ".csv":
-        body = pd.read_csv(mtx_file_name, header=None, index_col=False).values
-        n_rows, n_cols = body.shape
-        is_dense = True
-    elif suffix == ".zip":
-        archive = zipfile.ZipFile(mtx_file_name, 'r')
-        with archive.open(archive.namelist()[0]) as fn:
-            sf = Path(archive.namelist()[0]).suffix
-            if sf not in [".csv", ".tsv"]:
-                rows = fn.readlines()
-                body, header = _get_mtx_body(rows, decode="utf-8")
-                n_rows, n_cols = int(header[0]), int(header[1])
-                is_dense = False
-            else:
-                body = pd.DataFrame([f.decode("utf-8").strip().split("," if sf == ".csv" else "\t")
-                                     for f in fn.readlines()]).iloc[1:, 1:].values
-                n_rows, n_cols = body.shape
-                is_dense = True
-    else:
-        raise ValueError("The suffix of this file is not valid")
-    return body, is_dense, n_rows, n_cols
-
-
-def read_mtx(mtx_file_name: Union[str, Path],
-             gene_file_name: Union[str, Path],
-             barcode_file_name: Optional[Union[str, Path]]) -> pd.DataFrame:
-    """
-    Read mtx data
-
-    Parameters
-    ----------
-    mtx_file_name: str
-        File name of mtx data
-    gene_file_name
-        File name of gene vector
-    barcode_file_name
-        File name of barcode vector
-
-    Returns
-    -------
-    df: pd.DataFrame
-        A dataframe with genes as rows and cells as columns
-    """
-    if mtx_file_name is None:
-        raise ValueError("matrix file is required")
-    if gene_file_name is None:
-        raise ValueError("gene file is required")
-    genes = pd.read_csv(gene_file_name, sep='\t', header=None).iloc[:, 0]
-    barcodes = pd.read_csv(barcode_file_name, sep='\t', header=None).iloc[:, 0] \
-        if barcode_file_name is not None else None
-    if barcodes is None:
-        warn("Barcode file is not existed. Added fake barcode name in the dataset")
-    body, is_dense, n_rows, n_cols = _parse_mtx(mtx_file_name)
-    barcodes = barcodes if barcodes is not None else [f"barcode_{i}" for i in range(n_cols)]
-    print(f"creating a {(len(genes), len(barcodes))} matrix")
-    if not is_dense:
-        data = _build_matrix_from_sparse(body, shape=(len(genes), len(barcodes)))
-    else:
-        data = body
-    df = pd.DataFrame(index=genes, columns=barcodes, data=data)
-    return df
-
-
-def read_folder(file_dir: Union[str, Path],
-                matrix_fn: str = "matrix",
-                gene_fn: str = "genes",
-                barcodes_fn: str = "barcodes") -> pd.DataFrame:
-    """Read mtx + genes + barcodes from a directory by filename substring.
-
-    Parameters
-    ----------
-    file_dir
-        Path to a directory containing matrix, gene, and barcode files.
-    matrix_fn
-        Substring identifying the matrix file (e.g. ``"matrix"``).
-    gene_fn
-        Substring identifying the gene file.
-    barcodes_fn
-        Substring identifying the barcode file.
-
-    Returns
-    -------
-    Genes-by-cells DataFrame.
-    """
-    dir_path = Path(file_dir)
-    fn_dic = {fn: [] for fn in [matrix_fn, gene_fn, barcodes_fn]}
-    if not dir_path.is_dir():
-        raise ValueError("Path is not exist or is not a folder path")
-    for fn in dir_path.iterdir():
-        for k in fn_dic:
-            if k in fn.name:
-                fn_dic[k].append(fn)
-
-    resolved = {}
-    for key, matches in fn_dic.items():
-        if len(matches) > 1:
-            raise ValueError(f"Multiple files match {key!r}: {[match.name for match in matches]}")
-        resolved[key] = matches[0] if matches else None
-
-    matrix_path = resolved[matrix_fn]
-    gene_path = resolved[gene_fn]
-    barcode_path = resolved[barcodes_fn]
-    if matrix_path is None:
-        raise ValueError("matrix file is required")
-    if gene_path is None:
-        raise ValueError("gene file is required")
-
-    return read_mtx(mtx_file_name=str(matrix_path),
-                    gene_file_name=str(gene_path),
-                    barcode_file_name=str(barcode_path) if barcode_path else None)