diff --git a/docs/src/vignettes/1_simple_example.ipynb b/docs/src/vignettes/1_simple_example.ipynb index 75eb78c..7211816 100644 --- a/docs/src/vignettes/1_simple_example.ipynb +++ b/docs/src/vignettes/1_simple_example.ipynb @@ -70,34 +70,19 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "panacea_countdata, panacea_metadata = nc.data.omics.panacea()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now, we download PANACEA. Since it contains transcriptomics profiles from 32 drugs and 11 cell lines, we will filter the dataframe for just one particular contrast as an example." - ] - }, - { - "cell_type": "code", - "execution_count": 3, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "singlec_metadata = panacea_metadata[(panacea_metadata['group'] == 'ASPC_DMSO') | (panacea_metadata['group'] == 'ASPC_AFATINIB')]\n", - "singlec_samples = singlec_metadata['sample_ID'].tolist()\n", - "singlec_countdata = panacea_countdata[['gene_symbol'] + singlec_samples]" + "drug_countdata, drug_metadata = nc.data.omics.panacea_tables(type='raw', cell_line='ASPC', drug='AFATINIB')\n", + "ctrl_countdata, ctrl_metadata = nc.data.omics.panacea_tables(type='raw', cell_line='ASPC', drug='DMSO')\n", + "panacea_countdata = pd.merge(left=drug_countdata, right=ctrl_countdata, on='gene_symbol')\n", + "panacea_metadata = pd.concat([drug_metadata, ctrl_metadata], axis=0)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -122,6 +107,8 @@ " \n", " \n", " gene_symbol\n", + " ASPC_AFATINIB_0.09_24\n", + " ASPC_AFATINIB_0.09_24.1\n", " ASPC_DMSO__24\n", " ASPC_DMSO__24.1\n", " ASPC_DMSO__24.2\n", @@ -129,8 +116,6 @@ " ASPC_DMSO__24.4\n", " ASPC_DMSO__24.5\n", " ASPC_DMSO_0_24\n", - " ASPC_DMSO_0_24.1\n", - " ASPC_DMSO_0_24.2\n", " ...\n", " ASPC_DMSO_0_24.38\n", " ASPC_DMSO_0_24.39\n", @@ -172,9 +157,9 @@ " \n", " 1\n", " NAT2\n", - " 1\n", " 0\n", " 0\n", + " 1\n", " 0\n", " 0\n", " 0\n", @@ -196,6 +181,8 @@ " \n", " 2\n", " ADA\n", + " 0\n", + " 1\n", " 6\n", " 6\n", " 9\n", @@ -203,8 +190,6 @@ " 7\n", " 7\n", " 1\n", - " 6\n", - " 3\n", " ...\n", " 6\n", " 0\n", @@ -221,9 +206,9 @@ " 3\n", " CDH2\n", " 0\n", - " 2\n", " 0\n", " 0\n", + " 2\n", " 0\n", " 0\n", " 0\n", @@ -252,7 +237,7 @@ " 0\n", " 0\n", " 0\n", - " 1\n", + " 0\n", " ...\n", " 0\n", " 0\n", @@ -271,63 +256,56 @@ "" ], "text/plain": [ - " gene_symbol ASPC_DMSO__24 ASPC_DMSO__24.1 ASPC_DMSO__24.2 \\\n", - "0 A1BG 0 0 0 \n", - "1 NAT2 1 0 0 \n", - "2 ADA 6 6 9 \n", - "3 CDH2 0 2 0 \n", - "4 AKT3 0 0 0 \n", + " gene_symbol ASPC_AFATINIB_0.09_24 ASPC_AFATINIB_0.09_24.1 ASPC_DMSO__24 \\\n", + "0 A1BG 0 0 0 \n", + "1 NAT2 0 0 1 \n", + "2 ADA 0 1 6 \n", + "3 CDH2 0 0 0 \n", + "4 AKT3 0 0 0 \n", "\n", - " ASPC_DMSO__24.3 ASPC_DMSO__24.4 ASPC_DMSO__24.5 ASPC_DMSO_0_24 \\\n", - "0 0 0 0 0 \n", - "1 0 0 0 0 \n", - "2 19 7 7 1 \n", - "3 0 0 0 0 \n", - "4 0 0 0 0 \n", + " ASPC_DMSO__24.1 ASPC_DMSO__24.2 ASPC_DMSO__24.3 ASPC_DMSO__24.4 \\\n", + "0 0 0 0 0 \n", + "1 0 0 0 0 \n", + "2 6 9 19 7 \n", + "3 2 0 0 0 \n", + "4 0 0 0 0 \n", "\n", - " ASPC_DMSO_0_24.1 ASPC_DMSO_0_24.2 ... ASPC_DMSO_0_24.38 \\\n", - "0 0 0 ... 0 \n", - "1 0 0 ... 0 \n", - "2 6 3 ... 6 \n", - "3 0 0 ... 0 \n", - "4 0 1 ... 0 \n", + " ASPC_DMSO__24.5 ASPC_DMSO_0_24 ... ASPC_DMSO_0_24.38 ASPC_DMSO_0_24.39 \\\n", + "0 0 0 ... 0 0 \n", + "1 0 0 ... 0 0 \n", + "2 7 1 ... 6 0 \n", + "3 0 0 ... 0 0 \n", + "4 0 0 ... 0 0 \n", "\n", - " ASPC_DMSO_0_24.39 ASPC_DMSO_0_24.40 ASPC_DMSO_0_24.41 ASPC_DMSO_0_24.42 \\\n", + " ASPC_DMSO_0_24.40 ASPC_DMSO_0_24.41 ASPC_DMSO_0_24.42 ASPC_DMSO_0_24.43 \\\n", "0 0 0 0 0 \n", "1 0 0 0 0 \n", - "2 0 0 1 1 \n", - "3 0 0 0 1 \n", + "2 0 1 1 6 \n", + "3 0 0 1 0 \n", "4 0 0 0 0 \n", "\n", - " ASPC_DMSO_0_24.43 ASPC_DMSO_0_24.44 ASPC_DMSO_0_24.45 ASPC_DMSO_0_24.46 \\\n", - "0 0 0 0 0 \n", - "1 0 0 0 0 \n", - "2 6 2 0 12 \n", - "3 0 0 0 0 \n", - "4 0 0 0 0 \n", - "\n", - " ASPC_DMSO_0_24.47 \n", - "0 0 \n", - "1 2 \n", - "2 1 \n", - "3 1 \n", - "4 0 \n", + " ASPC_DMSO_0_24.44 ASPC_DMSO_0_24.45 ASPC_DMSO_0_24.46 ASPC_DMSO_0_24.47 \n", + "0 0 0 0 0 \n", + "1 0 0 0 2 \n", + "2 2 0 12 1 \n", + "3 0 0 0 1 \n", + "4 0 0 0 0 \n", "\n", "[5 rows x 63 columns]" ] }, - "execution_count": 4, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "singlec_countdata.head()" + "panacea_countdata.head()" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -353,54 +331,73 @@ " \n", " sample_ID\n", " group\n", + " cell\n", + " drug\n", " \n", " \n", " \n", " \n", + " 32\n", + " ASPC_AFATINIB_0.09_24\n", + " ASPC_AFATINIB\n", + " ASPC\n", + " AFATINIB\n", + " \n", + " \n", + " 94\n", + " ASPC_AFATINIB_0.09_24.1\n", + " ASPC_AFATINIB\n", + " ASPC\n", + " AFATINIB\n", + " \n", + " \n", " 0\n", " ASPC_DMSO__24\n", " ASPC_DMSO\n", + " ASPC\n", + " DMSO\n", " \n", " \n", " 1\n", " ASPC_DMSO__24.1\n", " ASPC_DMSO\n", + " ASPC\n", + " DMSO\n", " \n", " \n", " 2\n", " ASPC_DMSO__24.2\n", " ASPC_DMSO\n", - " \n", - " \n", - " 3\n", - " ASPC_DMSO__24.3\n", - " ASPC_DMSO\n", - " \n", - " \n", - " 4\n", - " ASPC_DMSO__24.4\n", - " ASPC_DMSO\n", + " ASPC\n", + " DMSO\n", " \n", " \n", "\n", "" ], "text/plain": [ - " sample_ID group\n", - "0 ASPC_DMSO__24 ASPC_DMSO\n", - "1 ASPC_DMSO__24.1 ASPC_DMSO\n", - "2 ASPC_DMSO__24.2 ASPC_DMSO\n", - "3 ASPC_DMSO__24.3 ASPC_DMSO\n", - "4 ASPC_DMSO__24.4 ASPC_DMSO" + " sample_ID group cell drug\n", + "32 ASPC_AFATINIB_0.09_24 ASPC_AFATINIB ASPC AFATINIB\n", + "94 ASPC_AFATINIB_0.09_24.1 ASPC_AFATINIB ASPC AFATINIB\n", + "0 ASPC_DMSO__24 ASPC_DMSO ASPC DMSO\n", + "1 ASPC_DMSO__24.1 ASPC_DMSO ASPC DMSO\n", + "2 ASPC_DMSO__24.2 ASPC_DMSO ASPC DMSO" ] }, - "execution_count": 5, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "singlec_metadata.head()" + "panacea_metadata.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we download PANACEA. Since it contains transcriptomics profiles from 32 drugs and 11 cell lines, we will filter the dataframe for just one particular contrast as an example." ] }, { @@ -412,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -423,33 +420,35 @@ " They will be converted to hyphens ('-').\n", " self.obsm[\"design_matrix\"] = build_design_matrix(\n", "Fitting size factors...\n", - "... done in 0.04 seconds.\n", + "... done in 0.03 seconds.\n", "\n", "Fitting dispersions...\n", - "... done in 6.97 seconds.\n", + "... done in 8.01 seconds.\n", "\n", "Fitting dispersion trend curve...\n", - "... done in 0.51 seconds.\n", + "... done in 0.64 seconds.\n", "\n", "Fitting MAP dispersions...\n", - "... done in 7.39 seconds.\n", + "... done in 10.56 seconds.\n", "\n", "Fitting LFCs...\n", - "... done in 4.18 seconds.\n", + "... done in 5.08 seconds.\n", "\n", "Calculating cook's distance...\n", - "... done in 0.07 seconds.\n", + "/home/victo/.cache/pypoetry/virtualenvs/networkcommons-DX9y6Uxu-py3.10/lib/python3.10/site-packages/pydeseq2/utils.py:1119: FutureWarning: DataFrameGroupBy.grouper is deprecated and will be removed in a future version of pandas.\n", + " ).grouper.group_info[0],\n", + "... done in 0.15 seconds.\n", "\n", "Replacing 32 outlier genes.\n", "\n", "Fitting dispersions...\n", - "... done in 0.02 seconds.\n", + "... done in 0.04 seconds.\n", "\n", "Fitting MAP dispersions...\n", - "... done in 0.02 seconds.\n", + "... done in 0.03 seconds.\n", "\n", "Fitting LFCs...\n", - "... done in 0.02 seconds.\n", + "... done in 0.04 seconds.\n", "\n", "Running Wald tests...\n" ] @@ -471,7 +470,7 @@ "KCNE2 0.000000 NaN NaN NaN NaN NaN\n", "DGCR2 11.193327 -0.679913 0.687801 -0.988532 0.322892 NaN\n", "CASP8AP2 9.318870 -0.410430 0.798973 -0.513696 0.607465 NaN\n", - "SCO2 15.866144 -0.390995 0.564523 -0.692611 0.488554 NaN\n", + "SCO2 15.866144 -0.390995 0.564523 -0.692610 0.488554 NaN\n", "\n", "[24961 rows x 6 columns]\n" ] @@ -480,23 +479,26 @@ "name": "stderr", "output_type": "stream", "text": [ - "... done in 1.87 seconds.\n", - "\n" + "... done in 2.47 seconds.\n", + "\n", + "/home/victo/.cache/pypoetry/virtualenvs/networkcommons-DX9y6Uxu-py3.10/lib/python3.10/site-packages/pydeseq2/utils.py:1599: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.\n", + "To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.\n", + " beta = np.linalg.lstsq(A, b)[0]\n" ] } ], "source": [ - "results = nc.data.omics.deseq2(singlec_countdata, singlec_metadata, test_group=\"ASPC_AFATINIB\", ref_group=\"ASPC_DMSO\")" + "results = nc.data.omics.deseq2(panacea_countdata, panacea_metadata, test_group=\"ASPC_AFATINIB\", ref_group=\"ASPC_DMSO\")" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -519,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ diff --git a/networkcommons/_utils.py b/networkcommons/_utils.py index fecee14..e1c2451 100644 --- a/networkcommons/_utils.py +++ b/networkcommons/_utils.py @@ -37,26 +37,31 @@ def edge_attrs_from_corneto(graph: cn.Graph) -> pd.DataFrame: concat_df.rename(columns={0: 'node'}, inplace=True) - def to_cornetograph(graph): """ Convert a networkx graph to a corneto graph, if needed. Args: - graph (nx.Graph or nx.DiGraph): The corneto graph. + graph (nx.DiGraph): The corneto graph. Returns: cn.Graph: The corneto graph. """ - if isinstance(graph, cn._graph.Graph): + if isinstance(graph, nx.MultiDiGraph): + raise NotImplementedError("Only nx.DiGraph graphs and corneto graphs are supported.") + elif isinstance(graph, cn.Graph): corneto_graph = graph - elif isinstance(graph, (nx.Graph, nx.DiGraph)): + elif isinstance(graph, nx.DiGraph): # substitute 'sign' for 'interaction' in the graph nx_graph = graph.copy() for u, v, data in nx_graph.edges(data=True): data['interaction'] = data.pop('sign') corneto_graph = cn_nx.networkx_to_corneto_graph(nx_graph) + elif isinstance(graph, nx.Graph): + raise NotImplementedError("Only nx.DiGraph graphs and corneto graphs are supported.") + else: + raise NotImplementedError("Only nx.DiGraph graphs and corneto graphs are supported.") return corneto_graph @@ -71,15 +76,21 @@ def to_networkx(graph, skip_unsupported_edges=True): Returns: nx.Graph: The networkx graph. """ - if isinstance(graph, nx.Graph) or isinstance(graph, nx.DiGraph): + if isinstance(graph, nx.MultiDiGraph): + raise NotImplementedError("Only nx.DiGraph graphs and corneto graphs are supported.") + elif isinstance(graph, nx.DiGraph): networkx_graph = graph - elif isinstance(graph, cn._graph.Graph): + elif isinstance(graph, cn.Graph): networkx_graph = cn_nx.corneto_graph_to_networkx( graph, skip_unsupported_edges=skip_unsupported_edges) # rename interaction for sign for u, v, data in networkx_graph.edges(data=True): data['sign'] = data.pop('interaction') + elif isinstance(graph, nx.Graph): + raise NotImplementedError("Only nx.DiGraph graphs and corneto graphs are supported.") + else: + raise NotImplementedError("Only nx.DiGraph graphs and corneto graphs are supported.") return networkx_graph @@ -116,8 +127,7 @@ def read_network_from_file(file_path, def network_from_df(network_df, source_col='source', target_col='target', - directed=True, - multigraph=False): + directed=True): """ Create a network from a DataFrame. @@ -132,9 +142,6 @@ def network_from_df(network_df, """ network_type = nx.DiGraph if directed else nx.Graph - if multigraph: - network_type = nx.MultiDiGraph if directed else nx.MultiGraph - if list(network_df.columns) == list([source_col, target_col]): network = nx.from_pandas_edgelist(network_df, source=source_col, @@ -183,8 +190,8 @@ def decoupler_formatter(df, Format dataframe to be used by decoupler. Parameters: - df (DataFrame): A pandas DataFrame. - column (str): The column to be used as index. + df (DataFrame): A pandas DataFrame. Index should be populated + column (str): The columns to be subsetted. Returns: A formatted DataFrame. @@ -211,7 +218,7 @@ def targetlayer_formatter(df, n_elements=25): # Sort the DataFrame by the absolute value of the # 'sign' column and get top n elements - df = df.sort_values(by='sign', key=lambda x: abs(x)) + df = df.sort_values(by='sign', key=lambda x: abs(x), ascending=False) df = df.head(n_elements) diff --git a/networkcommons/data/network/_liana.py b/networkcommons/data/network/_liana.py index 0e3cbb6..e23c301 100644 --- a/networkcommons/data/network/_liana.py +++ b/networkcommons/data/network/_liana.py @@ -19,9 +19,11 @@ __all__ = ['get_lianaplus'] -import lazy_import +# import lazy_import -liana = lazy_import.lazy_module('liana') +# liana = lazy_import.lazy_module('liana') + +import liana def get_lianaplus(resource='Consensus'): @@ -37,8 +39,6 @@ def get_lianaplus(resource='Consensus'): pandas.DataFrame: Liana+ network with source, target, and sign columns. """ - import liana - network = liana.resource.select_resource(resource).drop_duplicates() network.columns = ['source', 'target'] network['sign'] = 1 diff --git a/networkcommons/data/network/_moon.py b/networkcommons/data/network/_moon.py index 5134c87..e5c30b2 100644 --- a/networkcommons/data/network/_moon.py +++ b/networkcommons/data/network/_moon.py @@ -17,7 +17,7 @@ Prior knowledge network used by MOON. """ -__all__ = ['build_moon_regulons', 'get_cosmos_pkn'] +__all__ = ['get_cosmos_pkn'] import lazy_import import numpy as np @@ -59,52 +59,3 @@ def get_cosmos_pkn(update: bool = False): file_legend = pd.read_pickle(path) return file_legend - - - - -def build_moon_regulons(include_liana=False): - - dorothea_df = dc.get_collectri() - - TFs = np.unique(dorothea_df['source']) - - full_pkn = _omnipath.get_omnipath(genesymbols=True, directed_signed=True) - - if include_liana: - - ligrec_resource = _liana.get_lianaplus() - - full_pkn = pd.concat([full_pkn, ligrec_resource]) - full_pkn['edgeID'] = full_pkn['source'] + '_' + full_pkn['target'] - - # This prioritises edges coming from OP - full_pkn = full_pkn.drop_duplicates(subset='edgeID') - full_pkn = full_pkn.drop(columns='edgeID') - - kinTF_regulons = full_pkn[full_pkn['target'].isin(TFs)].copy() - kinTF_regulons.columns = ['source', 'target', 'mor'] - kinTF_regulons = kinTF_regulons.drop_duplicates() - - kinTF_regulons = kinTF_regulons.groupby(['source', 'target']).mean() \ - .reset_index() - - layer_2 = {} - activation_pkn = full_pkn[full_pkn['sign'] == 1].copy() - - pkn_graph = _utils.network_from_df(activation_pkn, directed=True) - - relevant_nodes = list(activation_pkn['source'].unique()) - relevant_nodes = [node for node in relevant_nodes if node in list(kinTF_regulons['source'])] - - for node in relevant_nodes: - intermediates = activation_pkn[activation_pkn['source'] == node]['target'].tolist() - targets = [n for i in intermediates for n in pkn_graph.neighbors(i)] - targets = np.unique([n for n in targets if n in TFs]) - layer_2[node] = targets - - layer_2_df = pd.concat([pd.DataFrame({'source': k, 'target': v, 'mor': 0.25}) for k, v in layer_2.items()], ignore_index=True) - kinTF_regulons = pd.concat([kinTF_regulons, layer_2_df]) - kinTF_regulons = kinTF_regulons.groupby(['source', 'target']).sum().reset_index() - - return kinTF_regulons diff --git a/networkcommons/data/omics/__init__.py b/networkcommons/data/omics/__init__.py index c03024e..5c48ca5 100644 --- a/networkcommons/data/omics/__init__.py +++ b/networkcommons/data/omics/__init__.py @@ -22,5 +22,5 @@ from ._deseq2 import * from ._panacea import * from ._scperturb import * -from ._moon import * +from ._nci60 import * from ._cptac import * diff --git a/networkcommons/data/omics/_common.py b/networkcommons/data/omics/_common.py index 4f02078..11e3eb7 100644 --- a/networkcommons/data/omics/_common.py +++ b/networkcommons/data/omics/_common.py @@ -75,11 +75,6 @@ def _commons_url(dataset: str, **kwargs) -> str: return urllib.parse.urljoin(baseurl, path) -def _dataset(key: str) -> dict | None: - - return _datasets()['datasets'].get(key.lower(), None) - - def _requests_session() -> requests.Session: ses = requests.Session() diff --git a/networkcommons/data/omics/_cptac.py b/networkcommons/data/omics/_cptac.py index 2b58baa..d424961 100644 --- a/networkcommons/data/omics/_cptac.py +++ b/networkcommons/data/omics/_cptac.py @@ -160,5 +160,6 @@ def cptac_extend_dataframe(df): extended_df.drop(['Tumor', 'Normal'], axis=1, inplace=True) extended_df.rename(columns={'idx': 'sample_ID'}, inplace=True) + extended_df.reset_index(inplace=True, drop=True) return extended_df \ No newline at end of file diff --git a/networkcommons/data/omics/_decryptm_ebi.py b/networkcommons/data/omics/_decryptm_ebi.py deleted file mode 100644 index 6f2c2e8..0000000 --- a/networkcommons/data/omics/_decryptm_ebi.py +++ /dev/null @@ -1,54 +0,0 @@ -#!/usr/bin/env python - -# -# This file is part of the `networkcommons` Python module -# -# Copyright 2024 -# Heidelberg University Hospital -# -# File author(s): Saez Lab (omnipathdb@gmail.com) -# -# Distributed under the GPLv3 license -# See the file `LICENSE` or read a copy at -# https://www.gnu.org/licenses/gpl-3.0.txt -# - -from __future__ import annotations - -__all__ = [] - -import os -import shutil -import glob -import urllib.parse - -from . import _common -from networkcommons._session import _log - - -def _get_decryptm(path: str): - """ - Download DecryptM from EBI. - - Args: - path: - Download the data into this directory. - """ - - os.makedirs(path, exist_ok = True) - url = 'https://ftp.pride.ebi.ac.uk/pride/data/archive/2023/03/PXD037285/' - files = [f for f in _common._ls(url) if f.endswith('Curves.zip')] - - for fname in files: - - zip_url = urllib.parse.urljoin(url, fname) - - with _common._open(zip_url) as zip_file: - - _log(f'Extracting zip `{zip_file.filename}` to `{path}`.') - zip_file.extractall(path) - - _ = [ - shutil.rmtree(pdfdir) - for pdfdir in glob.glob(f'{path}/*/*/*/pdfs', recursive = True) - ] diff --git a/networkcommons/data/omics/_deseq2.py b/networkcommons/data/omics/_deseq2.py index bf1e4bd..3a5f133 100644 --- a/networkcommons/data/omics/_deseq2.py +++ b/networkcommons/data/omics/_deseq2.py @@ -21,18 +21,13 @@ __all__ = ['deseq2'] -from typing import TYPE_CHECKING import multiprocessing -import importlib -if TYPE_CHECKING: +import pandas as pd - import pandas as pd - -import lazy_import from pypath_common import _misc as _ppcommon -#for _mod in ('default_inference', 'dds', 'ds'): +# for _mod in ('default_inference', 'dds', 'ds'): # globals()[f'_deseq2_{_mod}'] = lazy_import.lazy_module(f'pydeseq2.{_mod}') @@ -50,8 +45,7 @@ def deseq2( ref_group: str, sample_col: str = 'sample_ID', feature_col: str = 'gene_symbol', - covariates: list | None = None, - round_values: bool = False + covariates: list | None = None ) -> pd.DataFrame: """ Runs DESeq2 analysis on the given counts and metadata. @@ -67,8 +61,6 @@ def deseq2( Defaults to 'gene_symbol'. covariates (list, optional): List of covariates to include in the analysis. Defaults to None. - round_values (bool, optional): Whether to round the counts to integers. Otherwise, the - counts will be left as floats and the function will fail. Defaults to False. Returns: @@ -86,11 +78,6 @@ def deseq2( if '_' in ref_group: ref_group = ref_group.replace('_', '-') - if round_values and not counts.select_dtypes(include=['float64', 'float32']).empty: - counts = counts.round(0) - _log('Float values found. Rounded counts to integers.') - - n_cpus = _conf.get('cpu_count', multiprocessing.cpu_count()) inference = _deseq2_default_inference.DefaultInference(n_cpus = n_cpus) diff --git a/networkcommons/data/omics/_moon.py b/networkcommons/data/omics/_nci60.py similarity index 100% rename from networkcommons/data/omics/_moon.py rename to networkcommons/data/omics/_nci60.py diff --git a/networkcommons/data/omics/_scperturb.py b/networkcommons/data/omics/_scperturb.py index 8c27478..21b55b5 100644 --- a/networkcommons/data/omics/_scperturb.py +++ b/networkcommons/data/omics/_scperturb.py @@ -24,7 +24,6 @@ from typing import Any import json -import bs4 import anndata as ad from . import _common diff --git a/networkcommons/eval/_metrics.py b/networkcommons/eval/_metrics.py index 8e60c64..47ae5dd 100644 --- a/networkcommons/eval/_metrics.py +++ b/networkcommons/eval/_metrics.py @@ -189,7 +189,7 @@ def get_graph_metrics(network, target_dict): metrics.reset_index(inplace=True, drop=True) - elif isinstance(network, (nx.Graph, nx.DiGraph)): + elif isinstance(network, nx.DiGraph): metrics = pd.DataFrame({ 'Number of nodes': get_number_nodes(network), 'Number of edges': get_number_edges(network), @@ -198,6 +198,8 @@ def get_graph_metrics(network, target_dict): 'Mean closeness': get_mean_closeness(network), 'Connected targets': get_connected_targets(network, target_dict) }, index=[0]) + else: + raise TypeError("The network must be a networkx graph or a dictionary of networkx graphs.") return metrics diff --git a/networkcommons/methods/_graph.py b/networkcommons/methods/_graph.py index a5a2f7f..85ae249 100644 --- a/networkcommons/methods/_graph.py +++ b/networkcommons/methods/_graph.py @@ -277,11 +277,14 @@ def add_pagerank_scores(network, if personalize_for == "source": personalized_prob = {n: 1/len(sources) for n in sources} + attribute_name = 'pagerank_from_sources' elif personalize_for == "target": personalized_prob = {n: 1/len(targets) for n in targets} network = network.reverse() + attribute_name = 'pagerank_from_targets' else: personalized_prob = None + attribute_name = 'pagerank' pagerank = nx.pagerank(network, alpha=alpha, @@ -295,12 +298,6 @@ def add_pagerank_scores(network, network = network.reverse() for node, pr_value in pagerank.items(): - if personalize_for == "target": - attribute_name = 'pagerank_from_targets' - elif personalize_for == "source": - attribute_name = 'pagerank_from_sources' - elif personalize_for is None: - attribute_name = 'pagerank' network.nodes[node][attribute_name] = pr_value return network @@ -321,19 +318,19 @@ def compute_ppr_overlap(network, percentage=20): """ # Sorting nodes by PageRank score from sources and targets try: - sorted_nodes_sources = sorted(network.nodes(data=True), - key=lambda x: x[1].get( - 'pagerank_from_sources' - ), - reverse=True) - sorted_nodes_targets = sorted(network.nodes(data=True), - key=lambda x: x[1].get( - 'pagerank_from_targets' - ), - reverse=True) + nodes_sources = [(node, data['pagerank_from_sources']) for node, data in network.nodes(data=True)] + nodes_targets = [(node, data['pagerank_from_targets']) for node, data in network.nodes(data=True)] + except KeyError: - raise KeyError("Please run the add_pagerank_scores method first with\ + raise KeyError("Please run the add_pagerank_scores method first with \ personalization options.") + + sorted_nodes_sources = sorted(nodes_sources, + key=lambda x: x[1], + reverse=True) + sorted_nodes_targets = sorted(nodes_targets, + key=lambda x: x[1], + reverse=True) # Calculating the number of nodes to keep num_nodes_to_keep_sources = int( diff --git a/networkcommons/methods/_moon.py b/networkcommons/methods/_moon.py index 868820d..d3abfc7 100644 --- a/networkcommons/methods/_moon.py +++ b/networkcommons/methods/_moon.py @@ -219,7 +219,7 @@ def filter_input_nodes_not_in_pkn(data, pkn): node for node in data.keys() if node not in new_data.keys() ] - _log(f"COSMOS: {len(removed_nodes)} input/measured nodes are not in" + _log(f"COSMOS: {len(removed_nodes)} input/measured nodes are not in " f"PKN anymore: {removed_nodes}") return new_data @@ -408,12 +408,15 @@ def run_moon_core( ) if statistic == "norm_wmean": estimate = norm + elif statistic == "ulm": - _log(decoupler_mat) estimate, pvals = dc.run_ulm( mat=decoupler_mat, net=regulons, weight='sign', min_n=1 ) + else: + raise ValueError("Invalid method. Currently supported: 'ulm' or 'wmean'.") + n_plus_one = estimate.T n_plus_one.columns = ["score"] n_plus_one["level"] = 1 @@ -437,7 +440,7 @@ def run_moon_core( ) if statistic == "norm_wmean": estimate = norm - elif statistic == "ulm": + else: estimate, pvals = dc.run_ulm( mat=previous_n_plus_one, net=regulons, @@ -539,7 +542,7 @@ def run_moon(network, print(f'Optimisation iteration {i} - Before: {before}, After: {after}') if i == max_iter: - print("MOON: Maximum number of iterations reached." + _log("MOON: Maximum number of iterations reached." "Solution might not have converged") else: print("MOON: Solution converged after", i, "iterations") diff --git a/tests/test_deseq2.py b/tests/test_deseq2.py index 1289c6d..7405d2f 100644 --- a/tests/test_deseq2.py +++ b/tests/test_deseq2.py @@ -1,14 +1,15 @@ import pytest - import pandas as pd +from unittest.mock import patch, MagicMock +from networkcommons.data import omics -from networkcommons.data.omics._deseq2 import deseq2 - - -@pytest.mark.slow -def test_deseq2(): - - # Create dummy dataset for testing, samples as colnames, genes as rownames +# Here th nternal DESeq2 components are mocked to isolate the test from the actual pyDESeq2 implementation. +@patch('networkcommons.data.omics._deseq2._log') +@patch('networkcommons.data.omics._deseq2._conf.get', return_value=1) +@patch('networkcommons.data.omics._deseq2._deseq2_ds.DeseqStats') +@patch('networkcommons.data.omics._deseq2._deseq2_dds.DeseqDataSet') +@patch('networkcommons.data.omics._deseq2._deseq2_default_inference.DefaultInference') +def test_deseq2(mock_inference, mock_dds, mock_stats, mock_conf_get, mock_log): counts = pd.DataFrame({ 'gene_symbol': ['Gene1', 'Gene2', 'Gene3'], 'Sample1': [90, 150, 10], @@ -17,12 +18,40 @@ def test_deseq2(): 'Sample4': [100, 120, 17] }) + metadata = pd.DataFrame({ + 'sample_ID': ['Sample1', 'Sample2', 'Sample3', 'Sample4'], + 'group': ['Control_Group', 'Treatment_Group', 'Treatment_Group', 'Control_Group'] + }) + + mock_dds_instance = MagicMock() + mock_dds.return_value = mock_dds_instance + + mock_stats_instance = MagicMock() + mock_stats_instance.results_df = pd.DataFrame({ + 'baseMean': [93.233027, 101.285704, 11.793541], + 'log2FoldChange': [0.218173, -0.682184, -0.052951], + 'lfcSE': [0.328029, 0.352410, 0.521688], + 'stat': [0.665101, -1.935768, -0.101500], + 'pvalue': [0.505986, 0.052896, 0.919154], + 'padj': [0.758979, 0.158688, 0.919154] + }, index=['Gene1', 'Gene2', 'Gene3']) + mock_stats_instance.results_df.index.name = 'gene_symbol' + + mock_stats.return_value = mock_stats_instance + + result = omics.deseq2( + counts, + metadata, + ref_group='Control_Group', + test_group='Treatment_Group', + ) + # now without haifens metadata = pd.DataFrame({ 'sample_ID': ['Sample1', 'Sample2', 'Sample3', 'Sample4'], 'group': ['Control', 'Treatment', 'Treatment', 'Control'] }) - result = deseq2( + result = omics.deseq2( counts, metadata, ref_group='Control', @@ -33,15 +62,15 @@ def test_deseq2(): cols_expected = {'log2FoldChange', 'lfcSE', 'stat', 'pvalue', 'padj'} assert cols_expected.issubset(result.columns) - data = { + expected_result = pd.DataFrame({ 'baseMean': [93.233027, 101.285704, 11.793541], 'log2FoldChange': [0.218173, -0.682184, -0.052951], 'lfcSE': [0.328029, 0.352410, 0.521688], 'stat': [0.665101, -1.935768, -0.101500], 'pvalue': [0.505986, 0.052896, 0.919154], 'padj': [0.758979, 0.158688, 0.919154] - } - - expected_result = pd.DataFrame(data, index=['Gene1', 'Gene2', 'Gene3']) + }, index=['Gene1', 'Gene2', 'Gene3']) expected_result.index.name = 'gene_symbol' + pd.testing.assert_frame_equal(result, expected_result, check_exact=False) + mock_log.assert_called_with('Finished running DESeq2.') diff --git a/tests/test_eval_graph.py b/tests/test_eval_graph.py index eb37c66..cd49beb 100644 --- a/tests/test_eval_graph.py +++ b/tests/test_eval_graph.py @@ -1,19 +1,15 @@ import pytest - import networkx as nx import pandas as pd import numpy as np +from unittest.mock import patch, MagicMock +import random from networkcommons.eval import _metrics -from unittest.mock import patch -import networkcommons._utils as utils - -import unittest @pytest.fixture def network(): - network = nx.DiGraph() network.add_edge('A', 'B', weight=1) network.add_edge('B', 'C', weight=2) @@ -22,75 +18,43 @@ def network(): network.add_edge('A', 'D', weight=6) network.add_edge('A', 'E', weight=4) network.add_edge('E', 'F', weight=5) - return network def test_get_number_nodes(): - assert _metrics.get_number_nodes(nx.Graph()) == 0 assert _metrics.get_number_nodes(nx.Graph([(1, 2)])) == 2 assert _metrics.get_number_nodes(nx.Graph([(1, 2), (2, 3)])) == 3 def test_get_number_edges(): - assert _metrics.get_number_edges(nx.Graph()) == 0 assert _metrics.get_number_edges(nx.Graph([(1, 2)])) == 1 assert _metrics.get_number_edges(nx.Graph([(1, 2), (2, 3)])) == 2 def test_get_mean_degree(network): - - assert _metrics.get_mean_degree(network) == 7/3 + assert _metrics.get_mean_degree(network) == 7 / 3 def test_get_mean_betweenness(network): - assert _metrics.get_mean_betweenness(network) == 0.05833333333333334 def test_get_mean_closeness(network): - assert _metrics.get_mean_closeness(network) == 0.29444444444444445 def test_get_connected_targets(network): - target_dict = {'D': 1, 'F': 1, 'W': 1} - assert _metrics.get_connected_targets(network, target_dict) == 2 - assert ( - _metrics.get_connected_targets(network, target_dict, percent=True) == - 2 / 3 * 100 - ) + assert _metrics.get_connected_targets(network, target_dict, percent=True) == 2 / 3 * 100 def test_get_recovered_offtargets(network): - offtargets = ['B', 'D', 'W'] - assert _metrics.get_recovered_offtargets(network, offtargets) == 2 - assert ( - _metrics.get_recovered_offtargets(network, offtargets, percent=True) == - 2 / 3 * 100 - )# noqa: E501 - - -def test_get_graph_metrics(network): - - target_dict = {'D': 1, 'F': 1, 'W': 1} - - metrics = pd.DataFrame({ - 'Number of nodes': 6, - 'Number of edges': 7, - 'Mean degree': 7/3, - 'Mean betweenness': 0.05833333333333334, - 'Mean closeness': 0.29444444444444445, - 'Connected targets': 2 - }, index=[0]) - - assert _metrics.get_graph_metrics(network, target_dict).equals(metrics) + assert _metrics.get_recovered_offtargets(network, offtargets, percent=True) == 2 / 3 * 100 def test_all_nodes_in_ec50_dict(): @@ -102,7 +66,6 @@ def test_all_nodes_in_ec50_dict(): 'nodes_with_EC50': [3], 'coverage': [100.0] }) - result = _metrics.get_ec50_evaluation(network, ec50_dict) pd.testing.assert_frame_equal(result, expected_result) @@ -114,9 +77,8 @@ def test_some_nodes_in_ec50_dict(): 'avg_EC50_in': [7.5], 'avg_EC50_out': [20.0], 'nodes_with_EC50': [2], - 'coverage': [2/3 * 100] + 'coverage': [2 / 3 * 100] }) - result = _metrics.get_ec50_evaluation(network, ec50_dict) pd.testing.assert_frame_equal(result, expected_result) @@ -130,7 +92,6 @@ def test_no_nodes_in_ec50_dict(): 'nodes_with_EC50': [0], 'coverage': [0.0] }) - result = _metrics.get_ec50_evaluation(network, ec50_dict) pd.testing.assert_frame_equal(result, expected_result) @@ -144,23 +105,19 @@ def test_empty_network(): 'nodes_with_EC50': [0], 'coverage': [np.nan] }) - result = _metrics.get_ec50_evaluation(network, ec50_dict) pd.testing.assert_frame_equal(result, expected_result) def test_run_ora(): - # Create an example graph graph = nx.DiGraph() graph.add_nodes_from(["geneA", "geneB", "geneC", "geneD", "geneE", "geneF"]) - # Create an example net DataFrame net = pd.DataFrame({ 'source': ['gene_set_1', 'gene_set_1', 'gene_set_2', 'gene_set_2', 'gene_set_2'], 'target': ['geneA', 'geneB', 'geneC', 'geneD', 'geneE'] }) - # Expected output DataFrame (you need to adjust this based on expected results) expected_results = pd.DataFrame({ 'ora_Term': ["gene_set_1", "gene_set_2"], 'ora_Set size': [2, 3], @@ -173,19 +130,15 @@ def test_run_ora(): 'ora_rank': [2.0, 1.0] }) - # Run the ORA function ora_results = _metrics.run_ora(graph, net, metric='ora_Combined score', ascending=False) - # Assertions to verify the results pd.testing.assert_frame_equal(ora_results, expected_results) def test_get_phosphorylation_status(): - # Create a sample network graph network = nx.DiGraph() network.add_nodes_from(['node1', 'node2', 'node3']) - # Create a sample dataframe data = { 'stat': [0.5, 1.5, -0.5, 0.0], } @@ -196,7 +149,6 @@ def test_get_phosphorylation_status(): metric_overall = abs(dataframe['stat'].values) result_df = _metrics.get_phosphorylation_status(network, dataframe, col='stat') - print(result_df) expected_data = { 'avg_relabundance': np.mean(metric_in), @@ -206,13 +158,10 @@ def test_get_phosphorylation_status(): 'coverage': [3 / 3 * 100] } expected_df = pd.DataFrame(expected_data) - print(expected_data) - pd.testing.assert_frame_equal(result_df.reset_index(drop=True), expected_df) def test_get_metric_from_networks(): - # Create mock networks real_graph = nx.DiGraph() real_graph.add_edges_from([ ('A', 'B'), @@ -230,7 +179,6 @@ def test_get_metric_from_networks(): ('W', 'Y') ]) - # Create mock networks networks = { 'shortest_path__real': real_graph, 'shortest_path__random_1': random_graph @@ -238,7 +186,6 @@ def test_get_metric_from_networks(): target_dict = {'D': 1, 'F': 1, 'W': 1} - # Expected data expected_data = { 'Number of nodes': [5, 4], 'Number of edges': [4, 5], @@ -251,16 +198,11 @@ def test_get_metric_from_networks(): 'method': ['shortest_path', 'shortest_path'] } expected_df = pd.DataFrame(expected_data) - - # Call the function result_df = _metrics.get_metric_from_networks( networks, _metrics.get_graph_metrics, target_dict=target_dict - ) - print(result_df) - - # Verify the results + ) pd.testing.assert_frame_equal(result_df.reset_index(drop=True), expected_df) @@ -268,5 +210,150 @@ def test_function_not_found(): networks = { 'real_network__1': nx.path_graph(5), } - with unittest.TestCase().assertRaises(NameError): + with pytest.raises(NameError): _metrics.get_metric_from_networks(networks, nonexistent_function) + + +@patch('random.shuffle') +def test_perform_random_controls(mock_shuffle, network): + mock_shuffle.side_effect = lambda x: x.reverse() + inference_function = lambda g, **kw: (g, None) + n_iterations = 2 + network_name = 'test_network' + item_list = ['A', 'B', 'C', 'D', 'E', 'F'] + target_dict = {'A': 1, 'B': 1, 'C': 1} + + results = _metrics.perform_random_controls( + network, + inference_function, + n_iterations, + network_name, + randomise_measurements=True, + item_list=item_list, + target_dict=target_dict + ) + + assert len(results) == n_iterations + for i in range(n_iterations): + assert f"{network_name}__random{i+1:03d}" in results + + +def test_get_graph_metrics(): + target_dict = {'D': 1, 'F': 1, 'W': 1} + network1 = nx.DiGraph() + network1.add_edges_from([ + ('A', 'B'), + ('B', 'C'), + ('C', 'D'), + ('D', 'E') + ]) + + network2 = nx.DiGraph() + network2.add_edges_from([ + ('W', 'X'), + ('X', 'Y'), + ('Y', 'Z'), + ('Z', 'W'), + ('W', 'Y') + ]) + networks = {'network1': network1, 'network2': network2} + + expected_metrics = pd.DataFrame({ + 'Number of nodes': [5, 4], + 'Number of edges': [4, 5], + 'Mean degree': [1.6, 2.5], + 'Mean betweenness': [0.166667, 0.375000], + 'Mean closeness': [0.271667, 0.587500], + 'Connected targets': [1, 1], + 'network': ['network1', 'network2'] + }) + + metrics = _metrics.get_graph_metrics(networks, target_dict) + pd.testing.assert_frame_equal(metrics.reset_index(drop=True), expected_metrics) + assert 'network' in metrics.columns + + expected_metrics = pd.DataFrame({ + 'Number of nodes': [5], + 'Number of edges': [4], + 'Mean degree': [1.6], + 'Mean betweenness': [0.166667], + 'Mean closeness': [0.271667], + 'Connected targets': [1] + }) + print(type(network1)) + metrics = _metrics.get_graph_metrics(network1, target_dict) + pd.testing.assert_frame_equal(metrics.reset_index(drop=True), expected_metrics) + assert 'network' not in metrics.columns + + +def test_get_graph_metrics_invalid_type(): + with pytest.raises(TypeError, match="The network must be a networkx graph or a dictionary of networkx graphs."): + _metrics.get_graph_metrics(123, {}) + + +def test_shuffle_dict_keys(): + original_dict = {'A': 1, 'B': 2, 'C': 3} + items = ['A', 'B', 'C', 'X', 'Y', 'Z'] + + random.seed(42) + shuffled_dict = _metrics.shuffle_dict_keys(original_dict, items) + + expected_dict = {'A': 2, 'Y': 3, 'Z': 1} + assert shuffled_dict == expected_dict + + +def test_get_metric_from_networks_non_callable(): + networks = { + 'real_network__1': nx.path_graph(5), + } + non_callable = "I am not callable" + with pytest.raises(NameError): + _metrics.get_metric_from_networks(networks, non_callable) + + +def test_perform_random_controls_with_item_list(network): + inference_function = lambda g, **kw: (g, None) + n_iterations = 2 + network_name = 'test_network' + item_list = ['A', 'B', 'C', 'D', 'E', 'F'] + target_dict = {'A': 1, 'B': 1, 'C': 1} + + results = _metrics.perform_random_controls( + network, + inference_function, + n_iterations, + network_name, + randomise_measurements=True, + item_list=item_list, + target_dict=target_dict + ) + + assert len(results) == n_iterations + for i in range(n_iterations): + assert f"{network_name}__random{i+1:03d}" in results + +@patch("networkcommons.eval._metrics.shuffle_dict_keys") +def test_perform_random_controls_without_item_list(mock_shuffle, network): + inference_function = lambda g, **kw: (g, None) + n_iterations = 2 + network_name = 'test_network' + target_dict = {'A': 1, 'B': 1, 'C': 1} + + results = _metrics.perform_random_controls( + network, + inference_function, + n_iterations, + network_name, + randomise_measurements=False, + target_dict=target_dict + ) + + assert len(results) == n_iterations + for i in range(n_iterations): + assert f"{network_name}__random{i+1:03d}" in results + mock_shuffle.assert_not_called() + + + + + diff --git a/tests/test_methods_graph.py b/tests/test_methods_graph.py index d214498..6405cec 100644 --- a/tests/test_methods_graph.py +++ b/tests/test_methods_graph.py @@ -5,15 +5,17 @@ from networkcommons.methods import _graph +from unittest.mock import patch + def _network(weights: bool = False, signs: bool = False) -> nx.DiGraph: edges = pd.DataFrame( { - 'source': ['A', 'B', 'C', 'A', 'A', 'E'], - 'target': ['B', 'C', 'D', 'D', 'E', 'F'], - 'weight': [1, 2, 3, 6, 4, 5], - 'sign': [1, 1, -1, 1, 1, -1], + 'source': ['A', 'B', 'C', 'A', 'A', 'E', 'D'], + 'target': ['B', 'C', 'D', 'D', 'E', 'F', 'E'], + 'weight': [1, 2, 3, 6, 4, 5, 2], + 'sign': [1, 1, -1, 1, 1, -1, 1], } ) @@ -95,6 +97,94 @@ def test_run_shortest_paths(net_weighted): assert shortest_paths_res == [['A', 'D'], ['A', 'B', 'C', 'D']] +def test_run_shortest_paths_no_path_or_node_not_found(): + network = nx.DiGraph() + network.add_edge('A', 'B', weight=1) + network.add_edge('B', 'C', weight=2) + + # Source node exists, but target node does not exist + source_dict = {'A': 1} + target_dict = {'D': 1} + + subnetwork, shortest_paths_res = _graph.run_shortest_paths( + network, + source_dict, + target_dict, + ) + + assert list(subnetwork.edges) == [] + assert shortest_paths_res == [] + + # No path between source and target + target_dict = {'C': 1} + network.remove_edge('B', 'C') # Remove the edge to create no path scenario + + subnetwork, shortest_paths_res = _graph.run_shortest_paths( + network, + source_dict, + target_dict, + ) + + assert list(subnetwork.edges) == [] + assert shortest_paths_res == [] + + +def test_run_sign_consistency_branch_false(net_signed): + source_dict = {'A': 1} + target_dict = {'D': 1} # Ensure the target sign will cause the branch to be false + paths = [['A', 'B', 'C', 'D']] # Path that should not be added to sign_consistency_res + + subnetwork, sign_consistency_res = _graph.run_sign_consistency( + net_signed, + paths, + source_dict, + target_dict, + ) + + assert list(subnetwork.edges) == [] + assert sign_consistency_res == [] + + +def test_run_sign_consistency_inferred_signs(net_signed): + source_dict = {'A': 1} + target_dict = None # Set target_dict to None to trigger the else block lien 122 + paths = [['A', 'B', 'C', 'D']] # Path for testing + + subnetwork, sign_consistency_res, inferred_target_sign = _graph.run_sign_consistency( + net_signed, + paths, + source_dict, + target_dict + ) + + assert list(subnetwork.edges) == [('A', 'B'), ('B', 'C'), ('C', 'D')] + assert sign_consistency_res == [['A', 'B', 'C', 'D']] + assert inferred_target_sign == {'D': -1} # Check inferred sign based on path + + +@patch('random.choice') +def test_run_sign_consistency_ambiguous_signs(mock_random_choice, net_signed): + source_dict = {'A': 1, 'B': 1} + target_dict = None # Set target_dict to None to trigger the else block + paths = [ + ['B', 'C', 'D', 'E'], + ['A', 'E'] + ] # Paths for testing + + mock_random_choice.return_value = 1 # Mock random.choice to return 1 + subnetwork, sign_consistency_res, inferred_target_sign = _graph.run_sign_consistency( + net_signed, + paths, + source_dict, + target_dict, + ) + + assert list(subnetwork.edges) == [('A', 'E')] + assert sign_consistency_res == [['A', 'E']] + assert inferred_target_sign == {'E': 1} + mock_random_choice.assert_called_once_with([-1, 1]) + + def test_run_sign_consistency(net_signed): source_dict = {'A': 1} @@ -118,8 +208,9 @@ def test_run_reachability_filter(net): source_dict = {'B': 1} subnetwork = _graph.run_reachability_filter(net, source_dict) + print(subnetwork.edges) - assert list(subnetwork.edges) == [('B', 'C'), ('C', 'D')] + assert list(subnetwork.edges) == [('B', 'C'), ('C', 'D'), ('D', 'E'), ('E', 'F')] def test_run_all_paths(net_weighted): @@ -140,6 +231,48 @@ def test_run_all_paths(net_weighted): assert all_paths_res == [['A', 'B', 'C', 'D'], ['A', 'D']] +def test_run_all_paths_exceptions(): + # Create a network that will trigger the exceptions + network = nx.DiGraph() + network.add_edge('A', 'B') + network.add_edge('B', 'C') + + # Define source and target dictionaries that will cause exceptions + source_dict = {'A': 1} + target_dict = {'D': 1} # 'D' is not connected to 'A', causing NetworkXNoPath + source_dict_not_in_graph = {'X': 1} # 'X' is not in the graph, causing NodeNotFound + + # Check if the function handles NetworkXNoPath exception without raising it + try: + subnetwork, all_paths_res = _graph.run_all_paths( + network, + source_dict, + target_dict, + ) + except nx.NetworkXNoPath: + pytest.fail("NetworkXNoPath was raised") + except nx.NodeNotFound: + pytest.fail("NodeNotFound was raised") + + assert all_paths_res == [] + assert list(subnetwork.edges) == [] + + # Check if the function handles NodeNotFound exception without raising it + try: + subnetwork, all_paths_res = _graph.run_all_paths( + network, + source_dict_not_in_graph, + target_dict, + ) + except nx.NetworkXNoPath: + pytest.fail("NetworkXNoPath was raised") + except nx.NodeNotFound: + pytest.fail("NodeNotFound was raised") + + assert all_paths_res == [] + assert list(subnetwork.edges) == [] + + def test_add_pagerank_scores(net2): network, source_dict, target_dict = net2 @@ -197,6 +330,44 @@ def test_add_pagerank_scores(net2): pytest.approx(network_with_pagerank.edges[edge]) ) +# TODO: i don't know why in the codecov it says it's missing this branch, + # targeted by this test (personalization is None) + + +def test_add_pagerank_scores_no_personalization(): + # Create a test network + network = nx.DiGraph() + network.add_edge('A', 'B', weight=1) + network.add_edge('B', 'C', weight=2) + network.add_edge('C', 'D', weight=3) + network.add_edge('A', 'D', weight=10) + network.add_edge('D', 'E', weight=4) + network.add_edge('E', 'F', weight=5) + + source_dict = {'A': 1} + target_dict = {'D': 1} + + # Run the add_pagerank_scores function without personalization + network_with_pagerank = _graph.add_pagerank_scores( + network, + source_dict, + target_dict, + personalize_for=None, + ) + + # Check that the PageRank scores are added to the nodes + for node in network_with_pagerank.nodes: + assert 'pagerank' in network_with_pagerank.nodes[node] + + # Verify that the PageRank scores are correct + expected_pagerank = nx.pagerank(network, + alpha=0.85, + max_iter=100, + tol=1.0e-6, + weight='weight') + for node, pr_value in expected_pagerank.items(): + assert network_with_pagerank.nodes[node]['pagerank'] == pr_value + def test_compute_ppr_overlap(net2): @@ -251,3 +422,25 @@ def test_compute_ppr_overlap(net2): test_network.edges[edge] == pytest.approx(subnetwork.edges[edge]) ) + + +def test_compute_ppr_overlap_keyerror(): + # Create a test network without PageRank attributes + network1 = nx.DiGraph() + network1.add_edge('A', 'B', weight=1) + network1.add_edge('B', 'C', weight=2) + network1.add_edge('C', 'D', weight=3) + network1.add_edge('A', 'D', weight=10) + network1.add_edge('D', 'E', weight=4) + network1.add_edge('E', 'F', weight=5) + + # Ensure no PageRank attributes are added + for node in network1.nodes: + assert 'pagerank_from_sources' not in network1.nodes[node] + assert 'pagerank_from_targets' not in network1.nodes[node] + + # Attempt to compute PPR overlap and expect KeyError + with pytest.raises(KeyError, match="Please run the add_pagerank_scores method first with \ + personalization options."): + _graph.compute_ppr_overlap(network1) + diff --git a/tests/test_moon.py b/tests/test_moon.py index de7c8b4..3f45fa0 100644 --- a/tests/test_moon.py +++ b/tests/test_moon.py @@ -1,6 +1,8 @@ import networkx as nx import pandas as pd from networkcommons.methods import _moon +from unittest.mock import patch +import pytest def test_meta_network_cleanup(): @@ -35,6 +37,32 @@ def test_prepare_metab_inputs(): assert len(prepared_input) == 4, "Unexpected number of metabolite inputs" +def test_prepare_metab_inputs_no_valid_compartments(): + metab_input = {'glucose': 1.0, 'fructose': 2.0} + compartment_codes = ['invalid'] + + prepared_input = _moon.prepare_metab_inputs(metab_input, compartment_codes) + + assert 'Metab__glucose' in prepared_input + assert 'Metab__fructose' in prepared_input + assert 'Metab__glucose_invalid' not in prepared_input + assert 'Metab__fructose_invalid' not in prepared_input + assert len(prepared_input) == 2, "Unexpected number of metabolite inputs when no valid compartments" + + +def test_prepare_metab_inputs_with_valid_compartments(): + metab_input = {'glucose': 1.0, 'fructose': 2.0} + compartment_codes = ['c', 'm'] + + prepared_input = _moon.prepare_metab_inputs(metab_input, compartment_codes) + + assert 'Metab__glucose_c' in prepared_input + assert 'Metab__fructose_m' in prepared_input + assert 'Metab__glucose_m' in prepared_input + assert 'Metab__fructose_c' in prepared_input + assert len(prepared_input) == 4, "Unexpected number of metabolite inputs with valid compartments" + + def test_is_expressed(): expressed_genes_entrez = ["GENE1", "GENE2", "GENE3"] @@ -81,26 +109,50 @@ def test_filter_pkn_expressed_genes(): assert len(filtered_graph.nodes) == 2, "Unexpected number of nodes" -def test_filter_input_nodes_not_in_pkn(): - +@patch('networkcommons.methods._moon._log') +def test_filter_input_nodes_not_in_pkn(mock_log): data = {'Gene1': 1, 'Gene2': 2, 'Gene3': 3} graph = nx.DiGraph() graph.add_nodes_from(['Gene1', 'Gene2']) filtered_data = _moon.filter_input_nodes_not_in_pkn(data, graph) - assert 'Gene3' not in filtered_data, "Node not in PKN not removed" - assert len(filtered_data) == 2, "Unexpected number of input nodes" + # Check that nodes not in PKN are removed + assert 'Gene3' not in filtered_data + assert len(filtered_data) == 2 + # Check that _log was called with the correct message + mock_log.assert_called_with("COSMOS: 1 input/measured nodes are not in PKN anymore: ['Gene3']") + + +@patch('networkcommons.methods._moon._log') +def test_filter_input_nodes_not_in_pkn_nofilter(mock_log): + data = {'Gene1': 1, 'Gene2': 2, 'Gene3': 3} + graph = nx.DiGraph() + graph.add_nodes_from(['Gene1', 'Gene2', 'Gene3']) + + filtered_data = _moon.filter_input_nodes_not_in_pkn(data, graph) + + # Check that nodes not in PKN are removed + assert 'Gene3' in filtered_data + assert 'Gene1' in filtered_data + assert 'Gene2' in filtered_data + assert len(filtered_data) == 3 + + # Check that _log was not called + mock_log.assert_not_called() -def test_keep_controllable_neighbours(): +def test_keep_controllable_neighbours(): source_dict = {'Gene1': 1, 'Gene2': 1} graph = nx.DiGraph() - graph.add_edges_from([('Gene1', 'Gene3'), - ('Gene2', 'Gene4'), - ('Gene0', 'Gene1')]) + graph.add_edges_from([ + ('Gene1', 'Gene3'), + ('Gene2', 'Gene4'), + ('Gene0', 'Gene1') + ]) + # Assume _graph.run_reachability_filter is correctly implemented and tested elsewhere filtered_sources = _moon.keep_controllable_neighbours(source_dict, graph) assert 'Gene1' in filtered_sources @@ -111,14 +163,16 @@ def test_keep_controllable_neighbours(): def test_keep_observable_neighbours(): - target_dict = {'Gene3': 1, 'Gene4': 1} graph = nx.DiGraph() - graph.add_edges_from([('Gene1', 'Gene3'), - ('Gene2', 'Gene4'), - ('Gene0', 'Gene1'), - ('Gene4', 'Gene5')]) + graph.add_edges_from([ + ('Gene1', 'Gene3'), + ('Gene2', 'Gene4'), + ('Gene0', 'Gene1'), + ('Gene4', 'Gene5') + ]) + # Assume _graph.run_reachability_filter is correctly implemented and tested elsewhere filtered_targets = _moon.keep_observable_neighbours(target_dict, graph) assert 'Gene2' in filtered_targets @@ -173,17 +227,40 @@ def test_compress_same_children(): assert len(duplicated_parents) == 0, "Duplicated parents mismatch" # noqa E501 -def test_run_moon_core(): +def test_compress_same_children_conflicting_signatures(): + graph = nx.DiGraph() + graph.add_edges_from([ + ('A', 'B', {'sign': -1}), + ('A', 'C', {'sign': 1}), + ('B', 'D', {'sign': 1}), + ('C', 'D', {'sign': 1}), # Conflicting sign + ]) + sig_input = [] + metab_input = [] + + ( + subnetwork, + node_signatures, + duplicated_parents, + ) = _moon.compress_same_children(graph, sig_input, metab_input) + assert 'A' in subnetwork.nodes, "Node with conflicting signatures compressed" + assert 'B' in subnetwork.nodes, "Node with conflicting signatures compressed" + assert 'C' in subnetwork.nodes, "Node with conflicting signatures compressed" + assert 'D' in subnetwork.nodes, "Node with conflicting signatures compressed" + assert len(subnetwork.nodes) == 4, "Unexpected number of nodes in subnetwork" + + +def test_run_moon_core_no_upstream(): graph = nx.DiGraph() graph.add_edges_from([ ('A', 'B', {'sign': 1}), ('B', 'C', {'sign': 1}), - ('B', 'D', {'sign': 1}), + ('C', 'D', {'sign': 1}), ('D', 'E', {'sign': 1}), ('E', 'F', {'sign': -1}), ]) - upstream_input = {'A': 1} + upstream_input = None downstream_input = {'E': 0.5, 'F': -2} result = _moon.run_moon_core( @@ -199,6 +276,100 @@ def test_run_moon_core(): assert len(result.index) == 3, "Unexpected number of rows in result" assert result.empty is False, "Empty result" + result_norm = _moon.run_moon_core( + upstream_input=upstream_input, + downstream_input=downstream_input, + graph=graph, + n_layers=5, + statistic='norm_wmean' + ) + + assert 'score' in result_norm.columns, "Score column missing in result" + assert 'source' in result_norm.columns, "Source column missing in result" + assert len(result_norm.index) == 3, "Unexpected number of rows in result" + assert result_norm.empty is False, "Empty result" + # assert frames are different + assert not result.equals(result_norm), "Results are the same" + + +def test_run_moon_core_invalid_method(): + with pytest.raises(ValueError, match="Invalid method. Currently supported: 'ulm' or 'wmean'."): + _moon.run_moon_core( + upstream_input={'A': 1}, + downstream_input={'E': 0.5, 'F': -2}, + graph=nx.DiGraph(), + n_layers=5, + statistic='invalid_method' + ) + + +@patch('networkcommons.methods._moon._log') +def test_run_moon_core_while_loop(mock_log): + # Create a sample graph + graph = nx.DiGraph() + graph.add_edges_from([ + ('A', 'B', {'sign': 1}), + ('B', 'C', {'sign': 1}), + ('B', 'D', {'sign': 1}), + ('C', 'D', {'sign': 1}), + ('C', 'E', {'sign': 1}), + ('D', 'E', {'sign': 1}), + ('D', 'H', {'sign': 1}), + ('E', 'F', {'sign': -1}), + ('G', 'H', {'sign': 1}), + ]) + + upstream_input = {'A': 1} + downstream_input = {'H': 0.5, 'F': -2, 'G': 1} + + # Make sure that the while loop condition is met + result = _moon.run_moon_core( + upstream_input=upstream_input, + downstream_input=downstream_input, + graph=graph, + n_layers=5, + statistic='ulm' + ) + + assert 'score' in result.columns, "Score column missing in result" + assert 'source' in result.columns, "Source column missing in result" + assert len(result.index) > 0, "Unexpected number of rows in result" + assert not result.empty, "Empty result" + + mock_log.assert_any_call("Iteration count: 1") + + result_wmean = _moon.run_moon_core( + upstream_input=upstream_input, + downstream_input=downstream_input, + graph=graph, + n_layers=5, + statistic='wmean' + ) + + assert 'score' in result_wmean.columns, "Score column missing in result" + assert 'source' in result_wmean.columns, "Source column missing in result" + assert len(result_wmean.index) > 0, "Unexpected number of rows in result" + assert not result_wmean.empty, "Empty result" + + # Check that the while loop executed by checking log calls + mock_log.assert_any_call("Iteration count: 1") + + result_norm_wmean = _moon.run_moon_core( + upstream_input=upstream_input, + downstream_input=downstream_input, + graph=graph, + n_layers=5, + statistic='norm_wmean' + ) + + assert 'score' in result_norm_wmean.columns, "Score column missing in result" + assert 'source' in result_norm_wmean.columns, "Source column missing in result" + assert len(result_norm_wmean.index) > 0, "Unexpected number of rows in result" + assert not result_norm_wmean.empty, "Empty result" + + # Check that the while loop executed by checking log calls + mock_log.assert_any_call("Iteration count: 1") + def test_filter_incoherent_TF_target(): @@ -336,3 +507,205 @@ def test_translate_res(): assert 'Metab__Alpha_a' in translated_network.nodes, "Translation failed" assert 'Metab__Alpha_a' in translated_att['nodes'].values, \ "Translation failed in attributes" + + +def test_run_moon(): + network = nx.DiGraph() + network.add_edges_from([ + ('A', 'B', {'sign': 1}), + ('B', 'C', {'sign': 1}), + ('B', 'D', {'sign': 1}), + ('D', 'E', {'sign': 1}), + ('E', 'F', {'sign': -1}), + ]) + sig_input = {'A': 1} + metab_input = {'E': 0.5, 'F': -2} + tf_regn = pd.DataFrame({'source': ['TF1', 'TF1'], 'target': ['Gene1', 'Gene2'], 'weight': [1, -1]}) + rna_input = {'Gene1': -1, 'Gene2': -1} + + moon_res, moon_network = _moon.run_moon( + network, + sig_input, + metab_input, + tf_regn, + rna_input, + n_layers=5, + method='ulm', + max_iter=3 + ) + + assert 'score' in moon_res.columns, "Score column missing in result" + assert len(moon_network.nodes) > 0, "Empty moon network" + + +@patch('networkcommons.methods._moon._log') +def test_run_moon_non_convergence(mock_log): + network = nx.DiGraph() + network.add_edges_from([ + ('A', 'B', {'sign': 1}), + ('B', 'C', {'sign': 1}), + ('B', 'D', {'sign': 1}), + ('D', 'E', {'sign': 1}), + ('E', 'F', {'sign': -1}), + ]) + sig_input = {'A': 1} + metab_input = {'E': 0.5, 'F': -2} + tf_regn = pd.DataFrame({'source': ['TF1', 'TF1'], 'target': ['Gene1', 'Gene2'], 'weight': [1, -1]}) + rna_input = {'Gene1': -1, 'Gene2': -1} + + moon_res, moon_network = _moon.run_moon( + network, + sig_input, + metab_input, + tf_regn, + rna_input, + n_layers=5, + method='ulm', + max_iter=1 + ) + + mock_log.assert_called_with("MOON: Maximum number of iterations reached." + "Solution might not have converged") + + +def test_reduce_solution_network_edge_removal(): + # Sample moon_res DataFrame + moon_res = pd.DataFrame({ + 'source_original': ['A', 'B', 'C', 'D', 'E'], + 'source': ['A', 'B', 'C', 'D', 'E'], + 'score': [-1.5, 1.2, -0.8, 0.7, -0.9] + }) + + # Sample meta_network + meta_network = nx.DiGraph() + meta_network.add_edges_from([ + ('A', 'B', {'sign': -1}), + ('B', 'C', {'sign': -1}), + ('C', 'D', {'sign': -1}), + ('D', 'E', {'sign': 1}), + ('C', 'E', {'sign': 1}) + ]) + + # Sample sig_input + sig_input = {'A': -1} + rna_input = {'B': 1, 'D': -3.5} + + # Expected output + expected_edges = [ + ('A', 'B'), + ('B', 'C'), + ('C', 'D'), + ('C', 'E') + ] + + # Run the function + res_network, att = _moon.reduce_solution_network( + moon_res, meta_network, cutoff=0.5, sig_input=sig_input, rna_input=rna_input + ) + + # edge ('B', 'C') was removed + assert set(res_network.edges) == set(expected_edges), "Edges do not match expected result" + for node in res_network.nodes: + assert 'moon_score' in res_network.nodes[node], "moon_score attribute missing" + + +def test_reduce_solution_network_without_rna_input(): + # Sample moon_res DataFrame + moon_res = pd.DataFrame({ + 'source_original': ['A', 'B', 'C', 'D', 'E'], + 'source': ['A', 'B', 'C', 'D', 'E'], + 'score': [-1.5, 1.2, -0.8, 0.5, 0.3] + }) + + # Sample meta_network + meta_network = nx.DiGraph() + meta_network.add_edges_from([ + ('A', 'B', {'sign': -1}), + ('B', 'C', {'sign': -1}), + ('C', 'D', {'sign': -1}), + ('D', 'E', {'sign': 1}), + ('C', 'E', {'sign': 1}) + ]) + + # Sample sig_input + sig_input = {'A': -1} + + # Expected output + expected_edges = [ + ('A', 'B'), + ('B', 'C') + ] + + # Run the function + res_network, att = _moon.reduce_solution_network( + moon_res, meta_network, cutoff=0.5, sig_input=sig_input, rna_input=None + ) + + # Check if the edges are as expected + assert set(res_network.edges) == set(expected_edges), "Edges do not match expected result" + + # Check if the moon_score attribute is present in the nodes + for node in res_network.nodes: + assert 'moon_score' in res_network.nodes[node], "moon_score attribute missing" + + # Check the RNA_input column in the attributes dataframe + assert 'RNA_input' in att.columns, "Missing RNA_input column in attributes" + assert att['RNA_input'].isna().all(), "RNA_input column should contain only NaN values" + + +def test_translate_res_edge_cases(): + G = nx.DiGraph() + G.add_edges_from([ + ("Metab__HMDB1_a", "Metab__HMDB2_b"), + ("Metab__HMDB3_b", "GeneC_c"), + ("Metab__HMDB4_d", "GeneD_e"), + ('TAP1', 'GeneD_e') + ]) + + att_data = { + "nodes": [ + "Metab__HMDB1_a", + "Metab__HMDB2_b", + "Metab__HMDB3_b", + "GeneC_c", + "Metab__HMDB4_d", + "GeneD_e", + "TAP1" + ], + "score": [1, 2, 3, 4, 5, 6, 7] + } + att_df = pd.DataFrame(att_data) + + mapping_dict = { + "HMDB1": "Alpha", + "HMDB2": "Beta", + "HMDB3": "Gamma", + "HMDB4": "Delta" + } + + translated_network, translated_att = _moon.translate_res( + G, att_df, mapping_dict + ) + expected_edges = [ + ("Metab__Alpha_a", "Metab__Beta_b"), + ("Metab__Gamma_b", "EnzymeC"), + ("Metab__Delta_d", "EnzymeD"), + ('TAP1', 'EnzymeD') + ] + expected_att_nodes = [ + "Metab__Alpha_a", + "Metab__Beta_b", + "Metab__Gamma_b", + "EnzymeC_c", + "Metab__Delta_d", + "EnzymeD_e", + "TAP1" + ] + + assert set(translated_network.edges()) == set(expected_edges), "Translated network edges are incorrect" + assert translated_att['nodes'].tolist() == expected_att_nodes, "Translated attribute table nodes are incorrect" + assert 'Metab__Alpha_a' in translated_network.nodes, "Translation failed" + assert 'Metab__Alpha_a' in translated_att['nodes'].values, "Translation failed in attributes" + assert 'Metab__Delta_d' in translated_network.nodes, "Translation failed for new node" + assert 'Metab__Delta_d' in translated_att['nodes'].values, "Translation failed in attributes for new node" + assert 'TAP1' in translated_network.nodes, "Translation failed for TAP1" diff --git a/tests/test_omics.py b/tests/test_omics.py index bcebf65..2c841d7 100644 --- a/tests/test_omics.py +++ b/tests/test_omics.py @@ -6,12 +6,15 @@ from networkcommons.data.omics import _common from networkcommons.data import omics -from unittest.mock import patch, MagicMock +from unittest.mock import patch, MagicMock, mock_open +import zipfile +import bs4 import responses +import contextlib - +# FILE: omics/_common.py def test_datasets(): dsets = _common._datasets() @@ -38,22 +41,6 @@ def test_commons_url(): assert 'metadata' in url -@pytest.mark.slow -def test_download(tmp_path): - - url = _common._commons_url('test', table = 'meta') - path = tmp_path / 'test_download.tsv' - _common._download(url, path) - - assert path.exists() - - with open(path) as fp: - - line = next(fp) - - assert line.startswith('sample_ID\t') - - @pytest.mark.slow def test_open(): @@ -66,6 +53,7 @@ def test_open(): assert line.startswith('sample_ID\t') +@pytest.mark.slow def test_open_df(): url = _common._commons_url('test', table = 'meta') @@ -75,59 +63,554 @@ def test_open_df(): assert df.shape == (4, 2) -@pytest.mark.slow -def test_decryptm_datasets(): +@patch('networkcommons.data.omics._common._maybe_download') +@patch('pandas.read_csv') +def test_open_with_pandas_readers(mock_csv, mock_download): + mock_download.return_value = 'test.csv' + ftype = 'csv' + _common._open('http://example.com/test.csv', ftype, df=True) + + mock_download.assert_called_once_with('http://example.com/test.csv') + + mock_csv.assert_called_once_with('test.csv') + + +def test_open_tsv(): + url = "http://example.com/test.tsv" + with patch('networkcommons.data.omics._common._maybe_download', return_value='path/to/test.tsv'), \ + patch('builtins.open', mock_open(read_data="col1\tcol2\nval1\tval2")): + with _common._open(url, ftype='tsv') as f: + content = f.read() + assert "col1\tcol2\nval1\tval2" in content + + +def test_open_html(): + url = "http://example.com/test.html" + with patch('networkcommons.data.omics._common._maybe_download', return_value='path/to/test.html'), \ + patch('builtins.open', mock_open(read_data="Test")): + result = _common._open(url, ftype='html') + assert isinstance(result, bs4.BeautifulSoup) + assert result.body.text == "Test" + + +@patch('networkcommons.data.omics._common._maybe_download') +@patch('contextlib.closing') +@patch('zipfile.ZipFile') +def test_open_zip(mock_zip, contextlib_mock, mock_maybe_download): + url = "http://example.com/test.zip" + mock_maybe_download.return_value = 'path/to/test.zip' + mock_zip.return_value = MagicMock() + + result = _common._open(url, ftype='zip') + mock_zip.assert_called_once_with('path/to/test.zip', 'r') + contextlib_mock.assert_called_once_with(mock_zip.return_value) + + +@patch('networkcommons.data.omics._common._download') +@patch('networkcommons.data.omics._common._log') +@patch('networkcommons.data.omics._common._conf.get') +@patch('os.path.exists') +@patch('hashlib.md5') +def test_maybe_download_exists(mock_md5, mock_exists, mock_conf_get, mock_log, mock_download): + # Setup mock values + url = 'http://example.com/file.txt' + md5_hash = MagicMock() + md5_hash.hexdigest.return_value = 'dummyhash' + mock_md5.return_value = md5_hash + mock_conf_get.return_value = '/mock/cache/dir' + mock_exists.return_value = True + + # Call the function + path = _common._maybe_download(url) + + # Assertions + mock_md5.assert_called_once_with(url.encode()) + mock_conf_get.assert_called_once_with('cachedir') + mock_exists.assert_called_once_with('/mock/cache/dir/dummyhash-file.txt') + mock_log.assert_called_once_with('Looking up in cache: `http://example.com/file.txt` -> `/mock/cache/dir/dummyhash-file.txt`.') + mock_download.assert_not_called() + assert path == '/mock/cache/dir/dummyhash-file.txt' + + +@patch('networkcommons.data.omics._common._download') +@patch('networkcommons.data.omics._common._log') +@patch('networkcommons.data.omics._common._conf.get') +@patch('os.path.exists') +@patch('hashlib.md5') +def test_maybe_download_not_exists(mock_md5, mock_exists, mock_conf_get, mock_log, mock_download): + # Setup mock values + url = 'http://example.com/file.txt' + md5_hash = MagicMock() + md5_hash.hexdigest.return_value = 'dummyhash' + mock_md5.return_value = md5_hash + mock_conf_get.return_value = '/mock/cache/dir' + mock_exists.return_value = False + + # Call the function + path = _common._maybe_download(url) + + # Assertions + mock_md5.assert_called_once_with(url.encode()) + mock_conf_get.assert_called_once_with('cachedir') + mock_exists.assert_called_once_with('/mock/cache/dir/dummyhash-file.txt') + mock_log.assert_any_call('Looking up in cache: `http://example.com/file.txt` -> `/mock/cache/dir/dummyhash-file.txt`.') + mock_log.assert_any_call('Not found in cache, initiating download: `http://example.com/file.txt`.') + mock_download.assert_called_once_with(url, '/mock/cache/dir/dummyhash-file.txt') + assert path == '/mock/cache/dir/dummyhash-file.txt' + + +@patch('networkcommons.data.omics._common._requests_session') +@patch('networkcommons.data.omics._common._log') +@patch('networkcommons.data.omics._common._conf.get') +def test_download(mock_conf_get, mock_log, mock_requests_session, tmp_path): + # Setup mock values + url = 'http://example.com/file.txt' + path = tmp_path / 'file.txt' + timeouts = (5, 5) + mock_conf_get.side_effect = lambda k: 5 if k in ('http_read_timout', 'http_connect_timout') else None + mock_session = MagicMock() + mock_requests_session.return_value = mock_session + mock_response = MagicMock() + mock_response.iter_content.return_value = [b'test content'] + mock_session.get.return_value.__enter__.return_value = mock_response + + # Call the function + _common._download(url, str(path)) + + # Assertions + mock_conf_get.assert_any_call('http_read_timout') + mock_conf_get.assert_any_call('http_connect_timout') + mock_log.assert_any_call(f'Downloading `{url}` to `{path}`.') + mock_log.assert_any_call(f'Finished downloading `{url}` to `{path}`.') + mock_requests_session.assert_called_once() + mock_session.get.assert_called_once_with(url, timeout=(5, 5), stream=True) + mock_response.raise_for_status.assert_called_once() + mock_response.iter_content.assert_called_once_with(chunk_size=8192) + + # Check that the file was written correctly + with open(path, 'rb') as f: + content = f.read() + assert content == b'test content' + + +def test_ls_success(): + url = "http://example.com/dir/" + html_content = ''' + + + file1.txt + file2.txt + parent + + + ''' + + with responses.RequestsMock() as rsps: + rsps.add(responses.GET, url, body=html_content, status=200) + result = _common._ls(url) + assert result == ["file1.txt", "file2.txt"] + + +def test_ls_not_found(): + url = "http://example.com/dir/" + + with responses.RequestsMock() as rsps: + rsps.add(responses.GET, url, status=404) + with pytest.raises(FileNotFoundError, match="URL http://example.com/dir/ returned status code 404"): + _common._ls(url) + + +@patch('networkcommons.data.omics._common._maybe_download') +def test_open_unknown_file_type(mock_maybe_download): + url = 'http://example.com/file.unknown' + mock_maybe_download.return_value = 'file.unknown' + with pytest.raises(NotImplementedError, match='Can not open file type `unknown`.'): + _common._open(url, 'unknown') + + +@patch('networkcommons.data.omics._common._maybe_download') +def test_open_no_extension(mock_maybe_download): + url = 'http://example.com/file' + mock_maybe_download.return_value = 'file' + with pytest.raises(RuntimeError, match='Cannot determine file type for http://example.com/file.'): + _common._open(url) + + +# FILE: omics/_decryptm.py +@pytest.fixture +def decryptm_args(): + return 'KDAC_Inhibitors', 'Acetylome', 'curves_CUDC101.txt' + - dsets = omics.decryptm_datasets() +@patch('networkcommons.data.omics._decryptm._common._ls') +@patch('networkcommons.data.omics._decryptm._common._baseurl', return_value='http://example.com') +@patch('pandas.read_pickle') +@patch('os.path.exists', return_value=False) +@patch('pandas.DataFrame.to_pickle') +def test_decryptm_datasets_update(mock_to_pickle, mock_path_exists, mock_read_pickle, mock_baseurl, mock_ls): + # Mock the directory listing + mock_ls.side_effect = [ + ['experiment1', 'experiment2'], # First call, list experiments + ['data_type1', 'data_type2'], # Second call, list data types for experiment1 + ['curves_file1.txt', 'curves_file2.txt'], # Third call, list files for experiment1/data_type1 + ['curves_file3.txt', 'curves_file4.txt'], # Fourth call, list files for experiment1/data_type2 + ['data_type1', 'data_type2'], # Fifth call, list data types for experiment2 + ['curves_file5.txt', 'curves_file6.txt'], # Sixth call, list files for experiment2/data_type1 + ['curves_file7.txt', 'curves_file8.txt'] # Seventh call, list files for experiment2/data_type2 + ] + + dsets = omics.decryptm_datasets(update=True) assert isinstance(dsets, pd.DataFrame) - assert dsets.shape == (51, 3) - assert dsets.fname.str.contains('curves').all() + assert dsets.shape == (8, 3) # 4 experiments * 2 data types = 8 files + assert dsets.columns.tolist() == ['experiment', 'data_type', 'fname'] + mock_to_pickle.assert_called_once() + + +@patch('pandas.read_pickle') +@patch('os.path.exists', return_value=True) +def test_decryptm_datasets_cached(mock_path_exists, mock_read_pickle): + # Mock the cached DataFrame + mock_df = pd.DataFrame({ + 'experiment': ['experiment1', 'experiment2'], + 'data_type': ['data_type1', 'data_type2'], + 'fname': ['curves_file1.txt', 'curves_file2.txt'] + }) + mock_read_pickle.return_value = mock_df + dsets = omics.decryptm_datasets(update=False) -@pytest.fixture -def decryptm_args(): - - return 'KDAC_Inhibitors', 'Acetylome', 'curves_CUDC101.txt' + assert isinstance(dsets, pd.DataFrame) + assert dsets.shape == (2, 3) + assert dsets.columns.tolist() == ['experiment', 'data_type', 'fname'] + mock_read_pickle.assert_called_once() -@pytest.mark.slow -def test_decryptm_table(decryptm_args): +@patch('networkcommons.data.omics._decryptm._common._open') +def test_decryptm_table(mock_open, decryptm_args): + mock_df = pd.DataFrame({'EC50': [0.5, 1.0, 1.5]}) + mock_open.return_value = mock_df df = omics.decryptm_table(*decryptm_args) assert isinstance(df, pd.DataFrame) - assert df.shape == (18007, 65) + assert df.shape == (3, 1) assert df.EC50.dtype == 'float64' + mock_open.assert_called_once() -@pytest.mark.slow -def test_decryptm_experiment(decryptm_args): +@patch('networkcommons.data.omics._decryptm.decryptm_datasets') +@patch('networkcommons.data.omics._decryptm.decryptm_table') +def test_decryptm_experiment(mock_decryptm_table, mock_decryptm_datasets, decryptm_args): + mock_decryptm_datasets.return_value = pd.DataFrame({ + 'experiment': ['KDAC_Inhibitors', 'KDAC_Inhibitors'], + 'data_type': ['Acetylome', 'Acetylome'], + 'fname': ['curves_CUDC101.txt', 'curves_other.txt'] + }) + mock_df = pd.DataFrame({'EC50': [0.5, 1.0, 1.5]}) + mock_decryptm_table.return_value = mock_df - dfs = omics.decryptm_experiment(*decryptm_args[:2]) + dfs = omics.decryptm_experiment(decryptm_args[0], decryptm_args[1]) assert isinstance(dfs, list) - assert len(dfs) == 4 + assert len(dfs) == 2 assert all(isinstance(df, pd.DataFrame) for df in dfs) - assert dfs[3].shape == (15993, 65) - assert dfs[3].EC50.dtype == 'float64' + assert dfs[0].shape == (3, 1) + assert dfs[0].EC50.dtype == 'float64' + mock_decryptm_table.assert_called() -@pytest.mark.slow -def test_panacea(): +@patch('networkcommons.data.omics._decryptm.decryptm_datasets') +def test_decryptm_experiment_no_dataset(mock_decryptm_datasets): + mock_decryptm_datasets.return_value = pd.DataFrame({ + 'experiment': ['KDAC_Inhibitors'], + 'data_type': ['Acetylome'], + 'fname': ['curves_CUDC101.txt'] + }) - dfs = omics.panacea() + with pytest.raises(ValueError, match='No such dataset in DecryptM: `Invalid_Experiment/Invalid_Type`.'): + omics.decryptm_experiment('Invalid_Experiment', 'Invalid_Type') - assert isinstance(dfs, tuple) - assert len(dfs) == 2 - assert all(isinstance(df, pd.DataFrame) for df in dfs) - assert dfs[0].shape == (24961, 1217) - assert dfs[1].shape == (1216, 2) - assert (dfs[0].drop('gene_symbol', axis = 1).dtypes == 'int64').all() + +# FILE: omics/_panacea.py + +@patch('networkcommons.data.omics._panacea._common._baseurl', return_value='http://example.com') +@patch('pandas.read_pickle') +@patch('os.path.exists', return_value=False) +@patch('os.makedirs') +@patch('pandas.DataFrame.to_pickle') +@patch('urllib.request.urlopen') +def test_panacea_experiments(mock_urlopen, mock_to_pickle, mock_makedirs, mock_path_exists, mock_read_pickle, mock_baseurl): + # Mock the HTTP response for the metadata file + mock_response = MagicMock() + mock_response.read.return_value = b"group\tsample_ID\nA_B\tID1\nC_D\tID2" + mock_response.__enter__.return_value = mock_response + mock_urlopen.return_value = mock_response + + result_df = omics.panacea_experiments(update=True) + + assert isinstance(result_df, pd.DataFrame) + assert 'cell' in result_df.columns + assert 'drug' in result_df.columns + + mock_to_pickle.assert_called_once() + + +@patch('networkcommons.data.omics._panacea._common._baseurl', return_value='http://example.com') +@patch('pandas.read_pickle') +@patch('os.path.exists', return_value=True) +def test_panacea_experiments_cached(mock_path_exists, mock_read_pickle, mock_baseurl): + # Mock the cached data + mock_df = pd.DataFrame({'cell': ['A', 'C'], 'drug': ['B', 'D']}) + mock_read_pickle.return_value = mock_df + + result_df = omics.panacea_experiments(update=False) + + mock_read_pickle.assert_called_once() + assert result_df.equals(mock_df) + + +def test_panacea_datatypes(): + dtypes = omics.panacea_datatypes() + + expected_df = pd.DataFrame({ + 'type': ['raw', 'diffexp', 'TF_scores'], + 'description': [ + 'RNA-Seq raw counts and metadata containing sample, name, and group', + 'Differential expression analysis with filterbyExpr+DESeq2', + 'Transcription factor activity scores with CollecTRI + T-values' + ] + }) + + pd.testing.assert_frame_equal(dtypes, expected_df) + + +@patch('pandas.read_csv') +@patch('networkcommons.data.omics._panacea._common._baseurl', return_value='http://example.com') +def test_panacea_tables_diffexp(mock_baseurl, mock_read_csv): + # Mock the data + mock_df = pd.DataFrame({ + 'gene': ['gene1', 'gene2'], + 'log2FoldChange': [1.5, -2.3], + 'pvalue': [0.01, 0.05] + }) + mock_read_csv.return_value = mock_df + + result_df = omics.panacea_tables(cell_line='cell1', drug='drug1', type='diffexp') + + assert isinstance(result_df, pd.DataFrame) + assert 'gene' in result_df.columns + assert 'log2FoldChange' in result_df.columns + assert 'pvalue' in result_df.columns + + +@patch('networkcommons.data.omics._panacea._common._open') +@patch('networkcommons.data.omics._panacea._common._baseurl', return_value='http://example.com') +def test_panacea_tables_convert_to_list(mock_baseurl, mock_open): + # Mock the metadata + mock_meta = pd.DataFrame({ + 'sample_ID': ['sample1', 'sample2', 'sample3', 'sample4', 'sample5', 'sample6'], + 'group': ['cell1_drug1', 'cell1_drug2', 'cell2_drug1', 'cell2_drug2', 'cell1_drug1', 'cell1_drug2'] + }) + # Mock the count data + mock_count = pd.DataFrame({ + 'gene_symbol': ['gene1', 'gene2'], + 'sample1': [100, 200], + 'sample2': [150, 250], + 'sample3': [100, 200], + 'sample4': [150, 250], + 'sample5': [100, 200], + 'sample6': [150, 250] + }) + mock_open.side_effect = [mock_meta, mock_count] * 5 + + + # Test with cell_line and drug as strings + df_count, df_meta = omics.panacea_tables(cell_line='cell1', drug='drug1', type='raw') + assert isinstance(df_count, pd.DataFrame) + assert isinstance(df_meta, pd.DataFrame) + assert df_count.shape == (2, 3) + assert df_meta.shape == (2, 4) + + # Test with cell_line and drug as lists + df_count, df_meta = omics.panacea_tables(cell_line=['cell1'], drug=['drug1'], type='raw') + assert isinstance(df_count, pd.DataFrame) + assert isinstance(df_meta, pd.DataFrame) + assert df_count.shape == (2, 3) + assert df_meta.shape == (2, 4) + + # Test with cell_line and drug both None + df_count, df_meta = omics.panacea_tables(type='raw') + assert isinstance(df_count, pd.DataFrame) + assert isinstance(df_meta, pd.DataFrame) + assert df_count.shape == (2, 7) + assert df_meta.shape == (6, 4) + + # Test with cell_line as None and drug as string + df_count, df_meta = omics.panacea_tables(cell_line=None, drug='drug1', type='raw') + assert isinstance(df_count, pd.DataFrame) + assert isinstance(df_meta, pd.DataFrame) + assert df_count.shape == (2, 4) + assert df_meta.shape == (3, 4) + + # Test with cell_line as string and drug as None + df_count, df_meta = omics.panacea_tables(cell_line='cell1', drug=None, type='raw') + assert isinstance(df_count, pd.DataFrame) + assert isinstance(df_meta, pd.DataFrame) + assert df_count.shape == (2, 5) + assert df_meta.shape == (4, 4) + + # Test with unknown type to trigger the ValueError + with pytest.raises(ValueError, match='Unknown data type: unknown_type'): + omics.panacea_tables(cell_line='cell1', drug='drug1', type='unknown_type') + + +@patch('pandas.read_csv') +@patch('networkcommons.data.omics._panacea._common._baseurl', return_value='http://example.com') +def test_panacea_tables_diffexp(mock_baseurl, mock_read_csv): + # Mock the data + mock_df = pd.DataFrame({ + 'gene': ['gene1', 'gene2'], + 'log2FoldChange': [1.5, -2.3], + 'pvalue': [0.01, 0.05] + }) + mock_read_csv.return_value = mock_df + + result_df = omics.panacea_tables(cell_line='cell1', drug='drug1', type='diffexp') + + assert isinstance(result_df, pd.DataFrame) + assert 'gene' in result_df.columns + assert 'log2FoldChange' in result_df.columns + assert 'pvalue' in result_df.columns + + +@patch('pandas.read_csv') +@patch('networkcommons.data.omics._panacea._common._baseurl', return_value='http://example.com') +def test_panacea_tables_tf_scores(mock_baseurl, mock_read_csv): + # Mock the data + mock_df = pd.DataFrame({ + 'TF': ['TF1', 'TF2'], + 'score': [2.5, -1.3], + 'pvalue': [0.02, 0.07] + }) + mock_read_csv.return_value = mock_df + + result_df = omics.panacea_tables(cell_line='cell1', drug='drug1', type='TF_scores') + + assert isinstance(result_df, pd.DataFrame) + assert 'TF' in result_df.columns + assert 'score' in result_df.columns + assert 'pvalue' in result_df.columns + + +def test_panacea_tables_value_error(): + with pytest.raises(ValueError, match='Please specify cell line and drug.'): + omics.panacea_tables(type='diffexp') + + +@patch('networkcommons.data.omics._panacea._common._open') +@patch('networkcommons.data.omics._panacea._common._baseurl', return_value='http://example.com') +def test_panacea_tables_raw(mock_baseurl, mock_open): + cell_line = 'CellLine1' + drug = 'Drug1' + data_type = 'raw' + + # Mock the DataFrames returned by _common._open + mock_meta_df = pd.DataFrame({'group': ['CellLine1_Drug1', 'CellLine2_Drug2'], 'sample_ID': ['ID1', 'ID2']}) + mock_count_df = pd.DataFrame({'gene_symbol': ['Gene1', 'Gene2'], 'ID1': [10, 20], 'ID2': [30, 40]}) + mock_open.side_effect = [mock_meta_df, mock_count_df] + + result_count_df, result_meta_df = omics.panacea_tables(cell_line=cell_line, drug=drug, type=data_type) + + assert isinstance(result_count_df, pd.DataFrame) + assert 'gene_symbol' in result_count_df.columns + assert 'ID1' in result_count_df.columns + assert isinstance(result_meta_df, pd.DataFrame) + assert 'group' in result_meta_df.columns + assert 'sample_ID' in result_meta_df.columns + mock_open.assert_called() + + +def test_panacea_tables_no_cell_line_drug(): + with pytest.raises(ValueError, match='Please specify cell line and drug.'): + omics.panacea_tables(type='diffexp') + + +@patch('networkcommons.data.omics._panacea._common._open') +@patch('networkcommons.data.omics._panacea._common._baseurl', return_value='http://example.com') +def test_panacea_tables_unknown_type(mock_baseurl, mock_open): + with pytest.raises(ValueError, match='Unknown data type: unknown.'): + omics.panacea_tables(cell_line='CellLine1', drug='Drug1', type='unknown') + + +# FILE: omics/_scperturb.py +import pytest +from unittest.mock import patch, MagicMock +import json + +from networkcommons.data.omics import _scperturb + +@pytest.fixture +def mock_metadata(): + return { + 'files': { + 'entries': { + 'dataset1.h5ad': {'links': {'content': 'https://example.com/dataset1.h5ad'}}, + 'dataset2.h5ad': {'links': {'content': 'https://example.com/dataset2.h5ad'}} + } + } + } + + +@pytest.fixture +def mock_ann_data(): + return MagicMock(spec=ad.AnnData) + + +@patch('networkcommons.data.omics._scperturb._common._open') +@patch('networkcommons.data.omics._scperturb.json.loads') +def test_scperturb_metadata(mock_json_loads, mock_open, mock_metadata): + mock_open.return_value = MagicMock() + mock_json_loads.return_value = mock_metadata + + metadata = _scperturb.scperturb_metadata() + assert metadata == mock_metadata + mock_open.assert_called_once_with('https://zenodo.org/record/10044268', ftype='html') + mock_json_loads.assert_called_once() + + +@patch('networkcommons.data.omics._scperturb.scperturb_metadata') +def test_scperturb_datasets(mock_scperturb_metadata, mock_metadata): + mock_scperturb_metadata.return_value = mock_metadata + + datasets = _scperturb.scperturb_datasets() + expected_datasets = { + 'dataset1.h5ad': 'https://example.com/dataset1.h5ad', + 'dataset2.h5ad': 'https://example.com/dataset2.h5ad' + } + assert datasets == expected_datasets + mock_scperturb_metadata.assert_called_once() + + +@patch('networkcommons.data.omics._scperturb.scperturb_datasets') +@patch('networkcommons.data.omics._scperturb._common._maybe_download') +@patch('anndata.read_h5ad') +def test_scperturb(mock_read_h5ad, mock_maybe_download, mock_scperturb_datasets, mock_ann_data): + mock_scperturb_datasets.return_value = { + 'dataset1.h5ad': 'https://example.com/dataset1.h5ad' + } + mock_maybe_download.return_value = 'path/to/dataset1.h5ad' + mock_read_h5ad.return_value = mock_ann_data + + result = _scperturb.scperturb('dataset1.h5ad') + assert result is mock_ann_data + mock_scperturb_datasets.assert_called_once() + mock_maybe_download.assert_called_once_with('https://example.com/dataset1.h5ad') + mock_read_h5ad.assert_called_once_with('path/to/dataset1.h5ad') @pytest.mark.slow -def test_scperturb_metadata(): +def test_scperturb_metadata_slow(): m = omics.scperturb_metadata() @@ -137,7 +620,7 @@ def test_scperturb_metadata(): @pytest.mark.slow -def test_scperturb_datasets(): +def test_scperturb_datasets_slow(): example_url = ( 'https://zenodo.org/api/records/10044268/files/' @@ -151,7 +634,7 @@ def test_scperturb_datasets(): @pytest.mark.slow -def test_scperturb(): +def test_scperturb_slow(): var_cols = ('ensembl_id', 'ncounts', 'ncells') adata = omics.scperturb('AdamsonWeissman2016_GSM2406675_10X001.h5ad') @@ -162,37 +645,201 @@ def test_scperturb(): assert adata.shape == (5768, 35635) -@pytest.mark.slow -def test_cptac_cohortsize(): +@patch('networkcommons.data.omics._cptac._conf.get') +@patch('os.path.exists', return_value=True) +@patch('pandas.read_pickle') +def test_cptac_cohortsize_cached(mock_read_pickle, mock_path_exists, mock_conf_get): + # Mock configuration and data + mock_conf_get.return_value = '/mock/path' + mock_df = pd.DataFrame({ + "Cancer_type": ["BRCA", "CCRCC", "COAD", "GBM", "HNSCC", "LSCC", "LUAD", "OV", "PDAC", "UCEC"], + "Tumor": [122, 103, 110, 99, 108, 108, 110, 83, 105, 95], + "Normal": [0, 80, 100, 0, 62, 99, 101, 20, 44, 18] + }) + mock_read_pickle.return_value = mock_df - expected_df = pd.DataFrame({ + # Run the function with the condition that the pickle file exists + result_df = omics.cptac_cohortsize() + + # Check that the result is as expected + mock_read_pickle.assert_called_once_with('/mock/path/cptac_cohort.pickle') + pd.testing.assert_frame_equal(result_df, mock_df) + + +@patch('networkcommons.data.omics._cptac._conf.get') +@patch('os.makedirs') # Patch os.makedirs to prevent FileNotFoundError +@patch('os.path.exists', return_value=False) +@patch('pandas.read_excel') +@patch('pandas.DataFrame.to_pickle') +def test_cptac_cohortsize_download(mock_to_pickle, mock_read_excel, mock_makedirs, mock_conf_get, mock_path_exists): + # Mock configuration and data + mock_conf_get.return_value = '/mock/path' + mock_df = pd.DataFrame({ "Cancer_type": ["BRCA", "CCRCC", "COAD", "GBM", "HNSCC", "LSCC", "LUAD", "OV", "PDAC", "UCEC"], "Tumor": [122, 103, 110, 99, 108, 108, 110, 83, 105, 95], "Normal": [0, 80, 100, 0, 62, 99, 101, 20, 44, 18] }) + mock_read_excel.return_value = mock_df + + # Run the function with the condition that the pickle file does not exist + result_df = omics.cptac_cohortsize(update=True) + + # Check that the result is as expected + mock_read_excel.assert_called_once() + mock_to_pickle.assert_called_once() + pd.testing.assert_frame_equal(result_df, mock_df) + + +@patch('networkcommons.data.omics._cptac._conf.get') +@patch('os.path.exists', return_value=True) +@patch('pandas.read_pickle') +def test_cptac_fileinfo_cached(mock_read_pickle, mock_path_exists, mock_conf_get): + # Mock configuration and data + mock_conf_get.return_value = '/mock/path' + mock_df = pd.DataFrame({ + "File name": ["file1.txt", "file2.txt"], + "Description": ["Description1", "Description2"] + }) + mock_read_pickle.return_value = mock_df + + # Run the function with the condition that the pickle file exists + result_df = omics.cptac_fileinfo() + + # Check that the result is as expected + mock_read_pickle.assert_called_once_with('/mock/path/cptac_info.pickle') + pd.testing.assert_frame_equal(result_df, mock_df) + + +@patch('networkcommons.data.omics._cptac._conf.get') +@patch('os.makedirs') # Patch os.makedirs to prevent FileNotFoundError +@patch('os.path.exists', return_value=False) +@patch('pandas.read_excel') +@patch('pandas.DataFrame.to_pickle') +def test_cptac_fileinfo_download(mock_to_pickle, mock_read_excel, mock_makedirs, mock_conf_get, mock_path_exists): + # Mock configuration and data + mock_conf_get.return_value = '/mock/path' + mock_df = pd.DataFrame({ + "File name": ["file1.txt", "file2.txt"], + "Description": ["Description1", "Description2"] + }) + mock_read_excel.return_value = mock_df - output_df = omics.cptac_cohortsize() + # Run the function with the condition that the pickle file does not exist + result_df = omics.cptac_fileinfo(update=True) - assert output_df.equals(expected_df) + # Check that the result is as expected + mock_read_excel.assert_called_once() + mock_to_pickle.assert_called_once() + pd.testing.assert_frame_equal(result_df, mock_df) -@pytest.mark.slow -def test_cptac_fileinfo(): +@patch('networkcommons.data.omics._cptac._common._ls') +@patch('networkcommons.data.omics._cptac._common._baseurl', return_value='http://example.com/') +def test_cptac_datatypes(mock_baseurl, mock_ls): + # Mock the return value of _ls to simulate the directory listing + mock_ls.return_value = [ + 'directory1', + 'directory2', + 'CPTAC_pancancer_data_freeze_cohort_size.xlsx', + 'CPTAC_pancancer_data_freeze_file_description.xlsx' + ] - fileinfo_df = omics.cptac_fileinfo() + expected_directories = ['directory1', 'directory2'] - assert isinstance(fileinfo_df, pd.DataFrame) - assert fileinfo_df.shape == (37, 2) - assert fileinfo_df.columns.tolist() == ['File name', 'Description'] + # Call the function + directories = omics.cptac_datatypes() + # Check if the returned directories match the expected directories + assert directories == expected_directories -@pytest.mark.slow -def test_cptac_table(): - df = omics.cptac_table('BRCA', 'meta') +@patch('networkcommons.data.omics._common._open') +def test_cptac_table(mock_open): + mock_df = pd.DataFrame({ + "sample_ID": ["sample1", "sample2"], + "value": [123, 456] + }) + mock_open.return_value = mock_df + + df = omics.cptac_table('proteomics', 'BRCA', 'file.tsv') assert isinstance(df, pd.DataFrame) - assert df.shape == (123, 201) + assert df.shape == (2, 2) + mock_open.assert_called_once_with( + _common._commons_url('CPTAC', data_type='proteomics', cancer_type='BRCA', fname='file.tsv'), + df={'sep': '\t'} + ) + + +def test_cptac_extend_dataframe(): + df = pd.DataFrame({ + "idx": ["sample1", "sample2", "sample3"], + "Tumor": ["Yes", "No", "Yes"], + "Normal": ["No", "Yes", "No"] + }) + + extended_df = omics.cptac_extend_dataframe(df) + + print(extended_df) + + expected_df = pd.DataFrame({ + "sample_ID": ["sample1_tumor", "sample3_tumor", "sample2_ctrl"] + }) + + pd.testing.assert_frame_equal(extended_df, expected_df) + + +@patch('networkcommons.data.omics._common._conf.get') +@patch('pandas.read_pickle') +@patch('os.path.exists', return_value=True) +def test_get_ensembl_mappings_cached(mock_path_exists, mock_read_pickle, mock_conf_get): + # Mock configuration and data + mock_conf_get.return_value = '/path/to/pickle/dir' + mock_df = pd.DataFrame({ + 'gene_symbol': ['BRCA2', 'BRCA1'], + 'ensembl_id': ['ENSG00000139618', 'ENSG00000012048'] + }) + mock_read_pickle.return_value = mock_df + + # Run the function with the condition that the pickle file exists + result_df = _common.get_ensembl_mappings() + + # Check that the result is as expected + mock_read_pickle.assert_called_once_with('/path/to/pickle/dir/ensembl_map.pickle') + + +@patch('networkcommons.data.omics._common._conf.get') +@patch('os.path.exists', return_value=False) +@patch('biomart.BiomartServer') +def test_get_ensembl_mappings_download(mock_biomart_server, mock_path_exists, mock_conf_get): + # Mock configuration and data + mock_conf_get.return_value = '/path/to/pickle/dir' + + # Mock the biomart server and dataset + mock_server_instance = MagicMock() + mock_biomart_server.return_value = mock_server_instance + mock_dataset = mock_server_instance.datasets['hsapiens_gene_ensembl'] + mock_response = MagicMock() + mock_dataset.search.return_value = mock_response + mock_response.raw.data.decode.return_value = ( + 'ENST00000361390\tBRCA2\tENSG00000139618\tENSP00000354687\n' + 'ENST00000361453\tBRCA2\tENSG00000139618\tENSP00000354687\n' + 'ENST00000361453\tBRCA1\tENSG00000012048\tENSP00000354688\n' + ) + + with patch('pandas.DataFrame.to_pickle') as mock_to_pickle: + result_df = _common.get_ensembl_mappings() + + expected_data = { + 'gene_symbol': ['BRCA2', 'BRCA2', 'BRCA1', 'BRCA2', 'BRCA1', 'BRCA2', 'BRCA1'], + 'ensembl_id': ['ENST00000361390', 'ENST00000361453', 'ENST00000361453', + 'ENSG00000139618', 'ENSG00000012048', 'ENSP00000354687', + 'ENSP00000354688'] + } + expected_df = pd.DataFrame(expected_data) + + pd.testing.assert_frame_equal(result_df.reset_index(drop=True), expected_df) + mock_to_pickle.assert_called_once_with('/path/to/pickle/dir/ensembl_map.pickle') def test_convert_ensembl_to_gene_symbol_max(): @@ -250,7 +897,7 @@ def test_convert_ensembl_to_gene_symbol_median(): dataframe = pd.DataFrame({ 'idx': ['ENSG000001.10', 'ENSG000002', 'ENSG000001.2'], 'value': [10, 20, 15] - }) + }).set_index('idx') equivalence_df = pd.DataFrame({ 'ensembl_id': ['ENSG000001', 'ENSG000002'], 'gene_symbol': ['GeneA', 'GeneB'] @@ -308,4 +955,66 @@ def test_get_ensembl_mappings(mock_biomart_server): } expected_df = pd.DataFrame(expected_data) - pd.testing.assert_frame_equal(result_df.reset_index(drop=True), expected_df) \ No newline at end of file + pd.testing.assert_frame_equal(result_df.reset_index(drop=True), expected_df) + + +# FILE: omics/_nci60.py + +@patch('networkcommons.data.omics._nci60._common._ls') +@patch('networkcommons.data.omics._nci60._common._baseurl', return_value='http://example.com') +@patch('pandas.read_pickle') +@patch('os.path.exists', return_value=False) +@patch('pandas.DataFrame.to_pickle') +def test_nci60_datasets(mock_to_pickle, mock_path_exists, mock_read_pickle, mock_baseurl, mock_ls): + # Mock the directory listing + mock_ls.return_value = ['cell_line1', 'cell_line2', 'cell_line3'] + + dsets = omics.nci60_datasets(update=True) + + expected_df = pd.DataFrame({ + 'cell_line': ['cell_line1', 'cell_line2', 'cell_line3'] + }) + pd.testing.assert_frame_equal(dsets, expected_df) + mock_to_pickle.assert_called_once() + mock_read_pickle.assert_not_called() + + +@patch('pandas.read_pickle') +@patch('os.path.exists', return_value=True) +def test_nci60_datasets_cached(mock_path_exists, mock_read_pickle): + mock_df = pd.DataFrame({ + 'cell_line': ['cell_line1', 'cell_line2', 'cell_line3'] + }) + mock_read_pickle.return_value = mock_df + + dsets = omics.nci60_datasets() + + pd.testing.assert_frame_equal(dsets, mock_df) + mock_read_pickle.assert_called_once() + + +def test_nci60_datatypes(): + dtypes = omics.nci60_datatypes() + + expected_df = pd.DataFrame({ + 'data_type': ['TF_scores', 'RNA', 'metabolomic'], + 'description': ['TF scores', 'RNA expression', 'metabolomic data'] + }) + + pd.testing.assert_frame_equal(dtypes, expected_df) + + +@patch('networkcommons.data.omics._nci60._common._open') +def test_nci60_table(mock_open): + cell_line = 'cell_line1' + data_type = 'RNA' + mock_df = pd.DataFrame({ + 'gene': ['Gene1', 'Gene2'], + 'expression': [100, 200] + }) + mock_open.return_value = mock_df + + result = omics.nci60_table(cell_line, data_type) + + pd.testing.assert_frame_equal(result, mock_df) + mock_open.assert_called_once() \ No newline at end of file diff --git a/tests/test_pk.py b/tests/test_pk.py new file mode 100644 index 0000000..f80ca5e --- /dev/null +++ b/tests/test_pk.py @@ -0,0 +1,171 @@ +import pandas as pd +from unittest.mock import patch, MagicMock +from networkcommons.data.network._moon import get_cosmos_pkn +from networkcommons.data.network._liana import get_lianaplus +from networkcommons.data.network._omnipath import get_omnipath, get_phosphositeplus +import os + + +def test_get_lianaplus(): + # Create a mock DataFrame to be returned by the mocked select_resource function + mock_data = pd.DataFrame({ + 'source': ['gene1', 'gene2', 'gene3'], + 'target': ['gene4', 'gene5', 'gene6'] + }) + + with patch('liana.resource.select_resource', return_value=mock_data) as mock_select_resource: + result = get_lianaplus('Consensus') + + # Check that the select_resource function was called with the correct argument + mock_select_resource.assert_called_once_with('Consensus') + + # Check the result DataFrame + expected_result = mock_data.copy() + expected_result.columns = ['source', 'target'] + expected_result['sign'] = 1 + + pd.testing.assert_frame_equal(result, expected_result) + + +def test_get_cosmos_pkn_file_exists(): + path = os.path.join('dummy_path', 'metapkn.pickle') + mock_df = pd.DataFrame({'source': ['a'], 'target': ['b'], 'sign': [1]}) + + with patch('networkcommons._conf.get', return_value='dummy_path'), \ + patch('os.path.exists', return_value=True), \ + patch('pandas.read_pickle', return_value=mock_df) as mock_read_pickle: + + result = get_cosmos_pkn(update=False) + + mock_read_pickle.assert_called_once_with(path) + pd.testing.assert_frame_equal(result, mock_df) + + +def test_get_cosmos_pkn_file_not_exists_or_update(): + path = os.path.join('dummy_path', 'metapkn.pickle') + mock_df = pd.DataFrame({'source': ['a'], 'target': ['b'], 'sign': [1]}) + + with patch('networkcommons._conf.get', return_value='dummy_path'), \ + patch('os.path.exists', return_value=False), \ + patch('networkcommons.data.omics._common._baseurl', return_value='http://dummy_url'), \ + patch('pandas.read_csv', return_value=mock_df) as mock_read_csv, \ + patch('pandas.DataFrame.to_pickle') as mock_to_pickle: + + result = get_cosmos_pkn(update=False) + + mock_read_csv.assert_called_once_with('http://dummy_url/prior_knowledge/meta_network.sif', sep='\t') + mock_to_pickle.assert_called_once_with(path) + pd.testing.assert_frame_equal(result, mock_df) + + +def test_get_cosmos_pkn_update(): + path = os.path.join('dummy_path', 'metapkn.pickle') + mock_df = pd.DataFrame({'source': ['a'], 'target': ['b'], 'sign': [1]}) + + with patch('networkcommons._conf.get', return_value='dummy_path'), \ + patch('os.path.exists', return_value=True), \ + patch('networkcommons.data.omics._common._baseurl', return_value='http://dummy_url'), \ + patch('pandas.read_csv', return_value=mock_df) as mock_read_csv, \ + patch('pandas.DataFrame.to_pickle') as mock_to_pickle: + + result = get_cosmos_pkn(update=True) + + mock_read_csv.assert_called_once_with('http://dummy_url/prior_knowledge/meta_network.sif', sep='\t') + mock_to_pickle.assert_called_once_with(path) + pd.testing.assert_frame_equal(result, mock_df) + + +def test_get_omnipath(): + mock_data = pd.DataFrame({ + 'source': ['P12345', 'P23456'], + 'target': ['P34567', 'P45678'], + 'source_genesymbol': ['GeneA', 'GeneB'], + 'target_genesymbol': ['GeneC', 'GeneD'], + 'consensus_direction': [True, True], + 'consensus_stimulation': [True, False], + 'consensus_inhibition': [False, True], + 'curation_effort': [3, 2] + }) + + with patch('omnipath.interactions.AllInteractions.get', return_value=mock_data): + result = get_omnipath(genesymbols=True, directed_signed=True) + + expected_result = pd.DataFrame({ + 'source': ['GeneA', 'GeneB'], + 'target': ['GeneC', 'GeneD'], + 'sign': [1, -1] + }) + + pd.testing.assert_frame_equal(result, expected_result) + + +def test_get_omnipath_no_filter(): + mock_data = pd.DataFrame({ + 'source': ['P12345', 'P23456'], + 'target': ['P34567', 'P45678'], + 'source_genesymbol': ['GeneA', 'GeneB'], + 'target_genesymbol': ['GeneC', 'GeneD'], + 'consensus_direction': [True, True], + 'consensus_stimulation': [True, False], + 'consensus_inhibition': [False, True], + 'curation_effort': [3, 2] + }) + + with patch('omnipath.interactions.AllInteractions.get', return_value=mock_data): + result = get_omnipath(genesymbols=True, directed_signed=False) + + expected_result = pd.DataFrame({ + 'source': ['GeneA', 'GeneB'], + 'target': ['GeneC', 'GeneD'], + 'sign': [1, -1] + }) + + pd.testing.assert_frame_equal(result, expected_result) + + +def test_get_phosphositeplus_file_exists(): + path = os.path.join('dummy_path', 'phosphositeplus.pickle') + mock_df = pd.DataFrame({'source': ['a'], 'target': ['b'], 'sign': [1]}) + + with patch('networkcommons._conf.get', return_value='dummy_path'), \ + patch('os.path.exists', return_value=True), \ + patch('pandas.read_pickle', return_value=mock_df) as mock_read_pickle: + + result = get_phosphositeplus(update=False) + + mock_read_pickle.assert_called_once_with(path) + pd.testing.assert_frame_equal(result, mock_df) + + +def test_get_phosphositeplus_file_not_exists_or_update(): + path = os.path.join('dummy_path', 'phosphositeplus.pickle') + mock_df = pd.DataFrame({'source': ['a'], 'target': ['b'], 'sign': [1]}) + + with patch('networkcommons._conf.get', return_value='dummy_path'), \ + patch('os.path.exists', return_value=False), \ + patch('networkcommons.data.omics._common._baseurl', return_value='http://dummy_url'), \ + patch('pandas.read_csv', return_value=mock_df) as mock_read_csv, \ + patch('pandas.DataFrame.to_pickle') as mock_to_pickle: + + result = get_phosphositeplus(update=False) + + mock_read_csv.assert_called_once_with('http://dummy_url/prior_knowledge/kinase-substrate.tsv', sep='\t') + mock_to_pickle.assert_called_once_with(path) + pd.testing.assert_frame_equal(result, mock_df) + + +def test_get_phosphositeplus_update(): + path = os.path.join('dummy_path', 'phosphositeplus.pickle') + mock_df = pd.DataFrame({'source': ['a'], 'target': ['b'], 'sign': [1]}) + + with patch('networkcommons._conf.get', return_value='dummy_path'), \ + patch('os.path.exists', return_value=True), \ + patch('networkcommons.data.omics._common._baseurl', return_value='http://dummy_url'), \ + patch('pandas.read_csv', return_value=mock_df) as mock_read_csv, \ + patch('pandas.DataFrame.to_pickle') as mock_to_pickle: + + result = get_phosphositeplus(update=True) + + mock_read_csv.assert_called_once_with('http://dummy_url/prior_knowledge/kinase-substrate.tsv', sep='\t') + mock_to_pickle.assert_called_once_with(path) + pd.testing.assert_frame_equal(result, mock_df) \ No newline at end of file diff --git a/tests/test_utils.py b/tests/test_utils.py index 23be8e7..1b53667 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,30 +1,205 @@ -import networkcommons._utils as utils import pandas as pd +import networkx as nx import numpy as np +import corneto as cn +from unittest.mock import patch +import pytest +import networkcommons._utils as utils +import pygraphviz as pgv + + +def test_to_cornetograph(): + nx_graph = nx.DiGraph() + nx_graph.add_edge('a', 'b', sign=1) + + corneto_graph = utils.to_cornetograph(nx_graph) + + assert isinstance(corneto_graph, cn._graph.Graph) + + for data in corneto_graph.get_attr_edges(): + assert 'interaction' in data.keys() + assert 'sign' not in data.keys() + + corneto_graph = cn.Graph.from_sif_tuples([('node1', 1, 'node2')]) + result = utils.to_cornetograph(corneto_graph) + assert isinstance(result, cn._graph.Graph) + + +def test_to_cornetograph_when_cornetograph(): + corneto_graph = cn.Graph.from_sif_tuples([('node1', 1, 'node2')]) + + result = utils.to_cornetograph(corneto_graph) + assert isinstance(result, cn._graph.Graph) + + +def test_to_cornetograph_when_not_supported(): + multi_graph = nx.MultiDiGraph() + with pytest.raises(NotImplementedError, match="Only nx.DiGraph graphs and corneto graphs are supported."): + utils.to_cornetograph(multi_graph) + + undir_graph = nx.Graph() + with pytest.raises(NotImplementedError, match="Only nx.DiGraph graphs and corneto graphs are supported."): + utils.to_cornetograph(undir_graph) + + graphviz_grpah = pgv.AGraph() + with pytest.raises(NotImplementedError, match="Only nx.DiGraph graphs and corneto graphs are supported."): + utils.to_cornetograph(graphviz_grpah) + + +def test_to_networkx(): + corneto_graph = cn.Graph.from_sif_tuples([('node1', 1, 'node2')]) + + # Convert to networkx graph using the function + networkx_graph = utils.to_networkx(corneto_graph) + + # Expected networkx graph + expected_graph = nx.DiGraph() + expected_graph.add_node('node1', attr1='value1') + expected_graph.add_node('node2', attr1='value2') + expected_graph.add_edge('node1', 'node2', sign=1) + + assert isinstance(networkx_graph, nx.DiGraph) + + assert nx.is_isomorphic(networkx_graph, expected_graph) + for u, v, data in networkx_graph.edges(data=True): + assert data['sign'] == expected_graph.get_edge_data(u, v)['sign'] + assert 'interaction' not in data.keys() + + nx_graph = nx.DiGraph() + nx_graph.add_edge('a', 'b', sign=1) + + # Convert to networkx graph using the function + networkx_graph = utils.to_networkx(nx_graph) + + # Expected networkx graph + expected_graph = nx.DiGraph() + expected_graph.add_edge('a', 'b', sign=1) + + assert nx.is_isomorphic(networkx_graph, expected_graph) + for u, v, data in networkx_graph.edges(data=True): + assert data['sign'] == expected_graph.get_edge_data(u, v)['sign'] + + +def test_to_networkx_when_networkx_graph(): + nx_graph = nx.DiGraph() + nx_graph.add_edge('a', 'b', sign=1) + + result = utils.to_networkx(nx_graph) + assert isinstance(result, nx.DiGraph) + assert nx.is_isomorphic(result, nx_graph) + for u, v, data in nx_graph.edges(data=True): + assert data['sign'] == result.get_edge_data(u, v)['sign'] + assert 'interaction' not in data.keys() + + +def test_to_networkx_when_not_supported(): + multi_graph = nx.MultiDiGraph() + with pytest.raises(NotImplementedError, match="Only nx.DiGraph graphs and corneto graphs are supported."): + utils.to_networkx(multi_graph) + + undir_graph = nx.Graph() + with pytest.raises(NotImplementedError, match="Only nx.DiGraph graphs and corneto graphs are supported."): + utils.to_networkx(undir_graph) + graphviz_grpah = pgv.AGraph() + with pytest.raises(NotImplementedError, match="Only nx.DiGraph graphs and corneto graphs are supported."): + utils.to_networkx(graphviz_grpah) -def test_fill_and_drop(): + +def test_read_network_from_file(): + with patch('pandas.read_csv') as mock_read_csv, patch('networkcommons._utils.network_from_df') as mock_network_from_df: + mock_read_csv.return_value = pd.DataFrame({'source': ['a'], 'target': ['b']}) + utils.read_network_from_file('dummy_path') + mock_network_from_df.assert_called_once() + + +def test_network_from_df(): + df = pd.DataFrame({'source': ['a'], 'target': ['b'], 'sign': [1]}) + result = utils.network_from_df(df) + assert isinstance(result, nx.DiGraph) + assert list(result.edges(data=True)) == [('a', 'b', {'sign': 1})] + + +def test_network_from_df_no_attrs(): + df = pd.DataFrame({'source': ['a'], 'target': ['b']}) + result = utils.network_from_df(df) + assert isinstance(result, nx.DiGraph) + assert list(result.edges(data=True)) == [('a', 'b', {})] + + +def test_network_from_df_negative_weights(): + df = pd.DataFrame({'source': ['a'], 'target': ['b'], 'weight':-3}) + result = utils.network_from_df(df) + assert isinstance(result, nx.DiGraph) + assert list(result.edges(data=True)) == [('a', 'b', {'weight': 3, 'sign': -1})] + + +def test_get_subnetwork(): + G = nx.path_graph(4) + paths = [[0, 1, 2], [2, 3]] + subnetwork = utils.get_subnetwork(G, paths) + assert list(subnetwork.edges) == [(0, 1), (1, 2), (2, 3)] + + +def test_decoupler_formatter(): + df = pd.DataFrame({'ID': ['Gene1', 'Gene2', 'Gene3'], 'stat': [3.5, 4, 3]}).set_index('ID') + result = utils.decoupler_formatter(df, ['stat']) + expected = df.T + pd.testing.assert_frame_equal(result, expected) + + +def test_decoupler_formatter_string(): + df = pd.DataFrame({'ID': ['Gene1', 'Gene2', 'Gene3'], 'stat': [3.5, 4, 3]}).set_index('ID') + result = utils.decoupler_formatter(df, 'stat') + expected = df.T + pd.testing.assert_frame_equal(result, expected) + + +def test_targetlayer_formatter(): + df = pd.DataFrame({'TF': ['A', 'B', 'C', 'D'], 'sign': [1.5, -2, 0, 3]}).set_index('TF') + result = utils.targetlayer_formatter(df, n_elements=2) + expected = {'D': 1, 'B': -1} + assert result == expected + + +def test_subset_df_with_nodes(): + G = nx.Graph() + G.add_nodes_from([1, 2, 3]) + df = pd.DataFrame({'value': [10, 20, 30]}, index=[1, 2, 4]) + result = utils.subset_df_with_nodes(G, df) + expected = pd.DataFrame({'value': [10, 20]}, index=[1, 2]) + pd.testing.assert_frame_equal(result, expected) + + +def test_handle_missing_values_fill(): df = pd.DataFrame({'A': [1, 2, np.nan], 'B': [3, 2, np.nan], 'C': [np.nan, 7, 8]}) - result = utils.handle_missing_values(df, 0.5) + result = utils.handle_missing_values(df, 0.5, fill=True) expected = pd.DataFrame({'index': [0, 1], 'A': [1.0, 2.0], 'B': [3.0, 2.0], 'C': [2.0, 7.0]}).astype({'index': 'int64'}) pd.testing.assert_frame_equal(result, expected) -def test_all_rows_dropped(): +def test_handle_missing_values_fill_and_drop(): + df = pd.DataFrame({'A': [1, np.nan, np.nan], 'B': [np.nan, 2, np.nan], 'C': [np.nan, 7, np.nan]}) + result = utils.handle_missing_values(df, 0.5, fill=True) + expected = pd.DataFrame({'index': [1], 'A': [4.5], 'B': [2.0], 'C': [7.0]}).astype({'index': 'int64'}) + pd.testing.assert_frame_equal(result, expected) + + +def test_handle_missing_values_drop(): df = pd.DataFrame({'A': [1, np.nan, np.nan], 'B': [np.nan, np.nan, np.nan], 'C': [np.nan, np.nan, 8]}) - result = utils.handle_missing_values(df, 0.1) + result = utils.handle_missing_values(df, 0.1, fill=False) expected = pd.DataFrame({'index': [], 'A': [], 'B': [], 'C': []}).astype({'index': 'int64'}) pd.testing.assert_frame_equal(result, expected) -def test_non_numeric_column(): +def test_handle_missing_values_non_numeric_column(): df = pd.DataFrame({'id': ['a', 'b', 'c'], 'A': [1, 2, np.nan], 'B': [3, 2, np.nan], 'C': [np.nan, 7, 8]}) result = utils.handle_missing_values(df, 0.5) expected = pd.DataFrame({'id': ['a', 'b'], 'A': [1.0, 2.0], 'B': [3.0, 2.0], 'C': [2.0, 7.0]}) pd.testing.assert_frame_equal(result, expected) -def test_more_than_one_non_numeric_column(): +def test_handle_missing_values_more_than_one_non_numeric_column(): df = pd.DataFrame({'id1': ['a', 'b', 'c'], 'id2': ['x', 'y', 'z'], 'A': [1, 2, np.nan], 'B': [3, 2, np.nan]}) try: utils.handle_missing_values(df, 0.5) @@ -32,9 +207,16 @@ def test_more_than_one_non_numeric_column(): assert str(e) == "More than one non-numeric column found: Index(['id1', 'id2'], dtype='object')" -def test_no_missing_values(): +def test_handle_missing_values_no_missing_values(): df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}) result = utils.handle_missing_values(df, 0.5) expected = df.reset_index().rename(columns={'index': 'index'}) expected = expected.astype({'index': 'int64'}) pd.testing.assert_frame_equal(result, expected) + + +def test_handle_missing_values_with_inf(): + df = pd.DataFrame({'A': [1, 2, -np.inf], 'B': [3, 2, np.nan], 'C': [np.nan, 7, 8]}) + result = utils.handle_missing_values(df, 0.5) + expected = pd.DataFrame({'index': [0, 1], 'A': [1.0, 2.0], 'B': [3.0, 2.0], 'C': [2.0, 7.0]}).astype({'index': 'int64'}) + pd.testing.assert_frame_equal(result, expected) \ No newline at end of file