diff --git a/.DS_Store b/.DS_Store index 8da1960..8efee36 100644 Binary files a/.DS_Store and b/.DS_Store differ diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index c2dd833..6cead97 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -1,9 +1,9 @@ -name: Python package +name: Run Tests on: push: branches: - - main + - '*' pull_request: branches: - main @@ -13,23 +13,24 @@ jobs: runs-on: ubuntu-latest steps: - - name: Check out the code + # Checkout the repository + - name: Check out repository uses: actions/checkout@v3 - - name: Set up Python + # Set up Python version + - name: Set up Python 3.12 uses: actions/setup-python@v4 with: - python-version: '3.9' # You can change this to your desired Python version - - - name: Install Poetry - run: | - curl -sSL https://install.python-poetry.org | python3 - - echo "$HOME/.local/bin" >> $GITHUB_PATH + python-version: "3.12" + # Install dependencies using requirements.txt - name: Install dependencies run: | - poetry install + python -m pip install --upgrade pip + pip install -r requirements.txt - - name: Run tests + # Run tests + - name: Run tests with pytest run: | - poetry run pytest # Adjust this command based on your test framework + export PYTHONPATH=$(pwd) + pytest test/ diff --git a/.gitignore b/.gitignore index ce294da..f94221f 100644 --- a/.gitignore +++ b/.gitignore @@ -8,5 +8,5 @@ htmlcov/ env.yaml requirements.txt dist/ -.DS_Store -walkthroughs/workflow-Copy1.ipynb +*.DS_Store +myvenv/ diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index fb74ece..960374e 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -19,12 +19,15 @@ All types of contributions are encouraged and valued. See the [Table of Contents - [I Want To Contribute](#i-want-to-contribute) - [Reporting Bugs](#reporting-bugs) - [Suggesting Enhancements](#suggesting-enhancements) - - [Your First Code Contribution](#your-first-code-contribution) - - [Improving The Documentation](#improving-the-documentation) -- [Styleguides](#styleguides) +- [Styleguides](#style-guides) + - [Documentation](#documentation) + - [Dev Environments](#dev-environments) +- [Code Quality](#code-quality) + - [Formatting](#formatting) + - [Linting](#linting) + - [Documentation Style Guide](#documentation-style-guide) - [Commit Messages](#commit-messages) -- [Join The Project Team](#join-the-project-team) - +- [Attribution](#attribution) ## Code of Conduct @@ -132,7 +135,102 @@ Enhancement suggestions are tracked as [GitHub issues](https://github.com/fanzha - **Explain why this enhancement would be useful** to most pyCellPhenoX users. You may also want to point out the other projects that solved it better and which could serve as inspiration. +## Your first code contribution + +We welcome contributions! Follow these steps to contribute: + +### 1. Fork, Clone, and Branch +- Fork the repository and clone it to your local machine. + +```bash +git clone https://github.com/fanzhanglab/pyCellPhenoX.git +cd pyCellPhenoX +``` + +Please branch from the `main` branch given we have set up branch protections. +``` bash +git checkout -b your-branch-name +``` + +### 2. Make Your Changes +- Make sure your code follows the project standards. +- Format your Python code with Black: + +``` bash +black your_file.py +``` + +### 3. Commit and Push +Commit your changes with a meaningful message: + +```bash +git commit -m "Description of your changes" +``` + +Push your changes: + +``` bash +git push origin your-branch-name +``` +### 4. Submit a Pull Request +Submit a pull request and explain the changes you've made. + + +## Style Guides + +### Documentation + +We use [sphinx](https://www.sphinx-doc.org/en/master/index.html) for autodocumentation of docstrings, using the [napoleon extenstion](https://www.sphinx-doc.org/en/master/usage/extensions/napoleon.html) to parse [NumPy style docstrings](https://numpydoc.readthedocs.io/en/latest/format.html), implemented with a [furo](https://pradyunsg.me/furo/) theme. +We host our documentation on [readthedocs.org](https://readthedocs.org/) at [https://pyCellPhenoX.readthedocs.io/en/](https://pyCellPhenoX.readthedocs.io/en/). + +To build and test changes to the docs locally, run the following command: + +```bash +sphinx-build -b html docs build +``` + +See [`docs/conf.py`](../conf.py) for full documentation configuration. + +### Dev environments + +#### Local devcontainer + +Instructions for setting up a local development environment using VSCode DevContainers: + +1. Install [VSCode](https://code.visualstudio.com/download) +2. Install the [Remote - Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) extension +3. Open the repository in VSCode +4. Click on the green "Reopen in Container" button in the lower left corner of the window +5. Wait for the container to build and install the required dependencies + +## Code Quality + +Please follow the below quality guides to the best of your abilities. +If you have configured your [dev environment](#dev-environments) as described above, the formatting and linting rules will also be enforced automatically using the installed [pre-commit](https://pre-commit.com/) hooks. + +### Formatting + +We use [black](https://black.readthedocs.io/en/stable/) for formatting Python code, and [prettier](https://prettier.io/) for formatting markdown, json and yaml files. +We include `black` in the poetry dev dependencies so it can be run manually using `black format` +Prettier (which is not python-based) is not included in the poetry dev dependencies, but can be installed and run manually. +Alternately, both `black format` and `prettier` will be run automatically at commit time with the pre-commit hooks installed. + +### Linting + +For python code linting, we also use [black](https://black.readthedocs.io/en/stable/), which can perform same linting checks as Flake8. +You can use the command `black --check your_file.py` or `black path/to/your/directory` to check for linting errors. +We also include some commented-out rules in that section that we are working towards enabling in the future. +All linting checks will also be run automatically at commit time with the pre-commit hooks as described above. + +### Documentation style guide + +We use the [numpy documentation style guide](https://numpydoc.readthedocs.io/en/latest/format.html). +When writing markdown documentation, please also ensure that each sentence is on a new line. + +### Commit messages +pyCellPhenoX uses [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) standard for commit messages to aid in automatic changelog generation. +We prepare commit messages that follow this standard using [commitizen](https://commitizen-tools.github.io/commitizen/), which comes with the poetry dev dependencies. ## Attribution This guide is based on the **contributing-gen**. [Make your own](https://github.com/bttger/contributing-gen)! diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..d0c3cbf --- /dev/null +++ b/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = source +BUILDDIR = build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/README.md b/README.md index 2d77771..7b575e7 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,4 @@ +# pyCellPhenoX

@@ -38,7 +39,7 @@ conda install -c conda-forge pyCellPhenoX git clone git@github.com:fanzhanglab/pyCellPhenoX.git ``` -### Dependencies/ Requirements +### Dependencies / Requirements When using pyCellPhenoX please ensure you are using the following dependency versions or requirements ``` python python = "^3.9" @@ -51,60 +52,6 @@ scikit-learn = "^1.5.2" matplotlib = "^3.9.2" statsmodels = "^0.14.3" ``` -To check if you have the right depenencies please run the following: -#### Check Python Version -``` bash -python --version -``` - -#### Check individual package versions -``` bash -pip show {package} | grep Version -``` -> Replace {package} with the name of the package you want to check (e.g., pandas, numpy, etc.). This will display the installed version of the package. - -### Virtual Environment - -If any of the versions are not compatible with your working environment, please set up a virtual environment using one of the following methods: **conda/mamba**, **pip**, or **poetry**. - -#### Conda and Mamba - -To create a virtual environment using **conda** or **mamba**, follow these steps: - -1. **Create the environment:** - ```bash - conda create --name {name_the_environment} - ``` -2. **Activate the environment:** - ```bash - conda activate {name_the_environment} - ``` -3. **Install the requirements.txt:** - ```bash - conda install -f requirements.txt - ``` - -#### PIP -To create a virtual environment using **PIP** follow these steps: - -1. **Create the environment:** - ```bash - python -m venv {name_the_environment} - ``` -2. **Activate the environment:** -- on Windows - ```bash - {name_the_environment}\Scripts\activate - ``` -- on macOS - ```bash - source {name_the_environment}\bin\activate - ``` -3. **Install the requirements.txt:** - ```bash - pip install -r requirements.txt - ``` - ## Tutorials Please see the [Command-line Reference] for details. Additonally, please see [Walkthroughs] on the documentation page. @@ -125,16 +72,16 @@ Additional major functions associated with pyCellPhenoX are: Each function has uniqure arguments, see our [documentation] for more information ## Usage -- TODO +For more information please see [Walkthrough](walkthroughs/workflow.ipynb) or [Workflow Documentation] ## License Distributed under the terms of the [MIT license][license], _pyCellPhenoX_ is free and open source software. -## Code of Conduct +### Code of Conduct For more information please see [Code of Conduct](CODE_OF_CONDUCT.md) or [Code of Conduct Documentation] -## Contributing +### Contributing For more information please see [Contributing](CONTRIBUTING.md) or [Contributing Documentation] ## Issues @@ -167,8 +114,8 @@ or ``` ## Contact -Please contact [fanzhanglab@gmail.com](fanzhanglab@gmail.com) for -further questions or protential collaborative opportunities! +Please contact [fanzhanglab@gmail.com](mailto:fanzhanglab@gmail.com) for +further questions or potential collaborative opportunities! @@ -182,3 +129,4 @@ further questions or protential collaborative opportunities! [documentation]: https://pyCellPhenoXreadthedocs.io/ [Code of Conduct Documentation]: https://pyCellPhenoXreadthedocs.io/code_of_conduct [Contributing Documentation]: https://pyCellPhenoXreadthedocs.io/contributing +[Workflow Documentation]: https://pyCellPhenoXreadthedocs.io/walkthroughs/workflows \ No newline at end of file diff --git a/build/.buildinfo b/build/.buildinfo new file mode 100644 index 0000000..460e5a1 --- /dev/null +++ b/build/.buildinfo @@ -0,0 +1,4 @@ +# Sphinx build info version 1 +# This file records the configuration used when building these files. When it is not found, a full rebuild will be done. +config: 752896d6acf2089b607d9cda8b02be6b +tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/build/.buildinfo.bak b/build/.buildinfo.bak new file mode 100644 index 0000000..3a09931 --- /dev/null +++ b/build/.buildinfo.bak @@ -0,0 +1,4 @@ +# Sphinx build info version 1 +# This file records the configuration used when building these files. When it is not found, a full rebuild will be done. +config: 15f57f3ca10b6230b4abc06d59abc2dc +tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/build/.doctrees/README.doctree b/build/.doctrees/README.doctree new file mode 100644 index 0000000..bb345ac Binary files /dev/null and b/build/.doctrees/README.doctree differ diff --git a/build/.doctrees/api_reference.doctree b/build/.doctrees/api_reference.doctree new file mode 100644 index 0000000..d48e6aa Binary files /dev/null and b/build/.doctrees/api_reference.doctree differ diff --git a/build/.doctrees/changelog.doctree b/build/.doctrees/changelog.doctree new file mode 100644 index 0000000..df54c8c Binary files /dev/null and b/build/.doctrees/changelog.doctree differ diff --git a/build/.doctrees/citation.doctree b/build/.doctrees/citation.doctree new file mode 100644 index 0000000..48bca2b Binary files /dev/null and b/build/.doctrees/citation.doctree differ diff --git a/build/.doctrees/code_of_conduct.doctree b/build/.doctrees/code_of_conduct.doctree new file mode 100644 index 0000000..a2214ce Binary files /dev/null and b/build/.doctrees/code_of_conduct.doctree differ diff --git a/build/.doctrees/contributing.doctree b/build/.doctrees/contributing.doctree new file mode 100644 index 0000000..66bc1b1 Binary files /dev/null and b/build/.doctrees/contributing.doctree differ diff --git a/build/.doctrees/environment.pickle b/build/.doctrees/environment.pickle new file mode 100644 index 0000000..13c4eec Binary files /dev/null and b/build/.doctrees/environment.pickle differ diff --git a/build/.doctrees/index.doctree b/build/.doctrees/index.doctree new file mode 100644 index 0000000..2c6e12e Binary files /dev/null and b/build/.doctrees/index.doctree differ diff --git a/build/.doctrees/installation.doctree b/build/.doctrees/installation.doctree new file mode 100644 index 0000000..6de724f Binary files /dev/null and b/build/.doctrees/installation.doctree differ diff --git a/build/.doctrees/issues.doctree b/build/.doctrees/issues.doctree new file mode 100644 index 0000000..a5fef43 Binary files /dev/null and b/build/.doctrees/issues.doctree differ diff --git a/build/.doctrees/license.doctree b/build/.doctrees/license.doctree new file mode 100644 index 0000000..d142027 Binary files /dev/null and b/build/.doctrees/license.doctree differ diff --git a/build/.doctrees/modules.doctree b/build/.doctrees/modules.doctree new file mode 100644 index 0000000..a690f34 Binary files /dev/null and b/build/.doctrees/modules.doctree differ diff --git a/docs/walkthroughs/single_cell_usage.ipynb b/build/.doctrees/nbsphinx/walkthroughs/single_cell_usage.ipynb similarity index 100% rename from docs/walkthroughs/single_cell_usage.ipynb rename to build/.doctrees/nbsphinx/walkthroughs/single_cell_usage.ipynb diff --git a/build/.doctrees/nbsphinx/walkthroughs/workflow.ipynb b/build/.doctrees/nbsphinx/walkthroughs/workflow.ipynb new file mode 100644 index 0000000..cf835d3 --- /dev/null +++ b/build/.doctrees/nbsphinx/walkthroughs/workflow.ipynb @@ -0,0 +1,932 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Importing Dependencies " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/zhanglab/Documents/Python Projects/pyCellPhenoX/pycpx/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import pyCellPhenoX\n", + "\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1: Import Data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# paths to expression data and meta data files\n", + "expression_file = \"./../input/uc_fibroblast_exp.csv\"\n", + "meta_file = \"./../input/uc_fibroblast_meta.csv\"\n", + "output_path = \"./../output/\"\n", + "# read in data\n", + "expression_mat = pd.read_csv(expression_file, index_col=0)\n", + "meta = pd.read_csv(meta_file, index_col=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ADAMDEC1ACTA2TAGLNCCL11CCL13APOECXCL14CFDCCL8CCL2...CCDC23MEIS1AP001258.4FBXO42ASUNELP6CCDC77ELK3INO80EFHOD3
cell
N7.LPA.ATGTTCACATCGAC4.5913050.0000000.0000000.0000000.04.4023835.3820542.6198340.03.668685...0.00.00.00.00.00.00.00.0000001.6571770.0
N7.LPA.CATTAGCTGAGACG4.9041130.0000000.0000004.6945470.04.5706025.3831114.7511970.03.820224...0.00.00.00.00.00.00.01.9978910.0000000.0
N7.LPA.AAGGCTTGTGTAGC4.6003802.2203090.0000000.0000000.03.2437854.6003804.4200660.02.220309...0.00.00.00.00.00.00.00.0000000.0000000.0
N7.LPA.TATCAAGATGTGAC5.9000790.0000001.7453903.2043980.03.9704703.9704704.1346180.06.055687...0.00.00.00.00.00.00.00.0000000.0000000.0
N7.LPA.GAGTGGGAATGTGC5.4723131.7152181.7152185.2597390.03.6233564.8568684.2394300.03.169241...0.00.00.00.00.00.00.00.0000000.0000000.0
\n", + "

5 rows × 5494 columns

\n", + "
" + ], + "text/plain": [ + " ADAMDEC1 ACTA2 TAGLN CCL11 CCL13 \\\n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC 4.591305 0.000000 0.000000 0.000000 0.0 \n", + "N7.LPA.CATTAGCTGAGACG 4.904113 0.000000 0.000000 4.694547 0.0 \n", + "N7.LPA.AAGGCTTGTGTAGC 4.600380 2.220309 0.000000 0.000000 0.0 \n", + "N7.LPA.TATCAAGATGTGAC 5.900079 0.000000 1.745390 3.204398 0.0 \n", + "N7.LPA.GAGTGGGAATGTGC 5.472313 1.715218 1.715218 5.259739 0.0 \n", + "\n", + " APOE CXCL14 CFD CCL8 CCL2 ... \\\n", + "cell ... \n", + "N7.LPA.ATGTTCACATCGAC 4.402383 5.382054 2.619834 0.0 3.668685 ... \n", + "N7.LPA.CATTAGCTGAGACG 4.570602 5.383111 4.751197 0.0 3.820224 ... \n", + "N7.LPA.AAGGCTTGTGTAGC 3.243785 4.600380 4.420066 0.0 2.220309 ... \n", + "N7.LPA.TATCAAGATGTGAC 3.970470 3.970470 4.134618 0.0 6.055687 ... \n", + "N7.LPA.GAGTGGGAATGTGC 3.623356 4.856868 4.239430 0.0 3.169241 ... \n", + "\n", + " CCDC23 MEIS1 AP001258.4 FBXO42 ASUN ELP6 CCDC77 \\\n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "N7.LPA.CATTAGCTGAGACG 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "N7.LPA.AAGGCTTGTGTAGC 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "N7.LPA.TATCAAGATGTGAC 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "N7.LPA.GAGTGGGAATGTGC 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "\n", + " ELK3 INO80E FHOD3 \n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC 0.000000 1.657177 0.0 \n", + "N7.LPA.CATTAGCTGAGACG 1.997891 0.000000 0.0 \n", + "N7.LPA.AAGGCTTGTGTAGC 0.000000 0.000000 0.0 \n", + "N7.LPA.TATCAAGATGTGAC 0.000000 0.000000 0.0 \n", + "N7.LPA.GAGTGGGAATGTGC 0.000000 0.000000 0.0 \n", + "\n", + "[5 rows x 5494 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "expression_mat.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cell.1samplediseasecell_typeclusternGenenUMIpercent_mitofibroblast_clusters
cell
N7.LPA.ATGTTCACATCGACN7.LPA.ATGTTCACATCGACN7Non-inflamedLPWNT2B+ Fos-lo 1969.02357.00.031409WNT2B
N7.LPA.CATTAGCTGAGACGN7.LPA.CATTAGCTGAGACGN7Non-inflamedLPWNT2B+ Fos-hi681.01569.00.044614WNT2B
N7.LPA.AAGGCTTGTGTAGCN7.LPA.AAGGCTTGTGTAGCN7Non-inflamedLPWNT2B+ Fos-lo 2615.01218.00.013957WNT2B
N7.LPA.TATCAAGATGTGACN7.LPA.TATCAAGATGTGACN7Non-inflamedLPWNT2B+ Fos-hi841.02115.00.021749WNT2B
N7.LPA.GAGTGGGAATGTGCN7.LPA.GAGTGGGAATGTGCN7Non-inflamedLPWNT2B+ Fos-lo 1923.02194.00.019599WNT2B
\n", + "
" + ], + "text/plain": [ + " cell.1 sample disease cell_type \\\n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC N7.LPA.ATGTTCACATCGAC N7 Non-inflamed LP \n", + "N7.LPA.CATTAGCTGAGACG N7.LPA.CATTAGCTGAGACG N7 Non-inflamed LP \n", + "N7.LPA.AAGGCTTGTGTAGC N7.LPA.AAGGCTTGTGTAGC N7 Non-inflamed LP \n", + "N7.LPA.TATCAAGATGTGAC N7.LPA.TATCAAGATGTGAC N7 Non-inflamed LP \n", + "N7.LPA.GAGTGGGAATGTGC N7.LPA.GAGTGGGAATGTGC N7 Non-inflamed LP \n", + "\n", + " cluster nGene nUMI percent_mito \\\n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC WNT2B+ Fos-lo 1 969.0 2357.0 0.031409 \n", + "N7.LPA.CATTAGCTGAGACG WNT2B+ Fos-hi 681.0 1569.0 0.044614 \n", + "N7.LPA.AAGGCTTGTGTAGC WNT2B+ Fos-lo 2 615.0 1218.0 0.013957 \n", + "N7.LPA.TATCAAGATGTGAC WNT2B+ Fos-hi 841.0 2115.0 0.021749 \n", + "N7.LPA.GAGTGGGAATGTGC WNT2B+ Fos-lo 1 923.0 2194.0 0.019599 \n", + "\n", + " fibroblast_clusters \n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC WNT2B \n", + "N7.LPA.CATTAGCTGAGACG WNT2B \n", + "N7.LPA.AAGGCTTGTGTAGC WNT2B \n", + "N7.LPA.TATCAAGATGTGAC WNT2B \n", + "N7.LPA.GAGTGGGAATGTGC WNT2B " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meta.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 2: Preprocess Data\n", + "generate latent dimensions configure input for CellPhenoX (include covariates and identify target column)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "## we actually need both the neighborhood abundance matrix (for CellPhenoX) & expression data (for the marker discovery later)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/zhanglab_mac2/Library/CloudStorage/OneDrive-TheUniversityofColoradoDenver/Zhang_Lab/Research/shap/.conda/lib/python3.11/site-packages/sklearn/decomposition/_nmf.py:1710: ConvergenceWarning: Maximum number of iterations 200 reached. Increase it to improve convergence.\n" + ] + } + ], + "source": [ + "# get the latent dimensions using NMF\n", + "latent_features, _ = nonnegativeMatrixFactorization(expression_mat, numberOfComponents=4, min_k=3, max_k=5) # the \"_\"\" is the nmf model components which we don't need here" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# alternatively, use PCA\n", + "# proportion_var_explained = 0.9\n", + "# latent_features = principalComponentAnalysis(expression_mat, var=proportion_var_explained)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0123
cell
N7.LPA.ATGTTCACATCGAC0.2853340.1205890.4589740.205040
N7.LPA.CATTAGCTGAGACG0.2391240.0000000.5874350.094555
N7.LPA.AAGGCTTGTGTAGC0.2552120.0000000.4629120.226226
N7.LPA.TATCAAGATGTGAC0.3409510.0000000.3475800.300781
N7.LPA.GAGTGGGAATGTGC0.2311400.1757430.4207130.348904
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3\n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC 0.285334 0.120589 0.458974 0.205040\n", + "N7.LPA.CATTAGCTGAGACG 0.239124 0.000000 0.587435 0.094555\n", + "N7.LPA.AAGGCTTGTGTAGC 0.255212 0.000000 0.462912 0.226226\n", + "N7.LPA.TATCAAGATGTGAC 0.340951 0.000000 0.347580 0.300781\n", + "N7.LPA.GAGTGGGAATGTGC 0.231140 0.175743 0.420713 0.348904" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# then, set up the input data for CellPhenoX\n", + "X,y = preprocessing(latent_features, meta, sub_samp=False, subset_percentage=0.25 , target=\"disease\", covariates=[])\n", + "X.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3698, 4)\n", + "(3698,)\n" + ] + } + ], + "source": [ + "print(X.shape)\n", + "print(y.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3: Run CellPhenoX" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "entering CV loop\n", + "\n", + "------------ CV Repeat number: 1\n", + "\n", + "------ Fold Number: 1\n", + "--- Accuracy: 0.7023519870235199\n", + "1\n", + "--- Validation Accuracy: 0.8275862068965517 - Validation AUROC: 0.8185670261941448 - Val AUPRC: 0.9549581934555448\n", + "\n", + "------ Fold Number: 2\n", + "--- Accuracy: 0.7055961070559611\n", + "2\n", + "--- Validation Accuracy: 0.9006085192697769 - Validation AUROC: 0.892869371682931 - Val AUPRC: 0.9770399352399095\n", + "\n", + "------ Fold Number: 3\n", + "--- Accuracy: 0.6801948051948052\n", + "3\n", + "--- Validation Accuracy: 0.8765182186234818 - Validation AUROC: 0.8679925048973682 - Val AUPRC: 0.9707836787744281\n", + "Average AUROC: 0.8598096342581479 | Average AUPRC: 0.9675939358232942\n", + "best model precision-recall score = 0.9770\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/zhanglab_mac2/Library/CloudStorage/OneDrive-TheUniversityofColoradoDenver/Zhang_Lab/Research/shap/.conda/lib/python3.11/site-packages/shap/plots/_beeswarm.py:699: UserWarning: No data for colormapping provided via 'c'. Parameters 'vmin', 'vmax' will be ignored\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# create CellPhenoX object \n", + "cellpx_obj = CellPhenoX(X, y, CV_repeats=1, outer_num_splits=3, inner_num_splits=2)\n", + "# and then train the classification model\n", + "cellpx_obj.model_training_shap_val(outpath = output_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0_shap1_shap2_shap3_shapinterpretable_score
cell
N7.LPA.ATGTTCACATCGAC0.019978-0.0075820.1297630.0171640.159322
N7.LPA.CATTAGCTGAGACG0.0183790.0199890.2340100.1303040.402682
N7.LPA.AAGGCTTGTGTAGC0.0522780.0376040.184861-0.0049390.269803
N7.LPA.TATCAAGATGTGAC0.0136740.0562030.068779-0.1024630.036193
N7.LPA.GAGTGGGAATGTGC-0.0170150.016166-0.011645-0.110724-0.123219
..................
N110.LPB.CCAGCGATCCTCCTAG-0.025661-0.084043-0.0279670.075934-0.061737
N110.LPB.CGAATGTAGACTAGGC0.0474680.0044430.219336-0.0488410.222407
N110.LPB.TCAACGACAATCCAAC0.0760380.0830480.0011840.0367290.196999
N110.LPB.CTGATAGAGCATGGCA-0.0145260.030951-0.0087960.1988060.206434
N110.LPB.CTTCTCTCATCGGTTA0.0124890.0249170.0122300.2624110.312047
\n", + "

3698 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " 0_shap 1_shap 2_shap 3_shap \\\n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC 0.019978 -0.007582 0.129763 0.017164 \n", + "N7.LPA.CATTAGCTGAGACG 0.018379 0.019989 0.234010 0.130304 \n", + "N7.LPA.AAGGCTTGTGTAGC 0.052278 0.037604 0.184861 -0.004939 \n", + "N7.LPA.TATCAAGATGTGAC 0.013674 0.056203 0.068779 -0.102463 \n", + "N7.LPA.GAGTGGGAATGTGC -0.017015 0.016166 -0.011645 -0.110724 \n", + "... ... ... ... ... \n", + "N110.LPB.CCAGCGATCCTCCTAG -0.025661 -0.084043 -0.027967 0.075934 \n", + "N110.LPB.CGAATGTAGACTAGGC 0.047468 0.004443 0.219336 -0.048841 \n", + "N110.LPB.TCAACGACAATCCAAC 0.076038 0.083048 0.001184 0.036729 \n", + "N110.LPB.CTGATAGAGCATGGCA -0.014526 0.030951 -0.008796 0.198806 \n", + "N110.LPB.CTTCTCTCATCGGTTA 0.012489 0.024917 0.012230 0.262411 \n", + "\n", + " interpretable_score \n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC 0.159322 \n", + "N7.LPA.CATTAGCTGAGACG 0.402682 \n", + "N7.LPA.AAGGCTTGTGTAGC 0.269803 \n", + "N7.LPA.TATCAAGATGTGAC 0.036193 \n", + "N7.LPA.GAGTGGGAATGTGC -0.123219 \n", + "... ... \n", + "N110.LPB.CCAGCGATCCTCCTAG -0.061737 \n", + "N110.LPB.CGAATGTAGACTAGGC 0.222407 \n", + "N110.LPB.TCAACGACAATCCAAC 0.196999 \n", + "N110.LPB.CTGATAGAGCATGGCA 0.206434 \n", + "N110.LPB.CTTCTCTCATCGGTTA 0.312047 \n", + "\n", + "[3698 rows x 5 columns]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cellpx_obj.shap_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Marker Discovery\n", + "identify markers correlated with the Interpretable Score" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fitting model\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/zhanglab_mac2/Library/CloudStorage/OneDrive-TheUniversityofColoradoDenver/Zhang_Lab/Research/shap/.conda/lib/python3.11/site-packages/statsmodels/regression/linear_model.py:1794: RuntimeWarning: divide by zero encountered in divide\n", + "/Users/zhanglab_mac2/Library/CloudStorage/OneDrive-TheUniversityofColoradoDenver/Zhang_Lab/Research/shap/.conda/lib/python3.11/site-packages/statsmodels/regression/linear_model.py:1794: RuntimeWarning: invalid value encountered in scalar multiply\n", + "/Users/zhanglab_mac2/Library/CloudStorage/OneDrive-TheUniversityofColoradoDenver/Zhang_Lab/Research/shap/.conda/lib/python3.11/site-packages/statsmodels/regression/linear_model.py:1716: RuntimeWarning: divide by zero encountered in scalar divide\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "results sorted by p vlaue: \n", + " Beta P_Value Adjusted_P_Value gene\n", + "const 0.007220 NaN NaN const\n", + "ADAMDEC1 0.009512 NaN NaN ADAMDEC1\n", + "ACTA2 -0.004977 NaN NaN ACTA2\n", + "TAGLN 0.002539 NaN NaN TAGLN\n", + "CCL11 -0.005101 NaN NaN CCL11\n", + "Significant Markers\n", + "Empty DataFrame\n", + "Columns: [Beta, P_Value, Adjusted_P_Value, gene]\n", + "Index: []\n" + ] + } + ], + "source": [ + "marker_discovery(cellpx_obj.shap_df, expression_mat)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/build/.doctrees/nbsphinx/walkthroughs_workflow_13_2.png b/build/.doctrees/nbsphinx/walkthroughs_workflow_13_2.png new file mode 100644 index 0000000..7d57250 Binary files /dev/null and b/build/.doctrees/nbsphinx/walkthroughs_workflow_13_2.png differ diff --git a/build/.doctrees/nbsphinx/walkthroughs_workflow_13_3.png b/build/.doctrees/nbsphinx/walkthroughs_workflow_13_3.png new file mode 100644 index 0000000..2cf12af Binary files /dev/null and b/build/.doctrees/nbsphinx/walkthroughs_workflow_13_3.png differ diff --git a/build/.doctrees/pyCellPhenoX.doctree b/build/.doctrees/pyCellPhenoX.doctree new file mode 100644 index 0000000..271a89e Binary files /dev/null and b/build/.doctrees/pyCellPhenoX.doctree differ diff --git a/build/.doctrees/pyCellPhenoX.operations.doctree b/build/.doctrees/pyCellPhenoX.operations.doctree new file mode 100644 index 0000000..a6ae10d Binary files /dev/null and b/build/.doctrees/pyCellPhenoX.operations.doctree differ diff --git a/build/.doctrees/pyCellPhenoX.utils.doctree b/build/.doctrees/pyCellPhenoX.utils.doctree new file mode 100644 index 0000000..6a4a488 Binary files /dev/null and b/build/.doctrees/pyCellPhenoX.utils.doctree differ diff --git a/build/.doctrees/requirements.doctree b/build/.doctrees/requirements.doctree new file mode 100644 index 0000000..335ee1a Binary files /dev/null and b/build/.doctrees/requirements.doctree differ diff --git a/build/.doctrees/tutorials.doctree b/build/.doctrees/tutorials.doctree new file mode 100755 index 0000000..78dfa68 Binary files /dev/null and b/build/.doctrees/tutorials.doctree differ diff --git a/build/.doctrees/walkthrough.doctree b/build/.doctrees/walkthrough.doctree new file mode 100644 index 0000000..0125710 Binary files /dev/null and b/build/.doctrees/walkthrough.doctree differ diff --git a/build/.doctrees/walkthroughs/single_cell_usage.doctree b/build/.doctrees/walkthroughs/single_cell_usage.doctree new file mode 100644 index 0000000..5125f33 Binary files /dev/null and b/build/.doctrees/walkthroughs/single_cell_usage.doctree differ diff --git a/build/.doctrees/walkthroughs/workflow.doctree b/build/.doctrees/walkthroughs/workflow.doctree new file mode 100644 index 0000000..148a59b Binary files /dev/null and b/build/.doctrees/walkthroughs/workflow.doctree differ diff --git a/build/CODE_OF_CONDUCT.md b/build/CODE_OF_CONDUCT.md index cc472f5..38fc14f 100644 --- a/build/CODE_OF_CONDUCT.md +++ b/build/CODE_OF_CONDUCT.md @@ -1,116 +1 @@ -# Code of Conduct - pyCellPhenoX - -## Our Pledge - -In the interest of fostering an open and welcoming environment, we as -contributors and maintainers pledge to make participation in our project and -our community a harassment-free experience for everyone, regardless of age, body -size, disability, ethnicity, sex characteristics, gender identity and expression, -level of experience, education, socio-economic status, nationality, personal -appearance, race, religion, or sexual identity and orientation. - -## Our Standards - -Examples of behavior that contributes to a positive environment for our -community include: - -* Demonstrating empathy and kindness toward other people -* Being respectful of differing opinions, viewpoints, and experiences -* Giving and gracefully accepting constructive feedback -* Accepting responsibility and apologizing to those affected by our mistakes, - and learning from the experience -* Focusing on what is best not just for us as individuals, but for the - overall community - -Examples of unacceptable behavior include: - -* The use of sexualized language or imagery, and sexual attention or - advances -* Trolling, insulting or derogatory comments, and personal or political attacks -* Public or private harassment -* Publishing others' private information, such as a physical or email - address, without their explicit permission -* Other conduct which could reasonably be considered inappropriate in a - professional setting - -## Our Responsibilities - -Project maintainers are responsible for clarifying and enforcing our standards of -acceptable behavior and will take appropriate and fair corrective action in -response to any behavior that they deem inappropriate, -threatening, offensive, or harmful. - -Project maintainers have the right and responsibility to remove, edit, or reject -comments, commits, code, wiki edits, issues, and other contributions that are -not aligned to this Code of Conduct, and will -communicate reasons for moderation decisions when appropriate. - -## Scope - -This Code of Conduct applies within all community spaces, and also applies when -an individual is officially representing the community in public spaces. -Examples of representing our community include using an official e-mail address, -posting via an official social media account, or acting as an appointed -representative at an online or offline event. - -## Enforcement - -Instances of abusive, harassing, or otherwise unacceptable behavior may be -reported to the community leaders responsible for enforcement at . -All complaints will be reviewed and investigated promptly and fairly. - -All community leaders are obligated to respect the privacy and security of the -reporter of any incident. - -## Enforcement Guidelines - -Community leaders will follow these Community Impact Guidelines in determining -the consequences for any action they deem in violation of this Code of Conduct: - -### 1. Correction - -**Community Impact**: Use of inappropriate language or other behavior deemed -unprofessional or unwelcome in the community. - -**Consequence**: A private, written warning from community leaders, providing -clarity around the nature of the violation and an explanation of why the -behavior was inappropriate. A public apology may be requested. - -### 2. Warning - -**Community Impact**: A violation through a single incident or series -of actions. - -**Consequence**: A warning with consequences for continued behavior. No -interaction with the people involved, including unsolicited interaction with -those enforcing the Code of Conduct, for a specified period of time. This -includes avoiding interactions in community spaces as well as external channels -like social media. Violating these terms may lead to a temporary or -permanent ban. - -### 3. Temporary Ban - -**Community Impact**: A serious violation of community standards, including -sustained inappropriate behavior. - -**Consequence**: A temporary ban from any sort of interaction or public -communication with the community for a specified period of time. No public or -private interaction with the people involved, including unsolicited interaction -with those enforcing the Code of Conduct, is allowed during this period. -Violating these terms may lead to a permanent ban. - -### 4. Permanent Ban - -**Community Impact**: Demonstrating a pattern of violation of community -standards, including sustained inappropriate behavior, harassment of an -individual, or aggression toward or disparagement of classes of individuals. - -**Consequence**: A permanent ban from any sort of public interaction within -the community. - -## Attribution - -This Code of Conduct is adapted from the [Contributor Covenant](https://contributor-covenant.org/), version -[1.4](https://www.contributor-covenant.org/version/1/4/code-of-conduct/code_of_conduct.md) and -[2.0](https://www.contributor-covenant.org/version/2/0/code_of_conduct/code_of_conduct.md), -and was generated by [contributing-gen](https://github.com/bttger/contributing-gen). \ No newline at end of file +# Code of Conduct diff --git a/build/CONTRIBUTING.md b/build/CONTRIBUTING.md index fb74ece..5e90b2f 100644 --- a/build/CONTRIBUTING.md +++ b/build/CONTRIBUTING.md @@ -1,138 +1,47 @@ - -# Contributing to pyCellPhenoX +# Contributing to the Documentation -First off, thanks for taking the time to contribute! ❤️ + -## Table of Contents +1. **Fork the Repository**: Start by forking the repository on GitHub to create your own copy. +2. **Clone the Repository**: Clone your forked repository to your local machine using: -- [Code of Conduct](#code-of-conduct) -- [I Have a Question](#i-have-a-question) -- [I Want To Contribute](#i-want-to-contribute) - - [Reporting Bugs](#reporting-bugs) - - [Suggesting Enhancements](#suggesting-enhancements) - - [Your First Code Contribution](#your-first-code-contribution) - - [Improving The Documentation](#improving-the-documentation) -- [Styleguides](#styleguides) - - [Commit Messages](#commit-messages) -- [Join The Project Team](#join-the-project-team) + .. code:: bash + git clone https://github.com/fanzhanglab/pyCellPhenoX.git -## Code of Conduct +3. **Create a New Branch**: Create a new branch for your changes: -This project and everyone participating in it is governed by the -[pyCellPhenoX Code of Conduct](https://github.com/fanzhanglab/pyCellPhenoXblob/master/CODE_OF_CONDUCT.md). -By participating, you are expected to uphold this code. Please report unacceptable behavior -to . + .. code:: bash + git checkout -b your-branch-name -## I Have a Question +4. **Make Your Changes**: Edit the documentation files as needed. Be sure to follow the existing style and format. +5. **Commit Your Changes**: Save your changes and commit them with a clear message: -> If you want to ask a question, we assume that you have read the available [Documentation](https://pyCellPhenoX.readthedocs.io). + .. code:: bash -Before you ask a question, it is best to search for existing [Issues](https://github.com/fanzhanglab/pyCellPhenoX/issues) that might help you. In case you have found a suitable issue and still need clarification, you can write your question in this issue. It is also advisable to search the internet for answers first. + git commit -m "Brief description of your changes" -If you then still feel the need to ask a question and need clarification, we recommend the following: +6. **Push Your Changes**: Push your changes to your fork on GitHub: -- Open an [Issue](https://github.com/fanzhanglab/pyCellPhenoX/issues/new). -- Provide as much context as you can about what you're running into. -- Provide project and platform versions (nodejs, npm, etc), depending on what seems relevant. + .. code:: bash -We will then take care of the issue as soon as possible. + git push origin your-branch-name - +If you need help with any of these steps, refer to the `GitHub documentation `_ for detailed instructions. -## I Want To Contribute +Additional Tips +--------------- -> ### Legal Notice -> When contributing to this project, you must agree that you have authored 100% of the content, that you have the necessary rights to the content and that the content you contribute may be provided under the project license. +- **Documentation Standards**: Please ensure your contributions align with our documentation standards. Refer to existing documentation for examples of style and formatting. +- **Testing Changes**: If applicable, verify your changes by building the documentation locally to see how it looks. +- **Feedback and Collaboration**: We encourage discussions and feedback on your contributions. Feel free to reach out if you have any questions or need assistance! -### Reporting Bugs - - -#### Before Submitting a Bug Report - -A good bug report shouldn't leave others needing to chase you up for more information. Therefore, we ask you to investigate carefully, collect information and describe the issue in detail in your report. Please complete the following steps in advance to help us fix any potential bug as fast as possible. - -- Make sure that you are using the latest version. -- Determine if your bug is really a bug and not an error on your side e.g. using incompatible environment components/versions (Make sure that you have read the [documentation](https://pyCellPhenoX.readthedocs.io). If you are looking for support, you might want to check [this section](#i-have-a-question)). -- To see if other users have experienced (and potentially already solved) the same issue you are having, check if there is not already a bug report existing for your bug or error in the [bug tracker](https://github.com/fanzhanglab/pyCellPhenoXissues?q=label%3Abug). -- Also make sure to search the internet (including Stack Overflow) to see if users outside of the GitHub community have discussed the issue. -- Collect information about the bug: - - Stack trace (Traceback) - - OS, Platform and Version (Windows, Linux, macOS, x86, ARM) - - Version of the interpreter, compiler, SDK, runtime environment, package manager, depending on what seems relevant. - - Possibly your input and the output - - Can you reliably reproduce the issue? And can you also reproduce it with older versions? - - -#### How Do I Submit a Good Bug Report? - -> You must never report security related issues, vulnerabilities or bugs including sensitive information to the issue tracker, or elsewhere in public. Instead sensitive bugs must be sent by email to . - - -We use GitHub issues to track bugs and errors. If you run into an issue with the project: - -- Open an [Issue](https://github.com/fanzhanglab/pyCellPhenoX/issues/new). (Since we can't be sure at this point whether it is a bug or not, we ask you not to talk about a bug yet and not to label the issue.) -- Explain the behavior you would expect and the actual behavior. -- Please provide as much context as possible and describe the *reproduction steps* that someone else can follow to recreate the issue on their own. This usually includes your code. For good bug reports you should isolate the problem and create a reduced test case. -- Provide the information you collected in the previous section. - -Once it's filed: - -- The project team will label the issue accordingly. -- A team member will try to reproduce the issue with your provided steps. If there are no reproduction steps or no obvious way to reproduce the issue, the team will ask you for those steps and mark the issue as `needs-repro`. Bugs with the `needs-repro` tag will not be addressed until they are reproduced. -- If the team is able to reproduce the issue, it will be marked `needs-fix`, as well as possibly other tags (such as `critical`), and the issue will be left to be [implemented by someone](#your-first-code-contribution). - - - - -### Suggesting Enhancements - -This section guides you through submitting an enhancement suggestion for pyCellPhenoX, **including completely new features and minor improvements to existing functionality**. Following these guidelines will help maintainers and the community to understand your suggestion and find related suggestions. - - -#### Before Submitting an Enhancement - -- Make sure that you are using the latest version. -- Read the [documentation](https://pyCellPhenoX.readthedocs.io) carefully and find out if the functionality is already covered, maybe by an individual configuration. -- Perform a [search](https://github.com/fanzhanglab/pyCellPhenoX/issues) to see if the enhancement has already been suggested. If it has, add a comment to the existing issue instead of opening a new one. -- Find out whether your idea fits with the scope and aims of the project. It's up to you to make a strong case to convince the project's developers of the merits of this feature. Keep in mind that we want features that will be useful to the majority of our users and not just a small subset. If you're just targeting a minority of users, consider writing an add-on/plugin library. - - -#### How Do I Submit a Good Enhancement Suggestion? - -Enhancement suggestions are tracked as [GitHub issues](https://github.com/fanzhanglab/pyCellPhenoX/issues). - -- Use a **clear and descriptive title** for the issue to identify the suggestion. -- Provide a **step-by-step description of the suggested enhancement** in as many details as possible. -- **Describe the current behavior** and **explain which behavior you expected to see instead** and why. At this point you can also tell which alternatives do not work for you. -- You may want to **include screenshots and animated GIFs** which help you demonstrate the steps or point out the part which the suggestion is related to. You can use [this tool](https://www.cockos.com/licecap/) to record GIFs on macOS and Windows, and [this tool](https://github.com/colinkeenan/silentcast) or [this tool](https://github.com/GNOME/byzanz) on Linux. -- **Explain why this enhancement would be useful** to most pyCellPhenoX users. You may also want to point out the other projects that solved it better and which could serve as inspiration. - - - - -## Attribution -This guide is based on the **contributing-gen**. [Make your own](https://github.com/bttger/contributing-gen)! +Thank you for considering contributing to our documentation! Your efforts are invaluable in enhancing the user experience. --> diff --git a/build/README.html b/build/README.html new file mode 100644 index 0000000..dba0fc5 --- /dev/null +++ b/build/README.html @@ -0,0 +1,496 @@ + + + + + + + + + pyCellPhenoX - CellPhenoX 0.3.0 documentation + + + + + + + + + + + + + + + + + Contents + + + + + + Menu + + + + + + + + Expand + + + + + + Light mode + + + + + + + + + + + + + + Dark mode + + + + + + + Auto light/dark, in light mode + + + + + + + + + + + + + + + Auto light/dark, in dark mode + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
+ +
+
+
CellPhenoX 0.3.0 documentation
 +
+
+
+ +
+ +
+
+ +
+
+
+ + + + + Back to top + +
+
+ + + + +
+
+ +
+ +
+
+
+

pyCellPhenoX

+

+ +

+

PyPI +Python Version +License +Read the documentation at https://pyXcell.readthedocs.io/ +Codecov

+

pre-commit +Black

+

We introduce pyCellPhenoX.

+ +
+

Figure 1. Insert figure description here

+
+
+

Installation

+

You can install pyCellPhenoX from PyPI:

+
pip install pyCellPhenoX
+
+
+

conda (link):

+
# install pyCellPhenoX from conda-forge
+conda install -c conda-forge pyCellPhenoX
+
+
+

github (link):

+
# install pyCellPhenoX directly from github
+git clone git@github.com:fanzhanglab/pyCellPhenoX.git
+
+
+
+

Dependencies / Requirements

+

When using pyCellPhenoX please ensure you are using the following dependency versions or requirements

+
python = "^3.9"
+pandas = "^2.2.3"
+numpy = "^2.1.1"
+xgboost = "^2.0"
+numba = ">=0.54"
+shap = "^0.46.0"
+scikit-learn = "^1.5.2"
+matplotlib = "^3.9.2"
+statsmodels = "^0.14.3"
+
+
+
+
+
+

Tutorials

+

Please see the Command-line Reference for details. Additonally, please see Walkthroughs on the documentation page.

+
+
+

API

+

pyCellPhenoX has four major functions which are apart of the object:

+
    +

  1. split_data() - Split the data into training, testing, and validation sets

    2. +

  2. model_train_shap_values() - Train the model using nested cross validation strategy and generate shap values for each fold/CV repeat

    3. +

  3. get_shap_values() - Aggregate SHAP values for each sample

    4. +

  4. get_intepretable_score() - Calculate the interpretable score based on SHAP values.

    5. +
+

Additional major functions associated with pyCellPhenoX are:

+
    +

  1. marker_discovery() - Identify markers correlated with the discriminatory power of the Interpretable Score.

    2. +

  2. nonNegativeMatrixFactorization() - Perform non Negative Matrix Factorization (NMF)

    3. +

  3. preprocessing() - Prepare the data to be in the correct format for CellPhenoX

    4. +

  4. principleComponentAnalysis() - Perform Principle Component Analysis (PCA)

    5. +
+

Each function has uniqure arguments, see our documentation for more information

+
+
+

Usage

+

For more information please see Walkthrough or Workflow Documentation

+
+
+

License

+

Distributed under the terms of the MIT license, +pyCellPhenoX is free and open source software.

+
+

Code of Conduct

+

For more information please see Code of Conduct or Code of Conduct Documentation

+
+
+

Contributing

+

For more information please see Contributing or Contributing Documentation

+
+
+
+

Issues

+

If you encounter any problems, please file an issue along with a detailed description.

+
+
+

Citation

+

If you have used pyCellPhenoX in your project, please use the citation below.

+
@software{Young2024,
+  author = {Young, Jade and Inamo, Jun and Zhang, Fan},
+  title = {CellPhenoX: An eXplainable Cell-specific machine learning method to predict clinical Phenotypes using single-cell multi-omics},
+  date = {2024},
+  url = {https://github.com/fanzhanglab/pyCellPhenoX},
+  version = {},
+}
+
+
+

or

+
@ARTICLE{Young2024,
+  title    = "{CellPhenoX}: An eXplainable Cell-specific machine learning method to predict clinical Phenotypes using single-cell multi-omics",
+  author   = "Young, Jade and Inamo, Jun and Zhang, Fan",
+  journal  = "",
+  volume   =  ,
+  number   =  ,
+  pages    = "",
+  month    =  ,
+  year     =  ,
+  language = "en",
+}
+
+
+
+
+

Contact

+

Please contact fanzhanglab@gmail.com for +further questions or potential collaborative opportunities!

+ +
+
+ +
+
+ +
+ +
+
+ + + + + + + + + \ No newline at end of file diff --git a/build/_images/walkthroughs_workflow_13_2.png b/build/_images/walkthroughs_workflow_13_2.png new file mode 100644 index 0000000..7d57250 Binary files /dev/null and b/build/_images/walkthroughs_workflow_13_2.png differ diff --git a/build/_images/walkthroughs_workflow_13_3.png b/build/_images/walkthroughs_workflow_13_3.png new file mode 100644 index 0000000..2cf12af Binary files /dev/null and b/build/_images/walkthroughs_workflow_13_3.png differ diff --git a/build/_sources/CODE_OF_CONDUCT.md.txt b/build/_sources/CODE_OF_CONDUCT.md.txt new file mode 100644 index 0000000..cc472f5 --- /dev/null +++ b/build/_sources/CODE_OF_CONDUCT.md.txt @@ -0,0 +1,116 @@ +# Code of Conduct - pyCellPhenoX + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to make participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, sex characteristics, gender identity and expression, +level of experience, education, socio-economic status, nationality, personal +appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our +community include: + +* Demonstrating empathy and kindness toward other people +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, + and learning from the experience +* Focusing on what is best not just for us as individuals, but for the + overall community + +Examples of unacceptable behavior include: + +* The use of sexualized language or imagery, and sexual attention or + advances +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email + address, without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying and enforcing our standards of +acceptable behavior and will take appropriate and fair corrective action in +response to any behavior that they deem inappropriate, +threatening, offensive, or harmful. + +Project maintainers have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, and will +communicate reasons for moderation decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when +an individual is officially representing the community in public spaces. +Examples of representing our community include using an official e-mail address, +posting via an official social media account, or acting as an appointed +representative at an online or offline event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported to the community leaders responsible for enforcement at . +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the +reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining +the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed +unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing +clarity around the nature of the violation and an explanation of why the +behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series +of actions. + +**Consequence**: A warning with consequences for continued behavior. No +interaction with the people involved, including unsolicited interaction with +those enforcing the Code of Conduct, for a specified period of time. This +includes avoiding interactions in community spaces as well as external channels +like social media. Violating these terms may lead to a temporary or +permanent ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including +sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public +communication with the community for a specified period of time. No public or +private interaction with the people involved, including unsolicited interaction +with those enforcing the Code of Conduct, is allowed during this period. +Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community +standards, including sustained inappropriate behavior, harassment of an +individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within +the community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant](https://contributor-covenant.org/), version +[1.4](https://www.contributor-covenant.org/version/1/4/code-of-conduct/code_of_conduct.md) and +[2.0](https://www.contributor-covenant.org/version/2/0/code_of_conduct/code_of_conduct.md), +and was generated by [contributing-gen](https://github.com/bttger/contributing-gen). \ No newline at end of file diff --git a/build/_sources/CONTRIBUTING.md.txt b/build/_sources/CONTRIBUTING.md.txt new file mode 100644 index 0000000..960374e --- /dev/null +++ b/build/_sources/CONTRIBUTING.md.txt @@ -0,0 +1,236 @@ + +# Contributing to pyCellPhenoX + +First off, thanks for taking the time to contribute! ❤️ + +All types of contributions are encouraged and valued. See the [Table of Contents](#table-of-contents) for different ways to help and details about how this project handles them. Please make sure to read the relevant section before making your contribution. It will make it a lot easier for us maintainers and smooth out the experience for all involved. The community looks forward to your contributions. 🎉 + +> And if you like the project, but just don't have time to contribute, that's fine. There are other easy ways to support the project and show your appreciation, which we would also be very happy about: +> - Star the project +> - Tweet about it +> - Refer this project in your project's readme +> - Mention the project at local meetups and tell your friends/colleagues + + +## Table of Contents + +- [Code of Conduct](#code-of-conduct) +- [I Have a Question](#i-have-a-question) +- [I Want To Contribute](#i-want-to-contribute) + - [Reporting Bugs](#reporting-bugs) + - [Suggesting Enhancements](#suggesting-enhancements) +- [Styleguides](#style-guides) + - [Documentation](#documentation) + - [Dev Environments](#dev-environments) +- [Code Quality](#code-quality) + - [Formatting](#formatting) + - [Linting](#linting) + - [Documentation Style Guide](#documentation-style-guide) + - [Commit Messages](#commit-messages) +- [Attribution](#attribution) + +## Code of Conduct + +This project and everyone participating in it is governed by the +[pyCellPhenoX Code of Conduct](https://github.com/fanzhanglab/pyCellPhenoXblob/master/CODE_OF_CONDUCT.md). +By participating, you are expected to uphold this code. Please report unacceptable behavior +to . + + +## I Have a Question + +> If you want to ask a question, we assume that you have read the available [Documentation](https://pyCellPhenoX.readthedocs.io). + +Before you ask a question, it is best to search for existing [Issues](https://github.com/fanzhanglab/pyCellPhenoX/issues) that might help you. In case you have found a suitable issue and still need clarification, you can write your question in this issue. It is also advisable to search the internet for answers first. + +If you then still feel the need to ask a question and need clarification, we recommend the following: + +- Open an [Issue](https://github.com/fanzhanglab/pyCellPhenoX/issues/new). +- Provide as much context as you can about what you're running into. +- Provide project and platform versions (nodejs, npm, etc), depending on what seems relevant. + +We will then take care of the issue as soon as possible. + + + +## I Want To Contribute + +> ### Legal Notice +> When contributing to this project, you must agree that you have authored 100% of the content, that you have the necessary rights to the content and that the content you contribute may be provided under the project license. + +### Reporting Bugs + + +#### Before Submitting a Bug Report + +A good bug report shouldn't leave others needing to chase you up for more information. Therefore, we ask you to investigate carefully, collect information and describe the issue in detail in your report. Please complete the following steps in advance to help us fix any potential bug as fast as possible. + +- Make sure that you are using the latest version. +- Determine if your bug is really a bug and not an error on your side e.g. using incompatible environment components/versions (Make sure that you have read the [documentation](https://pyCellPhenoX.readthedocs.io). If you are looking for support, you might want to check [this section](#i-have-a-question)). +- To see if other users have experienced (and potentially already solved) the same issue you are having, check if there is not already a bug report existing for your bug or error in the [bug tracker](https://github.com/fanzhanglab/pyCellPhenoXissues?q=label%3Abug). +- Also make sure to search the internet (including Stack Overflow) to see if users outside of the GitHub community have discussed the issue. +- Collect information about the bug: + - Stack trace (Traceback) + - OS, Platform and Version (Windows, Linux, macOS, x86, ARM) + - Version of the interpreter, compiler, SDK, runtime environment, package manager, depending on what seems relevant. + - Possibly your input and the output + - Can you reliably reproduce the issue? And can you also reproduce it with older versions? + + +#### How Do I Submit a Good Bug Report? + +> You must never report security related issues, vulnerabilities or bugs including sensitive information to the issue tracker, or elsewhere in public. Instead sensitive bugs must be sent by email to . + + +We use GitHub issues to track bugs and errors. If you run into an issue with the project: + +- Open an [Issue](https://github.com/fanzhanglab/pyCellPhenoX/issues/new). (Since we can't be sure at this point whether it is a bug or not, we ask you not to talk about a bug yet and not to label the issue.) +- Explain the behavior you would expect and the actual behavior. +- Please provide as much context as possible and describe the *reproduction steps* that someone else can follow to recreate the issue on their own. This usually includes your code. For good bug reports you should isolate the problem and create a reduced test case. +- Provide the information you collected in the previous section. + +Once it's filed: + +- The project team will label the issue accordingly. +- A team member will try to reproduce the issue with your provided steps. If there are no reproduction steps or no obvious way to reproduce the issue, the team will ask you for those steps and mark the issue as `needs-repro`. Bugs with the `needs-repro` tag will not be addressed until they are reproduced. +- If the team is able to reproduce the issue, it will be marked `needs-fix`, as well as possibly other tags (such as `critical`), and the issue will be left to be [implemented by someone](#your-first-code-contribution). + + + + +### Suggesting Enhancements + +This section guides you through submitting an enhancement suggestion for pyCellPhenoX, **including completely new features and minor improvements to existing functionality**. Following these guidelines will help maintainers and the community to understand your suggestion and find related suggestions. + + +#### Before Submitting an Enhancement + +- Make sure that you are using the latest version. +- Read the [documentation](https://pyCellPhenoX.readthedocs.io) carefully and find out if the functionality is already covered, maybe by an individual configuration. +- Perform a [search](https://github.com/fanzhanglab/pyCellPhenoX/issues) to see if the enhancement has already been suggested. If it has, add a comment to the existing issue instead of opening a new one. +- Find out whether your idea fits with the scope and aims of the project. It's up to you to make a strong case to convince the project's developers of the merits of this feature. Keep in mind that we want features that will be useful to the majority of our users and not just a small subset. If you're just targeting a minority of users, consider writing an add-on/plugin library. + + +#### How Do I Submit a Good Enhancement Suggestion? + +Enhancement suggestions are tracked as [GitHub issues](https://github.com/fanzhanglab/pyCellPhenoX/issues). + +- Use a **clear and descriptive title** for the issue to identify the suggestion. +- Provide a **step-by-step description of the suggested enhancement** in as many details as possible. +- **Describe the current behavior** and **explain which behavior you expected to see instead** and why. At this point you can also tell which alternatives do not work for you. +- You may want to **include screenshots and animated GIFs** which help you demonstrate the steps or point out the part which the suggestion is related to. You can use [this tool](https://www.cockos.com/licecap/) to record GIFs on macOS and Windows, and [this tool](https://github.com/colinkeenan/silentcast) or [this tool](https://github.com/GNOME/byzanz) on Linux. +- **Explain why this enhancement would be useful** to most pyCellPhenoX users. You may also want to point out the other projects that solved it better and which could serve as inspiration. + + +## Your first code contribution + +We welcome contributions! Follow these steps to contribute: + +### 1. Fork, Clone, and Branch +- Fork the repository and clone it to your local machine. + +```bash +git clone https://github.com/fanzhanglab/pyCellPhenoX.git +cd pyCellPhenoX +``` + +Please branch from the `main` branch given we have set up branch protections. +``` bash +git checkout -b your-branch-name +``` + +### 2. Make Your Changes +- Make sure your code follows the project standards. +- Format your Python code with Black: + +``` bash +black your_file.py +``` + +### 3. Commit and Push +Commit your changes with a meaningful message: + +```bash +git commit -m "Description of your changes" +``` + +Push your changes: + +``` bash +git push origin your-branch-name +``` +### 4. Submit a Pull Request +Submit a pull request and explain the changes you've made. + + +## Style Guides + +### Documentation + +We use [sphinx](https://www.sphinx-doc.org/en/master/index.html) for autodocumentation of docstrings, using the [napoleon extenstion](https://www.sphinx-doc.org/en/master/usage/extensions/napoleon.html) to parse [NumPy style docstrings](https://numpydoc.readthedocs.io/en/latest/format.html), implemented with a [furo](https://pradyunsg.me/furo/) theme. +We host our documentation on [readthedocs.org](https://readthedocs.org/) at [https://pyCellPhenoX.readthedocs.io/en/](https://pyCellPhenoX.readthedocs.io/en/). + +To build and test changes to the docs locally, run the following command: + +```bash +sphinx-build -b html docs build +``` + +See [`docs/conf.py`](../conf.py) for full documentation configuration. + +### Dev environments + +#### Local devcontainer + +Instructions for setting up a local development environment using VSCode DevContainers: + +1. Install [VSCode](https://code.visualstudio.com/download) +2. Install the [Remote - Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) extension +3. Open the repository in VSCode +4. Click on the green "Reopen in Container" button in the lower left corner of the window +5. Wait for the container to build and install the required dependencies + +## Code Quality + +Please follow the below quality guides to the best of your abilities. +If you have configured your [dev environment](#dev-environments) as described above, the formatting and linting rules will also be enforced automatically using the installed [pre-commit](https://pre-commit.com/) hooks. + +### Formatting + +We use [black](https://black.readthedocs.io/en/stable/) for formatting Python code, and [prettier](https://prettier.io/) for formatting markdown, json and yaml files. +We include `black` in the poetry dev dependencies so it can be run manually using `black format` +Prettier (which is not python-based) is not included in the poetry dev dependencies, but can be installed and run manually. +Alternately, both `black format` and `prettier` will be run automatically at commit time with the pre-commit hooks installed. + +### Linting + +For python code linting, we also use [black](https://black.readthedocs.io/en/stable/), which can perform same linting checks as Flake8. +You can use the command `black --check your_file.py` or `black path/to/your/directory` to check for linting errors. +We also include some commented-out rules in that section that we are working towards enabling in the future. +All linting checks will also be run automatically at commit time with the pre-commit hooks as described above. + +### Documentation style guide + +We use the [numpy documentation style guide](https://numpydoc.readthedocs.io/en/latest/format.html). +When writing markdown documentation, please also ensure that each sentence is on a new line. + +### Commit messages + +pyCellPhenoX uses [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) standard for commit messages to aid in automatic changelog generation. +We prepare commit messages that follow this standard using [commitizen](https://commitizen-tools.github.io/commitizen/), which comes with the poetry dev dependencies. + +## Attribution +This guide is based on the **contributing-gen**. [Make your own](https://github.com/bttger/contributing-gen)! diff --git a/build/_sources/README.md.txt b/build/_sources/README.md.txt new file mode 100644 index 0000000..7b575e7 --- /dev/null +++ b/build/_sources/README.md.txt @@ -0,0 +1,132 @@ +# pyCellPhenoX + +

+ +

+ +![PyPI](https://img.shields.io/pypi/v/pyCellPhenoX.svg) +![Python Version](https://img.shields.io/pypi/pyversions/pyCellPhenoX) +[![License](https://img.shields.io/pypi/l/pyCellPhenoX)][license] +![Read the documentation at https://pyXcell.readthedocs.io/](https://img.shields.io/readthedocs/pyXcell/latest.svg?label=Read%20the%20Docs) +![Codecov](https://codecov.io/gh/fanzhanglab/pyCellPhenoX/branch/main/graph/badge.svg) + +![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white) +![Black](https://img.shields.io/badge/code%20style-black-000000.svg) + + +We introduce pyCellPhenoX. + + + +> Figure 1. Insert figure description here + +## Installation +You can install _pyCellPhenoX_ from PyPI: + +``` bash +pip install pyCellPhenoX +``` + +**conda** ([link](https://anaconda.org/conda-forge/pyCellPhenoX)): +``` bash +# install pyCellPhenoX from conda-forge +conda install -c conda-forge pyCellPhenoX +``` + +**github** ([link](https://github.com/fanzhanglab/pyCellPhenoX)): +``` bash +# install pyCellPhenoX directly from github +git clone git@github.com:fanzhanglab/pyCellPhenoX.git +``` + +### Dependencies / Requirements +When using pyCellPhenoX please ensure you are using the following dependency versions or requirements +``` python +python = "^3.9" +pandas = "^2.2.3" +numpy = "^2.1.1" +xgboost = "^2.0" +numba = ">=0.54" +shap = "^0.46.0" +scikit-learn = "^1.5.2" +matplotlib = "^3.9.2" +statsmodels = "^0.14.3" +``` + +## Tutorials +Please see the [Command-line Reference] for details. Additonally, please see [Walkthroughs] on the documentation page. + +## API +pyCellPhenoX has four major functions which are apart of the object: +1. split_data() - Split the data into training, testing, and validation sets +2. model_train_shap_values() - Train the model using nested cross validation strategy and generate shap values for each fold/CV repeat +3. get_shap_values() - Aggregate SHAP values for each sample +4. get_intepretable_score() - Calculate the interpretable score based on SHAP values. + +Additional major functions associated with pyCellPhenoX are: +1. marker_discovery() - Identify markers correlated with the discriminatory power of the Interpretable Score. +2. nonNegativeMatrixFactorization() - Perform non Negative Matrix Factorization (NMF) +3. preprocessing() - Prepare the data to be in the correct format for CellPhenoX +4. principleComponentAnalysis() - Perform Principle Component Analysis (PCA) + +Each function has uniqure arguments, see our [documentation] for more information + +## Usage +For more information please see [Walkthrough](walkthroughs/workflow.ipynb) or [Workflow Documentation] + +## License +Distributed under the terms of the [MIT license][license], +_pyCellPhenoX_ is free and open source software. + +### Code of Conduct +For more information please see [Code of Conduct](CODE_OF_CONDUCT.md) or [Code of Conduct Documentation] + +### Contributing +For more information please see [Contributing](CONTRIBUTING.md) or [Contributing Documentation] + +## Issues +If you encounter any problems, please [file an issue] along with a detailed description. + +## Citation +If you have used `pyCellPhenoX` in your project, please use the citation below. +``` +@software{Young2024, + author = {Young, Jade and Inamo, Jun and Zhang, Fan}, + title = {CellPhenoX: An eXplainable Cell-specific machine learning method to predict clinical Phenotypes using single-cell multi-omics}, + date = {2024}, + url = {https://github.com/fanzhanglab/pyCellPhenoX}, + version = {}, +} +``` +or +``` +@ARTICLE{Young2024, + title = "{CellPhenoX}: An eXplainable Cell-specific machine learning method to predict clinical Phenotypes using single-cell multi-omics", + author = "Young, Jade and Inamo, Jun and Zhang, Fan", + journal = "", + volume = , + number = , + pages = "", + month = , + year = , + language = "en", +} +``` + +## Contact +Please contact [fanzhanglab@gmail.com](mailto:fanzhanglab@gmail.com) for +further questions or potential collaborative opportunities! + + + +[license]: https://github.com/fanzhanglab/pyCellPhenoX/blob/main/LICENSE +[contributor guide]: https://github.com/fanzhanglab/pyCellPhenoX/blob/main/CONTRIBUTING.md +[file an issue]: https://github.com/fanzhanglab/pyCellPhenoX/issues/new +[command-line reference]: https://pyCellPhenoX.readthedocs.io/en/latest/usage.html +[pipi]: https://pypi.org/project/pip/ +[pypi]: https://pypi.org/project/pyCellPhenoX/ +[walkthroughs]: https://pyCellPhenoXreadthedocs.io/walkthroughs/single_cell_usage +[documentation]: https://pyCellPhenoXreadthedocs.io/ +[Code of Conduct Documentation]: https://pyCellPhenoXreadthedocs.io/code_of_conduct +[Contributing Documentation]: https://pyCellPhenoXreadthedocs.io/contributing +[Workflow Documentation]: https://pyCellPhenoXreadthedocs.io/walkthroughs/workflows \ No newline at end of file diff --git a/docs/api_reference.rst b/build/_sources/api_reference.rst.txt old mode 100755 new mode 100644 similarity index 100% rename from docs/api_reference.rst rename to build/_sources/api_reference.rst.txt diff --git a/docs/changelog.rst b/build/_sources/changelog.rst.txt old mode 100755 new mode 100644 similarity index 100% rename from docs/changelog.rst rename to build/_sources/changelog.rst.txt diff --git a/build/_sources/index.rst.txt b/build/_sources/index.rst.txt index 6f127ac..27a5fc1 100644 --- a/build/_sources/index.rst.txt +++ b/build/_sources/index.rst.txt @@ -1,23 +1,16 @@ -.. mdinclude:: ../README.md - .. toctree:: :maxdepth: 2 :caption: Table of Contents - installation + ../README.md + ../CONTRIBUTING.md + ../CODE_OF_CONDUCT.md walkthrough modules - citation - code_of_conduct - contributing - issues - license Indices and tables ================== * :ref:`genindex` -* :ref:`modindex` -* :ref:`search` - +* :ref:`modindex` \ No newline at end of file diff --git a/docs/tutorials.rst b/build/_sources/tutorials.rst.txt old mode 100755 new mode 100644 similarity index 100% rename from docs/tutorials.rst rename to build/_sources/tutorials.rst.txt diff --git a/build/_sources/walkthrough.rst.txt b/build/_sources/walkthrough.rst.txt index c3b5f7c..ffba62d 100644 --- a/build/_sources/walkthrough.rst.txt +++ b/build/_sources/walkthrough.rst.txt @@ -4,4 +4,4 @@ Walkthroughs .. toctree:: :maxdepth: 1 - walkthroughs/single_cell_usage.ipynb + /walkthroughs/workflow.ipynb diff --git a/build/_sources/walkthroughs/workflow.ipynb.txt b/build/_sources/walkthroughs/workflow.ipynb.txt new file mode 100644 index 0000000..451a9f6 --- /dev/null +++ b/build/_sources/walkthroughs/workflow.ipynb.txt @@ -0,0 +1,933 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Importing Dependencies " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/zhanglab/Documents/Python Projects/pyCellPhenoX/pycpx/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import pyCellPhenoX\n", + "\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1: Import Data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# paths to expression data and meta data files\n", + "expression_file = \"./../input/uc_fibroblast_exp.csv\"\n", + "meta_file = \"./../input/uc_fibroblast_meta.csv\"\n", + "output_path = \"./../output/\"\n", + "# read in data\n", + "expression_mat = pd.read_csv(expression_file, index_col=0)\n", + "meta = pd.read_csv(meta_file, index_col=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ADAMDEC1ACTA2TAGLNCCL11CCL13APOECXCL14CFDCCL8CCL2...CCDC23MEIS1AP001258.4FBXO42ASUNELP6CCDC77ELK3INO80EFHOD3
cell
N7.LPA.ATGTTCACATCGAC4.5913050.0000000.0000000.0000000.04.4023835.3820542.6198340.03.668685...0.00.00.00.00.00.00.00.0000001.6571770.0
N7.LPA.CATTAGCTGAGACG4.9041130.0000000.0000004.6945470.04.5706025.3831114.7511970.03.820224...0.00.00.00.00.00.00.01.9978910.0000000.0
N7.LPA.AAGGCTTGTGTAGC4.6003802.2203090.0000000.0000000.03.2437854.6003804.4200660.02.220309...0.00.00.00.00.00.00.00.0000000.0000000.0
N7.LPA.TATCAAGATGTGAC5.9000790.0000001.7453903.2043980.03.9704703.9704704.1346180.06.055687...0.00.00.00.00.00.00.00.0000000.0000000.0
N7.LPA.GAGTGGGAATGTGC5.4723131.7152181.7152185.2597390.03.6233564.8568684.2394300.03.169241...0.00.00.00.00.00.00.00.0000000.0000000.0
\n", + "

5 rows × 5494 columns

\n", + "
" + ], + "text/plain": [ + " ADAMDEC1 ACTA2 TAGLN CCL11 CCL13 \\\n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC 4.591305 0.000000 0.000000 0.000000 0.0 \n", + "N7.LPA.CATTAGCTGAGACG 4.904113 0.000000 0.000000 4.694547 0.0 \n", + "N7.LPA.AAGGCTTGTGTAGC 4.600380 2.220309 0.000000 0.000000 0.0 \n", + "N7.LPA.TATCAAGATGTGAC 5.900079 0.000000 1.745390 3.204398 0.0 \n", + "N7.LPA.GAGTGGGAATGTGC 5.472313 1.715218 1.715218 5.259739 0.0 \n", + "\n", + " APOE CXCL14 CFD CCL8 CCL2 ... \\\n", + "cell ... \n", + "N7.LPA.ATGTTCACATCGAC 4.402383 5.382054 2.619834 0.0 3.668685 ... \n", + "N7.LPA.CATTAGCTGAGACG 4.570602 5.383111 4.751197 0.0 3.820224 ... \n", + "N7.LPA.AAGGCTTGTGTAGC 3.243785 4.600380 4.420066 0.0 2.220309 ... \n", + "N7.LPA.TATCAAGATGTGAC 3.970470 3.970470 4.134618 0.0 6.055687 ... \n", + "N7.LPA.GAGTGGGAATGTGC 3.623356 4.856868 4.239430 0.0 3.169241 ... \n", + "\n", + " CCDC23 MEIS1 AP001258.4 FBXO42 ASUN ELP6 CCDC77 \\\n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "N7.LPA.CATTAGCTGAGACG 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "N7.LPA.AAGGCTTGTGTAGC 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "N7.LPA.TATCAAGATGTGAC 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "N7.LPA.GAGTGGGAATGTGC 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "\n", + " ELK3 INO80E FHOD3 \n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC 0.000000 1.657177 0.0 \n", + "N7.LPA.CATTAGCTGAGACG 1.997891 0.000000 0.0 \n", + "N7.LPA.AAGGCTTGTGTAGC 0.000000 0.000000 0.0 \n", + "N7.LPA.TATCAAGATGTGAC 0.000000 0.000000 0.0 \n", + "N7.LPA.GAGTGGGAATGTGC 0.000000 0.000000 0.0 \n", + "\n", + "[5 rows x 5494 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "expression_mat.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cell.1samplediseasecell_typeclusternGenenUMIpercent_mitofibroblast_clusters
cell
N7.LPA.ATGTTCACATCGACN7.LPA.ATGTTCACATCGACN7Non-inflamedLPWNT2B+ Fos-lo 1969.02357.00.031409WNT2B
N7.LPA.CATTAGCTGAGACGN7.LPA.CATTAGCTGAGACGN7Non-inflamedLPWNT2B+ Fos-hi681.01569.00.044614WNT2B
N7.LPA.AAGGCTTGTGTAGCN7.LPA.AAGGCTTGTGTAGCN7Non-inflamedLPWNT2B+ Fos-lo 2615.01218.00.013957WNT2B
N7.LPA.TATCAAGATGTGACN7.LPA.TATCAAGATGTGACN7Non-inflamedLPWNT2B+ Fos-hi841.02115.00.021749WNT2B
N7.LPA.GAGTGGGAATGTGCN7.LPA.GAGTGGGAATGTGCN7Non-inflamedLPWNT2B+ Fos-lo 1923.02194.00.019599WNT2B
\n", + "
" + ], + "text/plain": [ + " cell.1 sample disease cell_type \\\n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC N7.LPA.ATGTTCACATCGAC N7 Non-inflamed LP \n", + "N7.LPA.CATTAGCTGAGACG N7.LPA.CATTAGCTGAGACG N7 Non-inflamed LP \n", + "N7.LPA.AAGGCTTGTGTAGC N7.LPA.AAGGCTTGTGTAGC N7 Non-inflamed LP \n", + "N7.LPA.TATCAAGATGTGAC N7.LPA.TATCAAGATGTGAC N7 Non-inflamed LP \n", + "N7.LPA.GAGTGGGAATGTGC N7.LPA.GAGTGGGAATGTGC N7 Non-inflamed LP \n", + "\n", + " cluster nGene nUMI percent_mito \\\n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC WNT2B+ Fos-lo 1 969.0 2357.0 0.031409 \n", + "N7.LPA.CATTAGCTGAGACG WNT2B+ Fos-hi 681.0 1569.0 0.044614 \n", + "N7.LPA.AAGGCTTGTGTAGC WNT2B+ Fos-lo 2 615.0 1218.0 0.013957 \n", + "N7.LPA.TATCAAGATGTGAC WNT2B+ Fos-hi 841.0 2115.0 0.021749 \n", + "N7.LPA.GAGTGGGAATGTGC WNT2B+ Fos-lo 1 923.0 2194.0 0.019599 \n", + "\n", + " fibroblast_clusters \n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC WNT2B \n", + "N7.LPA.CATTAGCTGAGACG WNT2B \n", + "N7.LPA.AAGGCTTGTGTAGC WNT2B \n", + "N7.LPA.TATCAAGATGTGAC WNT2B \n", + "N7.LPA.GAGTGGGAATGTGC WNT2B " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meta.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 2: Preprocess Data\n", + "generate latent dimensions configure input for CellPhenoX (include covariates and identify target column)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "## we actually need both the neighborhood abundance matrix (for CellPhenoX) & expression data (for the marker discovery later)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/zhanglab_mac2/Library/CloudStorage/OneDrive-TheUniversityofColoradoDenver/Zhang_Lab/Research/shap/.conda/lib/python3.11/site-packages/sklearn/decomposition/_nmf.py:1710: ConvergenceWarning: Maximum number of iterations 200 reached. Increase it to improve convergence.\n" + ] + } + ], + "source": [ + "# get the latent dimensions using NMF\n", + "latent_features, _ = nonnegativeMatrixFactorization(expression_mat, numberOfComponents=4, min_k=3, max_k=5) # the \"_\"\" is the nmf model components which we don't need here" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# alternatively, use PCA\n", + "# proportion_var_explained = 0.9\n", + "# latent_features = principalComponentAnalysis(expression_mat, var=proportion_var_explained)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0123
cell
N7.LPA.ATGTTCACATCGAC0.2853340.1205890.4589740.205040
N7.LPA.CATTAGCTGAGACG0.2391240.0000000.5874350.094555
N7.LPA.AAGGCTTGTGTAGC0.2552120.0000000.4629120.226226
N7.LPA.TATCAAGATGTGAC0.3409510.0000000.3475800.300781
N7.LPA.GAGTGGGAATGTGC0.2311400.1757430.4207130.348904
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3\n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC 0.285334 0.120589 0.458974 0.205040\n", + "N7.LPA.CATTAGCTGAGACG 0.239124 0.000000 0.587435 0.094555\n", + "N7.LPA.AAGGCTTGTGTAGC 0.255212 0.000000 0.462912 0.226226\n", + "N7.LPA.TATCAAGATGTGAC 0.340951 0.000000 0.347580 0.300781\n", + "N7.LPA.GAGTGGGAATGTGC 0.231140 0.175743 0.420713 0.348904" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# then, set up the input data for CellPhenoX\n", + "X,y = preprocessing(latent_features, meta, sub_samp=False, subset_percentage=0.25 , target=\"disease\", covariates=[])\n", + "X.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3698, 4)\n", + "(3698,)\n" + ] + } + ], + "source": [ + "print(X.shape)\n", + "print(y.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3: Run CellPhenoX" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "entering CV loop\n", + "\n", + "------------ CV Repeat number: 1\n", + "\n", + "------ Fold Number: 1\n", + "--- Accuracy: 0.7023519870235199\n", + "1\n", + "--- Validation Accuracy: 0.8275862068965517 - Validation AUROC: 0.8185670261941448 - Val AUPRC: 0.9549581934555448\n", + "\n", + "------ Fold Number: 2\n", + "--- Accuracy: 0.7055961070559611\n", + "2\n", + "--- Validation Accuracy: 0.9006085192697769 - Validation AUROC: 0.892869371682931 - Val AUPRC: 0.9770399352399095\n", + "\n", + "------ Fold Number: 3\n", + "--- Accuracy: 0.6801948051948052\n", + "3\n", + "--- Validation Accuracy: 0.8765182186234818 - Validation AUROC: 0.8679925048973682 - Val AUPRC: 0.9707836787744281\n", + "Average AUROC: 0.8598096342581479 | Average AUPRC: 0.9675939358232942\n", + "best model precision-recall score = 0.9770\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/zhanglab_mac2/Library/CloudStorage/OneDrive-TheUniversityofColoradoDenver/Zhang_Lab/Research/shap/.conda/lib/python3.11/site-packages/shap/plots/_beeswarm.py:699: UserWarning: No data for colormapping provided via 'c'. Parameters 'vmin', 'vmax' will be ignored\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# create CellPhenoX object \n", + "cellpx_obj = CellPhenoX(X, y, CV_repeats=1, outer_num_splits=3, inner_num_splits=2)\n", + "# and then train the classification model\n", + "cellpx_obj.model_training_shap_val(outpath = output_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0_shap1_shap2_shap3_shapinterpretable_score
cell
N7.LPA.ATGTTCACATCGAC0.019978-0.0075820.1297630.0171640.159322
N7.LPA.CATTAGCTGAGACG0.0183790.0199890.2340100.1303040.402682
N7.LPA.AAGGCTTGTGTAGC0.0522780.0376040.184861-0.0049390.269803
N7.LPA.TATCAAGATGTGAC0.0136740.0562030.068779-0.1024630.036193
N7.LPA.GAGTGGGAATGTGC-0.0170150.016166-0.011645-0.110724-0.123219
..................
N110.LPB.CCAGCGATCCTCCTAG-0.025661-0.084043-0.0279670.075934-0.061737
N110.LPB.CGAATGTAGACTAGGC0.0474680.0044430.219336-0.0488410.222407
N110.LPB.TCAACGACAATCCAAC0.0760380.0830480.0011840.0367290.196999
N110.LPB.CTGATAGAGCATGGCA-0.0145260.030951-0.0087960.1988060.206434
N110.LPB.CTTCTCTCATCGGTTA0.0124890.0249170.0122300.2624110.312047
\n", + "

3698 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " 0_shap 1_shap 2_shap 3_shap \\\n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC 0.019978 -0.007582 0.129763 0.017164 \n", + "N7.LPA.CATTAGCTGAGACG 0.018379 0.019989 0.234010 0.130304 \n", + "N7.LPA.AAGGCTTGTGTAGC 0.052278 0.037604 0.184861 -0.004939 \n", + "N7.LPA.TATCAAGATGTGAC 0.013674 0.056203 0.068779 -0.102463 \n", + "N7.LPA.GAGTGGGAATGTGC -0.017015 0.016166 -0.011645 -0.110724 \n", + "... ... ... ... ... \n", + "N110.LPB.CCAGCGATCCTCCTAG -0.025661 -0.084043 -0.027967 0.075934 \n", + "N110.LPB.CGAATGTAGACTAGGC 0.047468 0.004443 0.219336 -0.048841 \n", + "N110.LPB.TCAACGACAATCCAAC 0.076038 0.083048 0.001184 0.036729 \n", + "N110.LPB.CTGATAGAGCATGGCA -0.014526 0.030951 -0.008796 0.198806 \n", + "N110.LPB.CTTCTCTCATCGGTTA 0.012489 0.024917 0.012230 0.262411 \n", + "\n", + " interpretable_score \n", + "cell \n", + "N7.LPA.ATGTTCACATCGAC 0.159322 \n", + "N7.LPA.CATTAGCTGAGACG 0.402682 \n", + "N7.LPA.AAGGCTTGTGTAGC 0.269803 \n", + "N7.LPA.TATCAAGATGTGAC 0.036193 \n", + "N7.LPA.GAGTGGGAATGTGC -0.123219 \n", + "... ... \n", + "N110.LPB.CCAGCGATCCTCCTAG -0.061737 \n", + "N110.LPB.CGAATGTAGACTAGGC 0.222407 \n", + "N110.LPB.TCAACGACAATCCAAC 0.196999 \n", + "N110.LPB.CTGATAGAGCATGGCA 0.206434 \n", + "N110.LPB.CTTCTCTCATCGGTTA 0.312047 \n", + "\n", + "[3698 rows x 5 columns]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cellpx_obj.shap_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Marker Discovery\n", + "identify markers correlated with the Interpretable Score" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fitting model\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/zhanglab_mac2/Library/CloudStorage/OneDrive-TheUniversityofColoradoDenver/Zhang_Lab/Research/shap/.conda/lib/python3.11/site-packages/statsmodels/regression/linear_model.py:1794: RuntimeWarning: divide by zero encountered in divide\n", + "/Users/zhanglab_mac2/Library/CloudStorage/OneDrive-TheUniversityofColoradoDenver/Zhang_Lab/Research/shap/.conda/lib/python3.11/site-packages/statsmodels/regression/linear_model.py:1794: RuntimeWarning: invalid value encountered in scalar multiply\n", + "/Users/zhanglab_mac2/Library/CloudStorage/OneDrive-TheUniversityofColoradoDenver/Zhang_Lab/Research/shap/.conda/lib/python3.11/site-packages/statsmodels/regression/linear_model.py:1716: RuntimeWarning: divide by zero encountered in scalar divide\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "results sorted by p vlaue: \n", + " Beta P_Value Adjusted_P_Value gene\n", + "const 0.007220 NaN NaN const\n", + "ADAMDEC1 0.009512 NaN NaN ADAMDEC1\n", + "ACTA2 -0.004977 NaN NaN ACTA2\n", + "TAGLN 0.002539 NaN NaN TAGLN\n", + "CCL11 -0.005101 NaN NaN CCL11\n", + "Significant Markers\n", + "Empty DataFrame\n", + "Columns: [Beta, P_Value, Adjusted_P_Value, gene]\n", + "Index: []\n" + ] + } + ], + "source": [ + "marker_discovery(cellpx_obj.shap_df, expression_mat)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.6" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/build/_static/basic.css b/build/_static/basic.css index f316efc..7ebbd6d 100644 --- a/build/_static/basic.css +++ b/build/_static/basic.css @@ -1,12 +1,5 @@ /* - * basic.css - * ~~~~~~~~~ - * * Sphinx stylesheet -- basic theme. - * - * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. - * :license: BSD, see LICENSE for details. - * */ /* -- main layout ----------------------------------------------------------- */ @@ -115,15 +108,11 @@ img { /* -- search page ----------------------------------------------------------- */ ul.search { - margin: 10px 0 0 20px; - padding: 0; + margin-top: 10px; } ul.search li { - padding: 5px 0 5px 20px; - background-image: url(file.png); - background-repeat: no-repeat; - background-position: 0 7px; + padding: 5px 0; } ul.search li a { diff --git a/build/_static/classic.css b/build/_static/classic.css new file mode 100644 index 0000000..5530147 --- /dev/null +++ b/build/_static/classic.css @@ -0,0 +1,269 @@ +/* + * classic.css_t + * ~~~~~~~~~~~~~ + * + * Sphinx stylesheet -- classic theme. + * + * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +@import url("basic.css"); + +/* -- page layout ----------------------------------------------------------- */ + +html { + /* CSS hack for macOS's scrollbar (see #1125) */ + background-color: #FFFFFF; +} + +body { + font-family: sans-serif; + font-size: 100%; + background-color: #11303d; + color: #000; + margin: 0; + padding: 0; +} + +div.document { + display: flex; + background-color: #1c4e63; +} + +div.documentwrapper { + float: left; + width: 100%; +} + +div.bodywrapper { + margin: 0 0 0 230px; +} + +div.body { + background-color: #ffffff; + color: #000000; + padding: 0 20px 30px 20px; +} + +div.footer { + color: #ffffff; + width: 100%; + padding: 9px 0 9px 0; + text-align: center; + font-size: 75%; +} + +div.footer a { + color: #ffffff; + text-decoration: underline; +} + +div.related { + background-color: #133f52; + line-height: 30px; + color: #ffffff; +} + +div.related a { + color: #ffffff; +} + +div.sphinxsidebar { +} + +div.sphinxsidebar h3 { + font-family: 'Trebuchet MS', sans-serif; + color: #ffffff; + font-size: 1.4em; + font-weight: normal; + margin: 0; + padding: 0; +} + +div.sphinxsidebar h3 a { + color: #ffffff; +} + +div.sphinxsidebar h4 { + font-family: 'Trebuchet MS', sans-serif; + color: #ffffff; + font-size: 1.3em; + font-weight: normal; + margin: 5px 0 0 0; + padding: 0; +} + +div.sphinxsidebar p { + color: #ffffff; +} + +div.sphinxsidebar p.topless { + margin: 5px 10px 10px 10px; +} + +div.sphinxsidebar ul { + margin: 10px; + padding: 0; + color: #ffffff; +} + +div.sphinxsidebar a { + color: #98dbcc; +} + +div.sphinxsidebar input { + border: 1px solid #98dbcc; + font-family: sans-serif; + font-size: 1em; +} + + + +/* -- hyperlink styles ------------------------------------------------------ */ + +a { + color: #355f7c; + text-decoration: none; +} + +a:visited { + color: #551a8b; + text-decoration: none; +} + +a:hover { + text-decoration: underline; +} + + + +/* -- body styles ----------------------------------------------------------- */ + +div.body h1, +div.body h2, +div.body h3, +div.body h4, +div.body h5, +div.body h6 { + font-family: 'Trebuchet MS', sans-serif; + background-color: #f2f2f2; + font-weight: normal; + color: #20435c; + border-bottom: 1px solid #ccc; + margin: 20px -20px 10px -20px; + padding: 3px 0 3px 10px; +} + +div.body h1 { margin-top: 0; font-size: 200%; } +div.body h2 { font-size: 160%; } +div.body h3 { font-size: 140%; } +div.body h4 { font-size: 120%; } +div.body h5 { font-size: 110%; } +div.body h6 { font-size: 100%; } + +a.headerlink { + color: #c60f0f; + font-size: 0.8em; + padding: 0 4px 0 4px; + text-decoration: none; +} + +a.headerlink:hover { + background-color: #c60f0f; + color: white; +} + +div.body p, div.body dd, div.body li, div.body blockquote { + text-align: justify; + line-height: 130%; +} + +div.admonition p.admonition-title + p { + display: inline; +} + +div.admonition p { + margin-bottom: 5px; +} + +div.admonition pre { + margin-bottom: 5px; +} + +div.admonition ul, div.admonition ol { + margin-bottom: 5px; +} + +div.note { + background-color: #eee; + border: 1px solid #ccc; +} + +div.seealso { + background-color: #ffc; + border: 1px solid #ff6; +} + +nav.contents, +aside.topic, +div.topic { + background-color: #eee; +} + +div.warning { + background-color: #ffe4e4; + border: 1px solid #f66; +} + +p.admonition-title { + display: inline; +} + +p.admonition-title:after { + content: ":"; +} + +pre { + padding: 5px; + background-color: unset; + color: unset; + line-height: 120%; + border: 1px solid #ac9; + border-left: none; + border-right: none; +} + +code { + background-color: #ecf0f3; + padding: 0 1px 0 1px; + font-size: 0.95em; +} + +th, dl.field-list > dt { + background-color: #ede; +} + +.warning code { + background: #efc2c2; +} + +.note code { + background: #d6d6d6; +} + +.viewcode-back { + font-family: sans-serif; +} + +div.viewcode-block:target { + background-color: #f4debf; + border-top: 1px solid #ac9; + border-bottom: 1px solid #ac9; +} + +div.code-block-caption { + color: #efefef; + background-color: #1c4e63; +} \ No newline at end of file diff --git a/build/_static/default.css b/build/_static/default.css new file mode 100644 index 0000000..81b9363 --- /dev/null +++ b/build/_static/default.css @@ -0,0 +1 @@ +@import url("classic.css"); diff --git a/build/_static/doctools.js b/build/_static/doctools.js index 4d67807..0398ebb 100644 --- a/build/_static/doctools.js +++ b/build/_static/doctools.js @@ -1,12 +1,5 @@ /* - * doctools.js - * ~~~~~~~~~~~ - * * Base JavaScript utilities for all Sphinx HTML documentation. - * - * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. - * :license: BSD, see LICENSE for details. - * */ "use strict"; diff --git a/build/_static/documentation_options.js b/build/_static/documentation_options.js index b16db03..7254ddd 100644 --- a/build/_static/documentation_options.js +++ b/build/_static/documentation_options.js @@ -1,5 +1,5 @@ const DOCUMENTATION_OPTIONS = { - VERSION: '0.2.0', + VERSION: '0.3.0', LANGUAGE: 'en', COLLAPSE_INDEX: false, BUILDER: 'html', diff --git a/build/_static/language_data.js b/build/_static/language_data.js index 367b8ed..c7fe6c6 100644 --- a/build/_static/language_data.js +++ b/build/_static/language_data.js @@ -1,13 +1,6 @@ /* - * language_data.js - * ~~~~~~~~~~~~~~~~ - * * This script contains the language-specific data used by searchtools.js, * namely the list of stopwords, stemmer, scorer and splitter. - * - * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. - * :license: BSD, see LICENSE for details. - * */ var stopwords = ["a", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "near", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with"]; diff --git a/build/_static/nature.css b/build/_static/nature.css new file mode 100644 index 0000000..e26d936 --- /dev/null +++ b/build/_static/nature.css @@ -0,0 +1,245 @@ +/* + * Sphinx stylesheet -- nature theme. + */ + +@import url("basic.css"); + +/* -- page layout ----------------------------------------------------------- */ + +body { + font-family: Arial, sans-serif; + font-size: 100%; + background-color: #fff; + color: #555; + margin: 0; + padding: 0; +} + +div.documentwrapper { + float: left; + width: 100%; +} + +div.bodywrapper { + margin: 0 0 0 230px; +} + +hr { + border: 1px solid #B1B4B6; +} + +div.document { + background-color: #eee; +} + +div.body { + background-color: #ffffff; + color: #3E4349; + padding: 0 30px 30px 30px; + font-size: 0.9em; +} + +div.footer { + color: #555; + width: 100%; + padding: 13px 0; + text-align: center; + font-size: 75%; +} + +div.footer a { + color: #444; + text-decoration: underline; +} + +div.related { + background-color: #6BA81E; + line-height: 32px; + color: #fff; + text-shadow: 0px 1px 0 #444; + font-size: 0.9em; +} + +div.related a { + color: #E2F3CC; +} + +div.sphinxsidebar { + font-size: 0.75em; + line-height: 1.5em; +} + +div.sphinxsidebarwrapper{ + padding: 20px 0; +} + +div.sphinxsidebar h3, +div.sphinxsidebar h4 { + font-family: Arial, sans-serif; + color: #222; + font-size: 1.2em; + font-weight: normal; + margin: 0; + padding: 5px 10px; + background-color: #ddd; + text-shadow: 1px 1px 0 white +} + +div.sphinxsidebar h4{ + font-size: 1.1em; +} + +div.sphinxsidebar h3 a { + color: #444; +} + + +div.sphinxsidebar p { + color: #888; + padding: 5px 20px; +} + +div.sphinxsidebar p.topless { +} + +div.sphinxsidebar ul { + margin: 10px 20px; + padding: 0; + color: #000; +} + +div.sphinxsidebar a { + color: #444; +} + +div.sphinxsidebar input { + border: 1px solid #ccc; + font-family: sans-serif; + font-size: 1em; +} + +div.sphinxsidebar .searchformwrapper { + margin-left: 20px; + margin-right: 20px; +} + +/* -- body styles ----------------------------------------------------------- */ + +a { + color: #005B81; + text-decoration: none; +} + +a:hover { + color: #E32E00; + text-decoration: underline; +} + +a:visited { + color: #551A8B; +} + +div.body h1, +div.body h2, +div.body h3, +div.body h4, +div.body h5, +div.body h6 { + font-family: Arial, sans-serif; + background-color: #BED4EB; + font-weight: normal; + color: #212224; + margin: 30px 0px 10px 0px; + padding: 5px 0 5px 10px; + text-shadow: 0px 1px 0 white +} + +div.body h1 { border-top: 20px solid white; margin-top: 0; font-size: 200%; } +div.body h2 { font-size: 150%; background-color: #C8D5E3; } +div.body h3 { font-size: 120%; background-color: #D8DEE3; } +div.body h4 { font-size: 110%; background-color: #D8DEE3; } +div.body h5 { font-size: 100%; background-color: #D8DEE3; } +div.body h6 { font-size: 100%; background-color: #D8DEE3; } + +a.headerlink { + color: #c60f0f; + font-size: 0.8em; + padding: 0 4px 0 4px; + text-decoration: none; +} + +a.headerlink:hover { + background-color: #c60f0f; + color: white; +} + +div.body p, div.body dd, div.body li { + line-height: 1.5em; +} + +div.admonition p.admonition-title + p { + display: inline; +} + +div.note { + background-color: #eee; + border: 1px solid #ccc; +} + +div.seealso { + background-color: #ffc; + border: 1px solid #ff6; +} + +nav.contents, +aside.topic, +div.topic { + background-color: #eee; +} + +div.warning { + background-color: #ffe4e4; + border: 1px solid #f66; +} + +p.admonition-title { + display: inline; +} + +p.admonition-title:after { + content: ":"; +} + +pre { + padding: 10px; + line-height: 1.2em; + border: 1px solid #C6C9CB; + font-size: 1.1em; + margin: 1.5em 0 1.5em 0; + -webkit-box-shadow: 1px 1px 1px #d8d8d8; + -moz-box-shadow: 1px 1px 1px #d8d8d8; +} + +code { + background-color: #ecf0f3; + color: #222; + /* padding: 1px 2px; */ + font-size: 1.1em; + font-family: monospace; +} + +.viewcode-back { + font-family: Arial, sans-serif; +} + +div.viewcode-block:target { + background-color: #f4debf; + border-top: 1px solid #ac9; + border-bottom: 1px solid #ac9; +} + +div.code-block-caption { + background-color: #ddd; + color: #222; + border: 1px solid #C6C9CB; +} \ No newline at end of file diff --git a/build/_static/searchtools.js b/build/_static/searchtools.js index b08d58c..2c774d1 100644 --- a/build/_static/searchtools.js +++ b/build/_static/searchtools.js @@ -1,12 +1,5 @@ /* - * searchtools.js - * ~~~~~~~~~~~~~~~~ - * * Sphinx JavaScript utilities for the full-text search. - * - * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. - * :license: BSD, see LICENSE for details. - * */ "use strict"; @@ -20,7 +13,7 @@ if (typeof Scorer === "undefined") { // and returns the new score. /* score: result => { - const [docname, title, anchor, descr, score, filename] = result + const [docname, title, anchor, descr, score, filename, kind] = result return score }, */ @@ -47,6 +40,14 @@ if (typeof Scorer === "undefined") { }; } +// Global search result kind enum, used by themes to style search results. +class SearchResultKind { + static get index() { return "index"; } + static get object() { return "object"; } + static get text() { return "text"; } + static get title() { return "title"; } +} + const _removeChildren = (element) => { while (element && element.lastChild) element.removeChild(element.lastChild); }; @@ -64,9 +65,13 @@ const _displayItem = (item, searchTerms, highlightTerms) => { const showSearchSummary = DOCUMENTATION_OPTIONS.SHOW_SEARCH_SUMMARY; const contentRoot = document.documentElement.dataset.content_root; - const [docName, title, anchor, descr, score, _filename] = item; + const [docName, title, anchor, descr, score, _filename, kind] = item; let listItem = document.createElement("li"); + // Add a class representing the item's type: + // can be used by a theme's CSS selector for styling + // See SearchResultKind for the class names. + listItem.classList.add(`kind-${kind}`); let requestUrl; let linkUrl; if (docBuilder === "dirhtml") { @@ -115,8 +120,10 @@ const _finishSearch = (resultCount) => { "Your search did not match any documents. Please make sure that all words are spelled correctly and that you've selected enough categories." ); else - Search.status.innerText = _( - "Search finished, found ${resultCount} page(s) matching the search query." + Search.status.innerText = Documentation.ngettext( + "Search finished, found one page matching the search query.", + "Search finished, found ${resultCount} pages matching the search query.", + resultCount, ).replace('${resultCount}', resultCount); }; const _displayNextItem = ( @@ -138,7 +145,7 @@ const _displayNextItem = ( else _finishSearch(resultCount); }; // Helper function used by query() to order search results. -// Each input is an array of [docname, title, anchor, descr, score, filename]. +// Each input is an array of [docname, title, anchor, descr, score, filename, kind]. // Order the results by score (in opposite order of appearance, since the // `_displayNextItem` function uses pop() to retrieve items) and then alphabetically. const _orderResultsByScoreThenName = (a, b) => { @@ -248,6 +255,7 @@ const Search = { searchSummary.classList.add("search-summary"); searchSummary.innerText = ""; const searchList = document.createElement("ul"); + searchList.setAttribute("role", "list"); searchList.classList.add("search"); const out = document.getElementById("search-results"); @@ -318,7 +326,7 @@ const Search = { const indexEntries = Search._index.indexentries; // Collect multiple result groups to be sorted separately and then ordered. - // Each is an array of [docname, title, anchor, descr, score, filename]. + // Each is an array of [docname, title, anchor, descr, score, filename, kind]. const normalResults = []; const nonMainIndexResults = []; @@ -337,6 +345,7 @@ const Search = { null, score + boost, filenames[file], + SearchResultKind.title, ]); } } @@ -354,6 +363,7 @@ const Search = { null, score, filenames[file], + SearchResultKind.index, ]; if (isMain) { normalResults.push(result); @@ -475,6 +485,7 @@ const Search = { descr, score, filenames[match[0]], + SearchResultKind.object, ]); }; Object.keys(objects).forEach((prefix) => @@ -585,6 +596,7 @@ const Search = { null, score, filenames[file], + SearchResultKind.text, ]); } return results; diff --git a/build/_static/sidebar.js b/build/_static/sidebar.js new file mode 100644 index 0000000..f28c206 --- /dev/null +++ b/build/_static/sidebar.js @@ -0,0 +1,70 @@ +/* + * sidebar.js + * ~~~~~~~~~~ + * + * This script makes the Sphinx sidebar collapsible. + * + * .sphinxsidebar contains .sphinxsidebarwrapper. This script adds + * in .sphixsidebar, after .sphinxsidebarwrapper, the #sidebarbutton + * used to collapse and expand the sidebar. + * + * When the sidebar is collapsed the .sphinxsidebarwrapper is hidden + * and the width of the sidebar and the margin-left of the document + * are decreased. When the sidebar is expanded the opposite happens. + * This script saves a per-browser/per-session cookie used to + * remember the position of the sidebar among the pages. + * Once the browser is closed the cookie is deleted and the position + * reset to the default (expanded). + * + * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +const initialiseSidebar = () => { + + + + + // global elements used by the functions. + const bodyWrapper = document.getElementsByClassName("bodywrapper")[0] + const sidebar = document.getElementsByClassName("sphinxsidebar")[0] + const sidebarWrapper = document.getElementsByClassName('sphinxsidebarwrapper')[0] + const sidebarButton = document.getElementById("sidebarbutton") + const sidebarArrow = sidebarButton.querySelector('span') + + // for some reason, the document has no sidebar; do not run into errors + if (typeof sidebar === "undefined") return; + + const flipArrow = element => element.innerText = (element.innerText === "»") ? "«" : "»" + + const collapse_sidebar = () => { + bodyWrapper.style.marginLeft = ".8em"; + sidebar.style.width = ".8em" + sidebarWrapper.style.display = "none" + flipArrow(sidebarArrow) + sidebarButton.title = _('Expand sidebar') + window.localStorage.setItem("sidebar", "collapsed") + } + + const expand_sidebar = () => { + bodyWrapper.style.marginLeft = "" + sidebar.style.removeProperty("width") + sidebarWrapper.style.display = "" + flipArrow(sidebarArrow) + sidebarButton.title = _('Collapse sidebar') + window.localStorage.setItem("sidebar", "expanded") + } + + sidebarButton.addEventListener("click", () => { + (sidebarWrapper.style.display === "none") ? expand_sidebar() : collapse_sidebar() + }) + + if (!window.localStorage.getItem("sidebar")) return + const value = window.localStorage.getItem("sidebar") + if (value === "collapsed") collapse_sidebar(); + else if (value === "expanded") expand_sidebar(); +} + +if (document.readyState !== "loading") initialiseSidebar() +else document.addEventListener("DOMContentLoaded", initialiseSidebar) \ No newline at end of file diff --git a/build/_static/traditional.css b/build/_static/traditional.css new file mode 100644 index 0000000..ca977f5 --- /dev/null +++ b/build/_static/traditional.css @@ -0,0 +1,765 @@ +/* + * traditional.css + * ~~~~~~~~~~~~~~~ + * + * Sphinx stylesheet -- traditional docs.python.org theme. + * + * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +body { + color: #000; + margin: 0; + padding: 0; +} + +/* :::: LAYOUT :::: */ + +div.documentwrapper { + float: left; + width: 100%; +} + +div.bodywrapper { + margin: 0 230px 0 0; +} + +div.body { + min-width: 0; + max-width: none; + background-color: white; + padding: 0 20px 30px 20px; +} + +div.sphinxsidebarwrapper { + border: 1px solid #99ccff; + padding: 10px; + margin: 10px 15px 10px 0; +} + +div.sphinxsidebar { + float: right; + margin-left: -100%; + width: 230px; +} + +div.clearer { + clear: both; +} + +div.footer { + clear: both; + width: 100%; + background-color: #99ccff; + padding: 9px 0 9px 0; + text-align: center; +} + +div.related { + background-color: #99ccff; + color: #333; + width: 100%; + height: 30px; + line-height: 30px; + border-bottom: 5px solid white; +} + +div.related h3 { + display: none; +} + +div.related ul { + margin: 0; + padding: 0 0 0 10px; + list-style: none; +} + +div.related li { + display: inline; + font-weight: bold; +} + +div.related li.right { + float: right; + margin-right: 5px; +} + +/* ::: SIDEBAR :::: */ +div.sphinxsidebar h3 { + margin: 0; +} + +div.sphinxsidebar h4 { + margin: 5px 0 0 0; +} + +div.sphinxsidebar p.topless { + margin: 5px 10px 10px 10px; +} + +div.sphinxsidebar ul { + margin: 10px; + margin-left: 15px; + padding: 0; +} + +div.sphinxsidebar ul ul { + margin-top: 0; + margin-bottom: 0; +} + +div.sphinxsidebar form { + margin-top: 10px; +} + + +/* :::: SEARCH :::: */ +ul.search { + margin: 10px 0 0 20px; + padding: 0; +} + +ul.search li { + padding: 5px 0 5px 20px; + background-image: url(file.png); + background-repeat: no-repeat; + background-position: 0 7px; +} + +ul.search li a { + font-weight: bold; +} + +ul.search li div.context { + color: #888; + margin: 2px 0 0 30px; + text-align: left; +} + +ul.keywordmatches li.goodmatch a { + font-weight: bold; +} + +/* :::: COMMON FORM STYLES :::: */ + +div.actions { + border-top: 1px solid #aaa; + background-color: #ddd; + margin: 10px 0 0 -20px; + padding: 5px 0 5px 20px; +} + +form dl { + color: #333; +} + +form dt { + clear: both; + float: left; + min-width: 110px; + margin-right: 10px; + padding-top: 2px; +} + +input#homepage { + display: none; +} + +div.error { + margin: 5px 20px 0 0; + padding: 5px; + border: 1px solid #d00; + /*border: 2px solid #05171e; + background-color: #092835; + color: white;*/ + font-weight: bold; +} + +/* :::: INLINE COMMENTS :::: */ + +div.inlinecommentswrapper { + float: right; + max-width: 40%; +} + +div.commentmarker { + float: right; + background-image: url(style/comment.png); + background-repeat: no-repeat; + width: 25px; + height: 25px; + text-align: center; + padding-top: 3px; +} + +div.nocommentmarker { + float: right; + background-image: url(style/nocomment.png); + background-repeat: no-repeat; + width: 25px; + height: 25px; +} + +div.inlinecomments { + margin-left: 10px; + margin-bottom: 5px; + background-color: #eee; + border: 1px solid #ccc; + padding: 5px; +} + +div.inlinecomment { + border-top: 1px solid #ccc; + padding-top: 5px; + margin-top: 5px; +} + +.inlinecomments p { + margin: 5px 0 5px 0; +} + +.inlinecomments .head { + font-weight: bold; +} + +.inlinecomments .meta { + font-style: italic; +} + + +/* :::: COMMENTS :::: */ + +div#comments h3 { + border-top: 1px solid #aaa; + padding: 5px 20px 5px 20px; + margin: 20px -20px 20px -20px; + background-color: #ddd; +} + +/* +div#comments { + background-color: #ccc; + margin: 40px -20px -30px -20px; + padding: 0 0 1px 0; +} + +div#comments h4 { + margin: 30px 0 20px 0; + background-color: #aaa; + border-bottom: 1px solid #09232e; + color: #333; +} + +div#comments form { + display: block; + margin: 0 0 0 20px; +} + +div#comments textarea { + width: 98%; + height: 160px; +} + +div#comments div.help { + margin: 20px 20px 10px 0; + background-color: #ccc; + color: #333; +} + +div#comments div.help p { + margin: 0; + padding: 0 0 10px 0; +} + +div#comments input, div#comments textarea { + font-family: 'Bitstream Vera Sans', 'Arial', sans-serif; + font-size: 13px; + color: black; + background-color: #aaa; + border: 1px solid #092835; +} + +div#comments input[type="reset"], +div#comments input[type="submit"] { + cursor: pointer; + font-weight: bold; + padding: 2px; + margin: 5px 5px 5px 0; + background-color: #666; + color: white; +} + +div#comments div.comment { + margin: 10px 10px 10px 20px; + padding: 10px; + border: 1px solid #0f3646; + background-color: #aaa; + color: #333; +} + +div#comments div.comment p { + margin: 5px 0 5px 0; +} + +div#comments div.comment p.meta { + font-style: italic; + color: #444; + text-align: right; + margin: -5px 0 -5px 0; +} + +div#comments div.comment h4 { + margin: -10px -10px 5px -10px; + padding: 3px; + font-size: 15px; + background-color: #888; + color: white; + border: 0; +} + +div#comments div.comment pre, +div#comments div.comment code { + background-color: #ddd; + color: #111; + border: none; +} + +div#comments div.comment a { + color: #fff; + text-decoration: underline; +} + +div#comments div.comment blockquote { + margin: 10px; + padding: 10px; + border-left: 1px solid #0f3646; + /*border: 1px solid #0f3646; + background-color: #071c25;*/ +} + +div#comments em.important { + color: #d00; + font-weight: bold; + font-style: normal; +}*/ + +/* :::: SUGGEST CHANGES :::: */ +div#suggest-changes-box input, div#suggest-changes-box textarea { + border: 1px solid #ccc; + background-color: white; + color: black; +} + +div#suggest-changes-box textarea { + width: 99%; + height: 400px; +} + + +/* :::: PREVIEW :::: */ +div.preview { + background-image: url(style/preview.png); + padding: 0 20px 20px 20px; + margin-bottom: 30px; +} + + +/* :::: INDEX PAGE :::: */ + +table.contentstable { + width: 90%; +} + +table.contentstable p.biglink { + line-height: 150%; +} + +a.biglink { + font-size: 1.5em; +} + +span.linkdescr { + font-style: italic; + padding-top: 5px; +} + +/* :::: GENINDEX STYLES :::: */ + +table.indextable td { + text-align: left; + vertical-align: top; +} + +table.indextable ul { + margin-top: 0; + margin-bottom: 0; + list-style-type: none; +} + +table.indextable > tbody > tr > td > ul { + padding-left: 0em; +} + +table.indextable tr.pcap { + height: 10px; +} + +table.indextable tr.cap { + margin-top: 10px; + background-color: #f2f2f2; +} + +img.toggler { + margin-right: 3px; + margin-top: 3px; + cursor: pointer; +} + +/* :::: DOMAIN MODULE INDEX STYLES :::: */ + +table.modindextable td { + padding: 2px; + border-collapse: collapse; +} + +/* :::: GLOBAL STYLES :::: */ + +p.subhead { + font-weight: bold; + margin-top: 20px; +} + +a:link:active { color: #ff0000; } +a:link:hover { background-color: #bbeeff; } +a:visited:hover { background-color: #bbeeff; } +a:visited { color: #551a8b; } +a:link { color: #0000bb; } + +div.body h1, +div.body h2, +div.body h3, +div.body h4, +div.body h5, +div.body h6 { + font-family: avantgarde, sans-serif; + font-weight: bold; +} + +div.body h1 { font-size: 180%; } +div.body h2 { font-size: 150%; } +div.body h3 { font-size: 120%; } +div.body h4 { font-size: 120%; } + +a.headerlink, +a.headerlink, +a.headerlink, +a.headerlink, +a.headerlink, +a.headerlink { + color: #c60f0f; + font-size: 0.8em; + padding: 0 4px 0 4px; + text-decoration: none; + visibility: hidden; +} + +*:hover > a.headerlink, +*:hover > a.headerlink, +*:hover > a.headerlink, +*:hover > a.headerlink, +*:hover > a.headerlink, +*:hover > a.headerlink { + visibility: visible; +} + +a.headerlink:hover, +a.headerlink:hover, +a.headerlink:hover, +a.headerlink:hover, +a.headerlink:hover, +a.headerlink:hover { + background-color: #c60f0f; + color: white; +} + +div.body p, div.body dd, div.body li { + text-align: justify; +} + +div.body td { + text-align: left; +} + +ul.fakelist { + list-style: none; + margin: 10px 0 10px 20px; + padding: 0; +} + +/* "Footnotes" heading */ +p.rubric { + margin-top: 30px; + font-weight: bold; +} + +/* "Topics" */ + +nav.contents, +aside.topic, +div.topic { + background-color: #eee; + border: 1px solid #ccc; + padding: 0 7px 0 7px; + margin: 10px 0 10px 0; +} + +p.topic-title { + font-size: 1.1em; + font-weight: bold; + margin-top: 10px; +} + +/* Admonitions */ + +div.admonition { + margin-top: 10px; + margin-bottom: 10px; + padding: 7px; +} + +div.admonition dt { + font-weight: bold; +} + +div.admonition dd { + margin-bottom: 10px; +} + +div.admonition dl { + margin-bottom: 0; +} + +div.admonition p { + display: inline; +} + +div.seealso { + background-color: #ffc; + border: 1px solid #ff6; +} + +div.warning { + background-color: #ffe4e4; + border: 1px solid #f66; +} + +div.note { + background-color: #eee; + border: 1px solid #ccc; +} + +p.admonition-title { + margin: 0px 10px 5px 0px; + font-weight: bold; + display: inline; +} + +p.admonition-title:after { + content: ":"; +} + +div.body p.centered { + text-align: center; + margin-top: 25px; +} + +table.docutils { + border: 0; +} + +table caption span.caption-number { + font-style: italic; +} + +table caption span.caption-text { +} + +table.docutils td, table.docutils th { + padding: 0 8px 2px 0; + border-top: 0; + border-left: 0; + border-right: 0; + border-bottom: 1px solid #aaa; +} + +table.field-list td, table.field-list th { + border: 0 !important; +} + +table.footnote td, table.footnote th { + border: 0 !important; +} + +dl { + margin-bottom: 15px; + clear: both; +} + +dd p { + margin-top: 0px; +} + +dd ul, dd table { + margin-bottom: 10px; +} + +dd { + margin-top: 3px; + margin-bottom: 10px; + margin-left: 30px; +} + +dl.glossary dt { + font-weight: bold; + font-size: 1.1em; +} + +th { + text-align: left; + padding-right: 5px; +} + +pre { + font-family: monospace; + padding: 5px; + border-left: none; + border-right: none; +} + +code { + font-family: monospace; + background-color: #ecf0f3; + padding: 0 1px 0 1px; +} + +code.descname { + background-color: transparent; + font-weight: bold; + font-size: 1.2em; +} + +code.descclassname { + background-color: transparent; +} + +code.xref, a code { + background-color: transparent; + font-weight: bold; +} + +.footnote:target { background-color: #ffa } + +.line-block { + display: block; + margin-top: 1em; + margin-bottom: 1em; +} + +.line-block .line-block { + margin-top: 0; + margin-bottom: 0; + margin-left: 1.5em; +} + +h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { + background-color: transparent; +} + +.optional { + font-size: 1.3em; +} + +.sig-paren { + font-size: larger; +} + +.versionmodified { + font-style: italic; +} + +/* :::: PRINT :::: */ +@media print { + div.documentwrapper { + width: 100%; + } + + div.body { + margin: 0; + } + + div.sphinxsidebar, + div.related, + div.footer, + div#comments div.new-comment-box, + #top-link { + display: none; + } +} + +.viewcode-link { + float: right; +} + +.viewcode-back { + float: right; + font-family: serif; +} + +div.viewcode-block:target { + background-color: #f4debf; + border-top: 1px solid #ac9; + border-bottom: 1px solid #ac9; + margin: -1px -10px; + padding: 0 10px; +} + +div.code-block-caption { + background-color: #cceeff; +} + +div.code-block-caption span.caption-number { + padding: 0.1em 0.3em; + font-style: italic; +} + +div.code-block-caption span.caption-text { +} + +div.literal-block-wrapper { + padding: 1em 1em 0; +} + +div.literal-block-wrapper pre { + margin: 0; +} + +div.figure p.caption span.caption-number, +figcaption span.caption-number { + font-style: italic; +} + +div.figure p.caption span.caption-text, +figcaption span.caption-text { +} + +/* :::: MATH DISPLAY :::: */ + +div.body div.math p { + text-align: center; +} + +span.eqno { + float: right; +} \ No newline at end of file diff --git a/build/api_reference.html b/build/api_reference.html new file mode 100644 index 0000000..05af671 --- /dev/null +++ b/build/api_reference.html @@ -0,0 +1,330 @@ + + + + + + + + + API Reference - CellPhenoX 0.3.0 documentation + + + + + + + + + + + + + + + + + Contents + + + + + + Menu + + + + + + + + Expand + + + + + + Light mode + + + + + + + + + + + + + + Dark mode + + + + + + + Auto light/dark, in light mode + + + + + + + + + + + + + + + Auto light/dark, in dark mode + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
+ +
+
+
CellPhenoX 0.3.0 documentation
 +
+
+
+ +
+ +
+
+ +
+
+
+ + + + + Back to top + +
+
+ + + + +
+
+ +
+ +
+
+
+

API Reference

+

This section provides an overview of the API.

+
+ +
+
+
+ +
+ + +
+
+
+
+ Copyright © 2024, Fan Zhang, Jade Young, Jun Inamo, Revanth Krishna, Zachary Caterer +
+ Made with Sphinx and @pradyunsg's + + Furo + +
+
+ +
+
+ +
+
+ +
+
+ + + + + + + + + \ No newline at end of file diff --git a/build/api_reference.md b/build/api_reference.md new file mode 100644 index 0000000..dc786cc --- /dev/null +++ b/build/api_reference.md @@ -0,0 +1,3 @@ +# API Reference + +This section provides an overview of the API. diff --git a/build/changelog.html b/build/changelog.html new file mode 100644 index 0000000..3aa5df0 --- /dev/null +++ b/build/changelog.html @@ -0,0 +1,387 @@ + + + + + + + + + Changelog - CellPhenoX 0.3.0 documentation + + + + + + + + + + + + + + + + + Contents + + + + + + Menu + + + + + + + + Expand + + + + + + Light mode + + + + + + + + + + + + + + Dark mode + + + + + + + Auto light/dark, in light mode + + + + + + + + + + + + + + + Auto light/dark, in dark mode + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
+ +
+
+
CellPhenoX 0.3.0 documentation
 +
+
+
+ +
+ +
+
+ +
+
+
+ + + + + Back to top + +
+
+ + + + +
+
+ +
+ +
+
+
+

Changelog

+

All notable changes to this project will be documented in this file.

+
+

0.1.0 - 2024-10-09

+
    +
  • +
    Removed unused attributes, variables and methods from the CellPhenoX class. Specifically, the following attributes, variables and methods were removed:
      +

    • pyCellPhenoX/CellPhenoX.py:30: unused class ‘CellPhenoX’ (60% confidence)

      • +

    • pyCellPhenoX/CellPhenoX.py:45: unused attribute ‘CV_repeat_times’ (60% confidence)

      • +

    • pyCellPhenoX/CellPhenoX.py:111: unused method ‘model_training_shap_val’ (60% confidence)

      • +

    • pyCellPhenoX/CellPhenoX.py:122: unused variable ‘fig’ (60% confidence)

      • +

    • pyCellPhenoX/CellPhenoX.py:221: unused variable ‘thresholds’ (60% confidence)

      • +

    • pyCellPhenoX/CellPhenoX.py:269: unused variable ‘sv_end’ (60% confidence)

      • +

    • pyCellPhenoX/CellPhenoX.py:290: unused variable ‘thresholds’ (60% confidence)

      • +

    • pyCellPhenoX/CellPhenoX.py:318: unused variable ‘d’ (60% confidence)

      • +

    • pyCellPhenoX/CellPhenoX.py:386: unused method ‘get_shap_values_per_cv’ (60% confidence)

      • +

    • pyCellPhenoX/CellPhenoX.py:389: unused method ‘get_best_score’ (60% confidence)

      • +

    • pyCellPhenoX/CellPhenoX.py:392: unused method ‘get_best_model’ (60% confidence)

      • +
    +
    +
    +
    • +
+
+
+

0.1.0 - YYYY-MM-DD

+
    +

  • Initial release with basic functionalities.

    • +

  • Added feature X.

    • +

  • Improved performance of Y.

    • +

  • added new svg logo

    • +
+
+
+ +
+
+
+ +
+ + +
+
+
+
+ Copyright © 2024, Fan Zhang, Jade Young, Jun Inamo, Revanth Krishna, Zachary Caterer +
+ Made with Sphinx and @pradyunsg's + + Furo + +
+
+ +
+
+ +
+
+ +
+
+ + + + + + + + + \ No newline at end of file diff --git a/build/changelog.md b/build/changelog.md new file mode 100644 index 0000000..97ed151 --- /dev/null +++ b/build/changelog.md @@ -0,0 +1,25 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +## 0.1.0 - 2024-10-09 + +- Removed unused attributes, variables and methods from the CellPhenoX class. Specifically, the following attributes, variables and methods were removed: + : - pyCellPhenoX/CellPhenoX.py:30: unused class ‘CellPhenoX’ (60% confidence) + - pyCellPhenoX/CellPhenoX.py:45: unused attribute ‘CV_repeat_times’ (60% confidence) + - pyCellPhenoX/CellPhenoX.py:111: unused method ‘model_training_shap_val’ (60% confidence) + - pyCellPhenoX/CellPhenoX.py:122: unused variable ‘fig’ (60% confidence) + - pyCellPhenoX/CellPhenoX.py:221: unused variable ‘thresholds’ (60% confidence) + - pyCellPhenoX/CellPhenoX.py:269: unused variable ‘sv_end’ (60% confidence) + - pyCellPhenoX/CellPhenoX.py:290: unused variable ‘thresholds’ (60% confidence) + - pyCellPhenoX/CellPhenoX.py:318: unused variable ‘d’ (60% confidence) + - pyCellPhenoX/CellPhenoX.py:386: unused method ‘get_shap_values_per_cv’ (60% confidence) + - pyCellPhenoX/CellPhenoX.py:389: unused method ‘get_best_score’ (60% confidence) + - pyCellPhenoX/CellPhenoX.py:392: unused method ‘get_best_model’ (60% confidence) + +## 0.1.0 - YYYY-MM-DD + +- Initial release with basic functionalities. +- Added feature X. +- Improved performance of Y. +- added new svg logo diff --git a/build/citation.html b/build/citation.html index c5cf091..406d18b 100644 --- a/build/citation.html +++ b/build/citation.html @@ -5,8 +5,8 @@ - - Citing pyCellPhenoX - CellPhenoX 0.2.0 documentation + + Citing pyCellPhenoX - CellPhenoX 0.3.0 documentation @@ -179,7 +179,7 @@
-
CellPhenoX 0.2.0 documentation
 +
CellPhenoX 0.3.0 documentation
@@ -206,7 +206,7 @@
- CellPhenoX 0.2.0 documentation + CellPhenoX 0.3.0 documentation
- + + diff --git a/build/contributing.html b/build/contributing.html index 4fd4d9e..6e37932 100644 --- a/build/contributing.html +++ b/build/contributing.html @@ -3,10 +3,10 @@ - + - - Contributing to the Documentation - CellPhenoX 0.2.0 documentation + + Contributing to pyCellPhenoX - CellPhenoX 0.3.0 documentation @@ -179,7 +179,7 @@
-
CellPhenoX 0.2.0 documentation
 +
CellPhenoX 0.3.0 documentation
@@ -191,7 +191,7 @@
-
- CellPhenoX 0.2.0 documentation + CellPhenoX 0.3.0 documentation @@ -216,12 +216,15 @@

Table of Contents

@@ -258,7 +255,7 @@
- + @@ -272,134 +269,226 @@
-
-
-

Contributing to the Documentation

-
+

Contributing to pyCellPhenoX

-

First of all, thank you for contributing to pyCellPhenoX! :tada: :100:

-

This document contains guidelines on how to most effectively contribute to the pyCellPhenoX codebase.

-

If you are stuck, please feel free to ask any questions or ask for help.

+

First off, thanks for taking the time to contribute! ❤️

+

All types of contributions are encouraged and valued. See the Table of Contents for different ways to help and details about how this project handles them. Please make sure to read the relevant section before making your contribution. It will make it a lot easier for us maintainers and smooth out the experience for all involved. The community looks forward to your contributions. 🎉

+
+

And if you like the project, but just don’t have time to contribute, that’s fine. There are other easy ways to support the project and show your appreciation, which we would also be very happy about:

+
    +

  • Star the project

    • +

  • Tweet about it

    • +

  • Refer this project in your project’s readme

    • +

  • Mention the project at local meetups and tell your friends/colleagues

    • +
+
+
-

Table of contents

-

Code of conduct

-

Quick links

-

How can I contribute?

+

Table of Contents

+ +
+
+

Code of Conduct

+

This project and everyone participating in it is governed by the +pyCellPhenoX Code of Conduct. +By participating, you are expected to uphold this code. Please report unacceptable behavior +to fanzhanglab@gmail.com.

+
+
+

I Have a Question

+
+

If you want to ask a question, we assume that you have read the available Documentation.

+
+

Before you ask a question, it is best to search for existing Issues that might help you. In case you have found a suitable issue and still need clarification, you can write your question in this issue. It is also advisable to search the internet for answers first.

+

If you then still feel the need to ask a question and need clarification, we recommend the following:

+
    +

  • Open an Issue.

    • +

  • Provide as much context as you can about what you’re running into.

    • +

  • Provide project and platform versions (nodejs, npm, etc), depending on what seems relevant.

    • +
+

We will then take care of the issue as soon as possible.

+ +
+
+

I Want To Contribute

+
+
+

When contributing to this project, you must agree that you have authored 100% of the content, that you have the necessary rights to the content and that the content you contribute may be provided under the project license.

+
+
+

Reporting Bugs

+ +
+

Before Submitting a Bug Report

+

A good bug report shouldn’t leave others needing to chase you up for more information. Therefore, we ask you to investigate carefully, collect information and describe the issue in detail in your report. Please complete the following steps in advance to help us fix any potential bug as fast as possible.

+
    +

  • Make sure that you are using the latest version.

    • +

  • Determine if your bug is really a bug and not an error on your side e.g. using incompatible environment components/versions (Make sure that you have read the documentation. If you are looking for support, you might want to check this section).

    • +

  • To see if other users have experienced (and potentially already solved) the same issue you are having, check if there is not already a bug report existing for your bug or error in the bug tracker.

    • +

  • Also make sure to search the internet (including Stack Overflow) to see if users outside of the GitHub community have discussed the issue.

    • +

  • Collect information about the bug:

    +
      +

    • Stack trace (Traceback)

      • +

    • OS, Platform and Version (Windows, Linux, macOS, x86, ARM)

      • +

    • Version of the interpreter, compiler, SDK, runtime environment, package manager, depending on what seems relevant.

      • +

    • Possibly your input and the output

      • +

    • Can you reliably reproduce the issue? And can you also reproduce it with older versions?

      • +
    +
    • +
+ +
+
+

How Do I Submit a Good Bug Report?

+
+

You must never report security related issues, vulnerabilities or bugs including sensitive information to the issue tracker, or elsewhere in public. Instead sensitive bugs must be sent by email to fanzhanglab@gmail.com.

+
+ +

We use GitHub issues to track bugs and errors. If you run into an issue with the project:

    -

  • Bug reporting

    • -

  • Suggesting enhancements

    • -

  • Your first code contribution

    • -

  • Pull requests

    • -

  • Documentation

    • -

  • Poetry

    • -

  • Dev environments

    • -

  • Releases

    • +

  • Open an Issue. (Since we can’t be sure at this point whether it is a bug or not, we ask you not to talk about a bug yet and not to label the issue.)

    • +

  • Explain the behavior you would expect and the actual behavior.

    • +

  • Please provide as much context as possible and describe the reproduction steps that someone else can follow to recreate the issue on their own. This usually includes your code. For good bug reports you should isolate the problem and create a reduced test case.

    • +

  • Provide the information you collected in the previous section.

-

Code Quality

+

Once it’s filed:

    -

  • Formatting

    • -

  • Linting

    • -

  • Git commit messages

    • -

  • Python style guide

    • -

  • Documentation style guide

    • +

  • The project team will label the issue accordingly.

    • +

  • A team member will try to reproduce the issue with your provided steps. If there are no reproduction steps or no obvious way to reproduce the issue, the team will ask you for those steps and mark the issue as needs-repro. Bugs with the needs-repro tag will not be addressed until they are reproduced.

    • +

  • If the team is able to reproduce the issue, it will be marked needs-fix, as well as possibly other tags (such as critical), and the issue will be left to be implemented by someone.

+
-
-

Code of conduct

-

This project and everyone participating in it is governed by our code of conduct. -By participating, you are expected to uphold this code. -Please report unacceptable behavior to fanzhanglab@gmail.com.

-
-

Quick links

+
+

Suggesting Enhancements

+

This section guides you through submitting an enhancement suggestion for pyCellPhenoX, including completely new features and minor improvements to existing functionality. Following these guidelines will help maintainers and the community to understand your suggestion and find related suggestions.

+ +
+

Before Submitting an Enhancement

    -

  • Documentation: https://pyCellPhenoX.readthedocs.io/en/latest/

    • -

  • Issue tracker: https://github.com/fanzhanglab/pyCellPhenoX/issues

    • -

  • Package requirements (using Poetry): https://github.com/fanzhanglab/pyCellPhenoX/blob/main/pyproject.toml

    • +

  • Make sure that you are using the latest version.

    • +

  • Read the documentation carefully and find out if the functionality is already covered, maybe by an individual configuration.

    • +

  • Perform a search to see if the enhancement has already been suggested. If it has, add a comment to the existing issue instead of opening a new one.

    • +

  • Find out whether your idea fits with the scope and aims of the project. It’s up to you to make a strong case to convince the project’s developers of the merits of this feature. Keep in mind that we want features that will be useful to the majority of our users and not just a small subset. If you’re just targeting a minority of users, consider writing an add-on/plugin library.

+
-
-

How can I contribute?

-
-

Bug reporting

-

We love hearing about use-cases when our software does not work. -This provides us an opportunity to improve. -However, in order for us to fix a bug, you need to tell us exactly what went wrong.

-

When you report a bug, please be prepared to tell us as much pertinent information as possible. -This information includes:

+
+

How Do I Submit a Good Enhancement Suggestion?

+

Enhancement suggestions are tracked as GitHub issues.

    -

  • The pyCellPhenoX version you’re using

    • -

  • The format of input data

    • -

  • Copy and paste two pieces of information: 1) your command and 2) the specific error message

    • -

  • What you’ve tried to overcome the bug

    • +

  • Use a clear and descriptive title for the issue to identify the suggestion.

    • +

  • Provide a step-by-step description of the suggested enhancement in as many details as possible.

    • +

  • Describe the current behavior and explain which behavior you expected to see instead and why. At this point you can also tell which alternatives do not work for you.

    • +

  • You may want to include screenshots and animated GIFs which help you demonstrate the steps or point out the part which the suggestion is related to. You can use this tool to record GIFs on macOS and Windows, and this tool or this tool on Linux.

    • +

  • Explain why this enhancement would be useful to most pyCellPhenoX users. You may also want to point out the other projects that solved it better and which could serve as inspiration.

-

Please provide this information as an issue in the repository: https://github.com/fanzhanglab/pyCellPhenoX/issues

-

Please also search the issues (and documentation) for an existing solution. -It’s possible we solved your bug already! -If you find an issue already describing your bug, please add a comment to the issue instead of opening a new one.

+
-
-

Suggesting enhancements

-

We’re deeply committed to a simple, intuitive user experience, and to support single cell omics analysis. This commitment requires a good relationship, and open communication, with our users.

-

We encourage you to propose enhancements to improve the pyCellPhenoX package.

-

First, figure out if your proposal is already implemented, by reading the documentation! -Next, check the issues (https://github.com/fanzhanglab/pyCellPhenoX/issues) to see if someone else has already proposed the enhancement you have in mind. -If you do find the suggestion, please comment on the existing issue noting that you are also interested in this functionality. -If you do not find the suggestion, please open a new issue and clearly document the specific enhancement and why it would be helpful for your particular use case.

-

Please provide your enhancement suggestions as an issue in the repository:

-
-

Your first code contribution

-

Contributing code for the first time can be a daunting task. -However, in our community, we strive to be as welcoming as possible to newcomers, while ensuring rigorous software development practices.

-

If you want to contribute code that we haven’t already outlined, please start a discussion in a new issue before actually writing any code. -A discussion will clarify the new code and reduce merge time. -Plus, it’s possible that your contribution belongs in a different code base, and we do not want to waste your time (or ours)!

-
-

Pull requests

-

After you’ve decided to contribute code and have written it up, now it is time to file a pull request. -We specifically follow a forked pull request model. -Please create a fork of the pyCellPhenoX repository, clone the fork, and then create a new, feature-specific branch. -Once you make the necessary changes on this branch, you should file a pull request to incorporate your changes into the main pyCellPhenoX repository.

-

The content and description of your pull request are directly related to the speed at which we are able to review, approve, and merge your contribution into pyCellPhenoX. -To ensure an efficient review process please perform the following steps:

-
    -

  1. Follow all instructions in the pull request template

    2. -

  2. Triple check that your pull request is only adding one specific feature. Small, bite-sized pull requests move so much faster than large pull requests.

    3. -

  3. After submitting your pull request, ensure that your contribution passes all status checks (e.g. passes all tests)

    4. -
-

All pull requests must be reviewed and approved by at least one project maintainer in order to be merged. -We will do our best to review the code addition in a timely fashion. -Ensuring that you follow all steps above will increase our speed and ability to review. -We will check for accuracy, style, code coverage, and scope.

+
+

Your first code contribution

+

We welcome contributions! Follow these steps to contribute:

+
+

1. Fork, Clone, and Branch

+
    +

  • Fork the repository and clone it to your local machine.

    • +
+
git clone https://github.com/fanzhanglab/pyCellPhenoX.git
+cd pyCellPhenoX
+
+
+

Please branch from the main branch given we have set up branch protections.

+
git checkout -b your-branch-name
+
+
+
+
+

2. Make Your Changes

+
    +

  • Make sure your code follows the project standards.

    • +

  • Format your Python code with Black:

    • +
+
black your_file.py
+
+
+
+
+

3. Commit and Push

+

Commit your changes with a meaningful message:

+
git commit -m "Description of your changes"
+
+
+

Push your changes:

+
git push origin your-branch-name
+
+
+
+
+

4. Submit a Pull Request

+

Submit a pull request and explain the changes you’ve made.

+
-
-

Documentation

+
+

Style Guides

+
+

Documentation

We use sphinx for autodocumentation of docstrings, using the napoleon extenstion to parse NumPy style docstrings, implemented with a furo theme. -We host our documentation on readthedocs.org at https://pycytominer.readthedocs.io/en/latest/.

+We host our documentation on readthedocs.org at https://pyCellPhenoX.readthedocs.io/en/.

To build and test changes to the docs locally, run the following command:

sphinx-build -b html docs build
-

See ``docs/conf.py` <docs/conf.py>`_ for full documentation configuration.

+

See docs/conf.py for full documentation configuration.

-
-

Poetry

-

We use Poetry to manage dependencies and packaging. -Changes in dependencies are managed by Poetry’s pyproject.toml file. -Poetry installs all dependencies in a virtual environment, which is activated automatically when you run poetry shell. -Poetry also provides a poetry run command to run commands in the virtual environment without activating it. -For example, to run the test suite, you can use poetry run pytest.

-
-
-

Dev environments

+
+

Dev environments

Local devcontainer

Instructions for setting up a local development environment using VSCode DevContainers:

@@ -411,81 +500,40 @@

Local devcontainer -

Cloud environment

-

We’ve set up cloud development configurations with Github Codespaces. -These development environments include the project dependencies pre-installed via Poetry. -Prior to commit, pre-installed git hooks auto-format any changed code. -When you are ready to make a pull request, use the pre-configured test suite in VSCode or run poetry run pytest to ensure that your changes pass all tests. -You can create a codespace by clicking on the following link:

-Open in GitHub Codespaces -

Beginner’s Guide to Codespaces

-

-
-

Manual setup

-

We recommend using either the local devcontainer or cloud dev environment approaches above. -However, we also provide general guidance for setting up a dev environment in Linux, MacOS, or Windows (WSL) below.

-
# Install Poetry (Linux, MacOS, Windows - WSL)
-curl -sSL https://install.python-poetry.org | python3 -
-# Checkout the repository
-git clone https://github.com/fanzhanglab/pyCellPhenoX.git
-cd pyCellPhenoX
-
-
-
-
-
-

Releases

-

Project maintainers are responsible for releasing new versions of pyCellPhenoX. -Creating a new release includes the following steps:

-
    -

  1. Create a new branch from main for the release (e.g. release-v1.0.0)

    2. -

  2. Review the commit history from the last release and check whether it includes commits that don’t follow the conventional commit standard. -If all changes follow conventional commits, skip to step 5.

    3. -

  3. Run the command poetry run cz bump --files-only to update the version number in CITATION.cff and pyproject.toml:tool.commitizen and generate the draft changelog.

    4. -

  4. Review the changes to CHANGELOG.md. If necessary, add descriptions of missing changes and modify descriptions to match conventional commits standard.

    5. -

  5. git add any manual changes and run poetry run cz bump to create the release commit. -Push the changes to the release branch.

    6. -

  6. Create a pull request for the release branch into main.

    7. -

  7. Request a review from another maintainer.

    8. -

  8. Once the pull request is approved, merge it into main.

    9. -

  9. Create a new release on GitHub using the release draft feature.

    10. -

  10. Publish the release.

    11. -

  11. The release will be automatically published to PyPI via Github Actions.

    12. -

  12. Manually create the release at conda-forge.

    13. -
-
-

Code Quality

+
+

Code Quality

Please follow the below quality guides to the best of your abilities. -If you have configured your dev environment as described above, the formatting and linting rules will also be enforced automatically using the installed pre-commit hooks.

-
-

Formatting

-

We use ruff for formatting Python code, and prettier for formatting markdown, json and yaml files. -Ruff includes a python code formatter similar to Black. -We include ruff in the poetry dev dependencies so it can be run manually using ruff format +If you have configured your dev environment as described above, the formatting and linting rules will also be enforced automatically using the installed pre-commit hooks.

+
+

Formatting

+

We use black for formatting Python code, and prettier for formatting markdown, json and yaml files. +We include black in the poetry dev dependencies so it can be run manually using black format Prettier (which is not python-based) is not included in the poetry dev dependencies, but can be installed and run manually. -Alternately, both ruff format and prettier will be run automatically at commit time with the pre-commit hooks installed.

+Alternately, both black format and prettier will be run automatically at commit time with the pre-commit hooks installed.

-
-

Linting

-

For python code linting, we also use ruff, which can perform same linting checks as Flake8. -You can use the command ruff check to check for linting errors. -The list of linting rules and exceptions are defined in the pyproject.toml file under the [tool.ruff.lint] section. +

+

Linting

+

For python code linting, we also use black, which can perform same linting checks as Flake8. +You can use the command black --check your_file.py or black path/to/your/directory to check for linting errors. We also include some commented-out rules in that section that we are working towards enabling in the future. All linting checks will also be run automatically at commit time with the pre-commit hooks as described above.

-
-

Git commit messages

+
+

Documentation style guide

+

We use the numpy documentation style guide. +When writing markdown documentation, please also ensure that each sentence is on a new line.

+
+
+

Commit messages

pyCellPhenoX uses Conventional Commits standard for commit messages to aid in automatic changelog generation. We prepare commit messages that follow this standard using commitizen, which comes with the poetry dev dependencies.

-
-

Documentation style guide

-

We use the numpy documentation style guide. -When writing markdown documentation, please also ensure that each sentence is on a new line.

+
+

Attribution

+

This guide is based on the contributing-gen. Make your own!

@@ -494,23 +542,23 @@

Documentation style guide - +
Next
-
Issues
+
Code of Conduct - pyCellPhenoX
 - +
Previous
-
Code of Conduct
+
pyCellPhenoX
 @@ -532,14 +580,71 @@

Documentation style guide +

- - + + diff --git a/build/genindex.html b/build/genindex.html index ef90e0d..be19575 100644 --- a/build/genindex.html +++ b/build/genindex.html @@ -4,7 +4,7 @@ - Index - CellPhenoX 0.2.0 documentation + Index - CellPhenoX 0.3.0 documentation @@ -177,7 +177,7 @@
-
CellPhenoX 0.2.0 documentation
 +
CellPhenoX 0.3.0 documentation
@@ -204,7 +204,7 @@
- CellPhenoX 0.2.0 documentation + CellPhenoX 0.3.0 documentation @@ -214,12 +214,15 @@

Table of Contents

@@ -495,8 +492,8 @@

S

-
- + + diff --git a/build/index.html b/build/index.html index 9686965..d6de9eb 100644 --- a/build/index.html +++ b/build/index.html @@ -3,10 +3,10 @@ - + - - CellPhenoX 0.2.0 documentation + + CellPhenoX 0.3.0 documentation @@ -179,7 +179,7 @@
-
CellPhenoX 0.2.0 documentation
 +
CellPhenoX 0.3.0 documentation
@@ -191,7 +191,7 @@
-
- CellPhenoX 0.2.0 documentation + CellPhenoX 0.3.0 documentation @@ -216,12 +216,15 @@

Table of Contents

@@ -272,321 +269,66 @@
-