dinglab-pollock


Namedinglab-pollock JSON
Version 0.0.14 PyPI version JSON
download
home_pagehttps://github.com/ding-lab/pollock
SummaryA tool for single cell classification and characterization.
upload_time2020-11-15 02:06:37
maintainer
docs_urlNone
authorDing Lab
requires_python>=3.6
license
keywords single cell classification expression machine learning deep learning
VCS
bugtrack_url
requirements No requirements were recorded.
Travis-CI No Travis.
coveralls test coverage No coveralls.
            # Pollock

![Image of Pollock](https://github.com/ding-lab/pollock/blob/master/images/polluck.png)

Pollock is a tool for single cell classification. Pollock is available in both Python, R, and as a command line tool

In Development

## Installation
#### Requirements
* OS:
  * macOS 10.12.6 (Sierra) or later
  * Ubuntu 16.04 or later
  * Windows 7 or later (not tested)

* Python3.6 or later

* Anaconda/Conda
  * Working installation of conda and [bioconda](https://bioconda.github.io/). If you are new to conda and bioconda, we recommend following the getting started page [here](https://bioconda.github.io/user/install.html)

#### To install

pollock is available through the conda package manager.

In addition to the default conda channels, pollock requires bioconda. In particular to ensure proper installation you must have your conda channels set up in the correct order by running the following:
```bash
conda config --add channels defaults
conda config --add channels bioconda
conda config --add channels conda-forge
```

To install

```bash
conda install -c epstorrs pollock==0.0.10
```

NOTE: tensorflow requires a fair amount of space to build correctly. In some clusters the tmp/ directory does not have enough space for tensorflow to build. If you run pollock and get an error about tensorflow note being available you will have to install it manually using a directory with enough space (> 2GB should be sufficient).

```bash
TMPDIR=<path/to/directory> pip install --cache-dir=<path/to/directory> --build <path/to/directory> tensorflow==2.1.0
```

After that pollock should work correctly

## Usage

Pollock uses deep learning to make cell type predictions. At it's core, pollock is build upon a deep learning technique called a Beta Variational Autoencoder (BVAE).

With pollock, there are a selection of cell type classification modules that have been trained on a variety of single cell RNA-seq datasets. Any of these modules can be used to classify your single cell data.

Additionally, if you have annotated single cell data, pollock can also be used to train a new module based on the given cell types.

### Modules

There are a variety of modules available for cell type classification. They can be found on the dinglab cluster at `/diskmnt/Projects/Users/estorrs/pollock/modules`.

To list available modules run
```bash
ls /diskmnt/Projects/Users/estorrs/pollock/modules
```

You can also create new modules with pollock (see below)

#### Python

[module training tutorial on pbmc dataset](https://github.com/ding-lab/pollock/blob/master/examples/pbmc_model_training.ipynb)

[prediction with an existing module](https://github.com/ding-lab/pollock/blob/master/examples/pbmc_module_prediction.ipynb)

[module examination](https://github.com/ding-lab/pollock/blob/master/examples/pollock_module_examination.ipynb)

#### R

There is an R library rpollock that comes installed with pollock that allows you to train a module and make predictions directly from R.

Note: rpollock is dependent on the R library reticulate, which will sometimes prompt for a python install location. If this occurs, run the below code to find out the location of your python installation. It will output `<path/to/python/executable>`

```bash
which python3
```

When running R you will need to have this line at the very start of your script (before your library imports)
```R
reticulate::use_python("<path/to/python/executable>")
```

[example usage of rpollock on pbmc3k](https://github.com/ding-lab/pollock/blob/master/examples/rpollock_pbmc_prediction.Rmd)

[This notebook](https://github.com/ding-lab/pollock/blob/master/examples/pollock_module_examination.ipynb) is a python script walking over the information that is contained in each module. Though it is in python, all this information is saved in a json file so everything done in that notebook can also be done in R.

## Command line tool
```bash
usage: pollock [-h] [--module-filepath MODULE_FILEPATH]
               [--seurat-rds-filepath SEURAT_RDS_FILEPATH]
               [--scanpy-h5ad-filepath SCANPY_H5AD_FILEPATH]
               [--cell-type-key CELL_TYPE_KEY] [--alpha ALPHA]
               [--epochs EPOCHS] [--latent-dim LATENT_DIM]
               [--n-per-cell-type N_PER_CELL_TYPE]
               [--counts-10x-filepath COUNTS_10X_FILEPATH]
               [--min-genes-per-cell MIN_GENES_PER_CELL] [--txt-output]
               [--output-prefix OUTPUT_PREFIX]
               mode source_type
```

##### Arguments

mode
  * What task/mode is pollock to perform. Valid arguments are:
    * train
    * predict

source_type
  * Input source type. Possible values are: from_seurat, from_10x, from_scanpy.


module_filepath
  * If in prediction mode, this is the filepath to module to use for classification. For beta, available modules are stored in katmai at `/diskmnt/Projects/Users/estorrs/pollock/modules`.
  * If in training mode, this is the filepath where pollock will save the trained module.

###### mode specific arguments

--seurat-rds-filepath SEURAT_RDS_FILEPATH
  * A saved Seurat RDS object to use as input. Raw RNA-seq (i.e. not normalized) counts **must** be stored in @assays$RNA@counts. Note that this is where raw rna-seq counts will be stored by most Seurat single cell workflows by default.

--scanpy-h5ad-filepath SCANPY_H5AD_FILEPATH
  * A saved .h5ad file to use as input. scanpy expression matrix (.X attribute in the anndata object) must be raw expression counts (i.e. not normalized)

--counts-10x-filepath COUNTS_10X_FILEPATH
  * Can only be used with predict mode. Results of 10X cellranger run to be used for classification. There are two options for inputs: 1) the mtx count directory (typically at outs/raw_feature_bc_matrix), and 2) the .h5 file (typically at outs/raw_feature_bc_matrix.h5).

###### specific to train mode
--cell-type-key CELL_TYPE_KEY
  * The key to use for training the pollock module. The key can be one of the following: 1) A string representing a column in the metadata of the input seurat object or .obs attribute of the scanpy anndata object, or 2) filepath to a .txt file where each line is a cell type label. The number of lines must be equal to the number of cells in the input object. The cell types must also be in the same order as the cells in the input object. By default if the input is a Seurat object pollock will use cell type labels in @active.ident, or if the input is a scanpy anndata object pollock will use the label in .obs["leiden"].

--alpha ALPHA
  * This parameter controls how regularized the BVAE is. .0001 is the default. If you increase alpha the cell embeddings are typically more noisy, but also more generalizable. If you decrease alpha the cell embeddings are typically less noisy, but also less generalizable.

--epochs EPOCHS
  * Number of epochs to train the neural net for. Default is 20.

--latent-dim LATENT_DIM
  * Size of hidden layer in the B-VAE. Default is 25.

--n-per-cell-type N_PER_CELL_TYPE
  * The number of cells per cell type that should be included in the training dataset. Typically this number will be somewhere between 500-2000. The default is 500. If you have a particular cell type in your dataset that has a low cell count it is usually a good idea not to increase n_per_cell_type too much. A good rule of thumb is that n_per_cell_type should be no greater than the minimum cell type count * 10.


###### optional arguments specific to predict mode

--min-genes-per-cell MIN_GENES_PER_CELL
  * The minimun number of genes expressed in a cell in order for it to be classified. Only used in 10x mode

--txt-output TXT_OUTPUT
  * If included output will be written to a tab-seperated .txt file. Otherwise output will be saved in the metadata of the input seurat object (.rds) or scanpy anndata object (.h5ad)

--output-prefix OUTPUT_PREFIX
  * Filepath prefix to write output file. Extension will be dependent on the inclusion of --output-txt argument. By default the extension will be the same as the input object type. Default value is "output"

#### example basic usage

##### predict mode

An example of cell type prediction on a Seurat .RDS object
```bash
pollock predict from_seurat --module-filepath <path_to_module_directory> --seurat-rds-filepath <filepath_to_RDS_object> --output-prefix output
```

An example of cell type prediction on a Seurat .RDS object, but writing to a txt file instead of an RDS object
```bash
pollock predict from_seurat --module-filepath <path_to_module_directory> --seurat-rds-filepath <filepath_to_RDS_object> --output-prefix output --txt-output
```

An example of cell type prediction on a scanpy .h5ad object
```bash
pollock predict from_scanpy --module-filepath <path_to_module_directory> --scanpy-h5ad-filepath <filepath_to_scanpy_h5ad> --output-prefix output
```

An example of cell type prediction on cellranger output
```bash
pollock predict from_10x --module-filepath <path_to_module_directory> --counts-10x-filepath </filepath/to/cellranger/outs/raw_feature_bc_matrix> --output-prefix output
```

##### train mode

An example of training a model on a Seurat .RDS object that has cell type labels in @active.idents slot. Note this is where cell type labels are typically stored in Seurat workflows.
```bash
pollock train from_seurat --module-filepath <path_to_write_output_module> --seurat-rds-filepath <filepath_to_RDS_object> 
```

An example of training a model on a Seurat .RDS object that has cell type labels stored in a metadata column named "my_special_cell_types".
```bash
pollock train from_seurat --module-filepath <path_to_write_output_module> --seurat-rds-filepath <filepath_to_RDS_object> --cell-type-key my_special_cell_types

```

An example of training a model on a Seurat .RDS object where cell type labels are in a file.
```bash
pollock train from_seurat --module-filepath <path_to_write_output_module> --seurat-rds-filepath <filepath_to_RDS_object> --cell-type-key <filepath_to_cell_labels>
```


An example of training a model on a Seurat .RDS object with custom model hyperparamters
```bash
pollock train from_seurat --module-filepath <path_to_write_output_module> --seurat-rds-filepath <filepath_to_RDS_object>  --alpha .0001 --epochs 20 --latent-dim 25 --n-per-cell-type 500
```

An example of training a model on a scanpy .h5ad object that has cell type labels stored in a column in .obs named "my_special_cell_types".
```bash
pollock train from_scanpy --module-filepath <path_to_write_output_module> --scanpy-h5ad-filepath <filepath_to_h5ad_object> --cell-type-key my_special_cell_types
```



## docker
Dockerfiles for pollock can be found in the `docker/` directory. They can also be pulled from estorrs/pollock-cpu on dockerhub. To pull the latest pollock docker image run the following:
```bash
docker pull estorrs/pollock-cpu:0.0.10
```

#### example basic usage of comand line tool within a docker container

When using docker, the input and ouput file directories need to be mounted as a volume using the docker -v argument.

Below is an example of predicting cell types from within a docker container. Sections outlined by <> need to be replaced. Note file and directory paths in the -v flag must be absolute. For more examples of how the pollock command line tool is used see the above usage examples.

ding lab only: the </path/to/modules/directory/> would be /diskmnt/Projects/Users/estorrs/pollock/modules on katmai
```bash
docker run -v </path/to/directory/with/seurat/rds>:/inputs -v </path/to/output/directory>:/outputs -v </path/to/modules/directory/>:/modules -t estorrs/pollock-cpu:0.0.10 pollock predict from_seurat --module-filepath /modules/<module_name> --seurat-rds-filepath /inputs/<name_of_seurat_rds_file> --output-prefix /outputs/output
```



            

Raw data

            {
    "_id": null,
    "home_page": "https://github.com/ding-lab/pollock",
    "name": "dinglab-pollock",
    "maintainer": "",
    "docs_url": null,
    "requires_python": ">=3.6",
    "maintainer_email": "",
    "keywords": "single cell classification expression machine learning deep learning",
    "author": "Ding Lab",
    "author_email": "estorrs@wustl.edu",
    "download_url": "https://files.pythonhosted.org/packages/1e/dd/803f31b33f11095aa4e5c604528ff50642de11664e96ec4ba430621d7f57/dinglab-pollock-0.0.14.tar.gz",
    "platform": "",
    "description": "# Pollock\n\n![Image of Pollock](https://github.com/ding-lab/pollock/blob/master/images/polluck.png)\n\nPollock is a tool for single cell classification. Pollock is available in both Python, R, and as a command line tool\n\nIn Development\n\n## Installation\n#### Requirements\n* OS:\n  * macOS 10.12.6 (Sierra) or later\n  * Ubuntu 16.04 or later\n  * Windows 7 or later (not tested)\n\n* Python3.6 or later\n\n* Anaconda/Conda\n  * Working installation of conda and [bioconda](https://bioconda.github.io/). If you are new to conda and bioconda, we recommend following the getting started page [here](https://bioconda.github.io/user/install.html)\n\n#### To install\n\npollock is available through the conda package manager.\n\nIn addition to the default conda channels, pollock requires bioconda. In particular to ensure proper installation you must have your conda channels set up in the correct order by running the following:\n```bash\nconda config --add channels defaults\nconda config --add channels bioconda\nconda config --add channels conda-forge\n```\n\nTo install\n\n```bash\nconda install -c epstorrs pollock==0.0.10\n```\n\nNOTE: tensorflow requires a fair amount of space to build correctly. In some clusters the tmp/ directory does not have enough space for tensorflow to build. If you run pollock and get an error about tensorflow note being available you will have to install it manually using a directory with enough space (> 2GB should be sufficient).\n\n```bash\nTMPDIR=<path/to/directory> pip install --cache-dir=<path/to/directory> --build <path/to/directory> tensorflow==2.1.0\n```\n\nAfter that pollock should work correctly\n\n## Usage\n\nPollock uses deep learning to make cell type predictions. At it's core, pollock is build upon a deep learning technique called a Beta Variational Autoencoder (BVAE).\n\nWith pollock, there are a selection of cell type classification modules that have been trained on a variety of single cell RNA-seq datasets. Any of these modules can be used to classify your single cell data.\n\nAdditionally, if you have annotated single cell data, pollock can also be used to train a new module based on the given cell types.\n\n### Modules\n\nThere are a variety of modules available for cell type classification. They can be found on the dinglab cluster at `/diskmnt/Projects/Users/estorrs/pollock/modules`.\n\nTo list available modules run\n```bash\nls /diskmnt/Projects/Users/estorrs/pollock/modules\n```\n\nYou can also create new modules with pollock (see below)\n\n#### Python\n\n[module training tutorial on pbmc dataset](https://github.com/ding-lab/pollock/blob/master/examples/pbmc_model_training.ipynb)\n\n[prediction with an existing module](https://github.com/ding-lab/pollock/blob/master/examples/pbmc_module_prediction.ipynb)\n\n[module examination](https://github.com/ding-lab/pollock/blob/master/examples/pollock_module_examination.ipynb)\n\n#### R\n\nThere is an R library rpollock that comes installed with pollock that allows you to train a module and make predictions directly from R.\n\nNote: rpollock is dependent on the R library reticulate, which will sometimes prompt for a python install location. If this occurs, run the below code to find out the location of your python installation. It will output `<path/to/python/executable>`\n\n```bash\nwhich python3\n```\n\nWhen running R you will need to have this line at the very start of your script (before your library imports)\n```R\nreticulate::use_python(\"<path/to/python/executable>\")\n```\n\n[example usage of rpollock on pbmc3k](https://github.com/ding-lab/pollock/blob/master/examples/rpollock_pbmc_prediction.Rmd)\n\n[This notebook](https://github.com/ding-lab/pollock/blob/master/examples/pollock_module_examination.ipynb) is a python script walking over the information that is contained in each module. Though it is in python, all this information is saved in a json file so everything done in that notebook can also be done in R.\n\n## Command line tool\n```bash\nusage: pollock [-h] [--module-filepath MODULE_FILEPATH]\n               [--seurat-rds-filepath SEURAT_RDS_FILEPATH]\n               [--scanpy-h5ad-filepath SCANPY_H5AD_FILEPATH]\n               [--cell-type-key CELL_TYPE_KEY] [--alpha ALPHA]\n               [--epochs EPOCHS] [--latent-dim LATENT_DIM]\n               [--n-per-cell-type N_PER_CELL_TYPE]\n               [--counts-10x-filepath COUNTS_10X_FILEPATH]\n               [--min-genes-per-cell MIN_GENES_PER_CELL] [--txt-output]\n               [--output-prefix OUTPUT_PREFIX]\n               mode source_type\n```\n\n##### Arguments\n\nmode\n  * What task/mode is pollock to perform. Valid arguments are:\n    * train\n    * predict\n\nsource_type\n  * Input source type. Possible values are: from_seurat, from_10x, from_scanpy.\n\n\nmodule_filepath\n  * If in prediction mode, this is the filepath to module to use for classification. For beta, available modules are stored in katmai at `/diskmnt/Projects/Users/estorrs/pollock/modules`.\n  * If in training mode, this is the filepath where pollock will save the trained module.\n\n###### mode specific arguments\n\n--seurat-rds-filepath SEURAT_RDS_FILEPATH\n  * A saved Seurat RDS object to use as input. Raw RNA-seq (i.e. not normalized) counts **must** be stored in @assays$RNA@counts. Note that this is where raw rna-seq counts will be stored by most Seurat single cell workflows by default.\n\n--scanpy-h5ad-filepath SCANPY_H5AD_FILEPATH\n  * A saved .h5ad file to use as input. scanpy expression matrix (.X attribute in the anndata object) must be raw expression counts (i.e. not normalized)\n\n--counts-10x-filepath COUNTS_10X_FILEPATH\n  * Can only be used with predict mode. Results of 10X cellranger run to be used for classification. There are two options for inputs: 1) the mtx count directory (typically at outs/raw_feature_bc_matrix), and 2) the .h5 file (typically at outs/raw_feature_bc_matrix.h5).\n\n###### specific to train mode\n--cell-type-key CELL_TYPE_KEY\n  * The key to use for training the pollock module. The key can be one of the following: 1) A string representing a column in the metadata of the input seurat object or .obs attribute of the scanpy anndata object, or 2) filepath to a .txt file where each line is a cell type label. The number of lines must be equal to the number of cells in the input object. The cell types must also be in the same order as the cells in the input object. By default if the input is a Seurat object pollock will use cell type labels in @active.ident, or if the input is a scanpy anndata object pollock will use the label in .obs[\"leiden\"].\n\n--alpha ALPHA\n  * This parameter controls how regularized the BVAE is. .0001 is the default. If you increase alpha the cell embeddings are typically more noisy, but also more generalizable. If you decrease alpha the cell embeddings are typically less noisy, but also less generalizable.\n\n--epochs EPOCHS\n  * Number of epochs to train the neural net for. Default is 20.\n\n--latent-dim LATENT_DIM\n  * Size of hidden layer in the B-VAE. Default is 25.\n\n--n-per-cell-type N_PER_CELL_TYPE\n  * The number of cells per cell type that should be included in the training dataset. Typically this number will be somewhere between 500-2000. The default is 500. If you have a particular cell type in your dataset that has a low cell count it is usually a good idea not to increase n_per_cell_type too much. A good rule of thumb is that n_per_cell_type should be no greater than the minimum cell type count * 10.\n\n\n###### optional arguments specific to predict mode\n\n--min-genes-per-cell MIN_GENES_PER_CELL\n  * The minimun number of genes expressed in a cell in order for it to be classified. Only used in 10x mode\n\n--txt-output TXT_OUTPUT\n  * If included output will be written to a tab-seperated .txt file. Otherwise output will be saved in the metadata of the input seurat object (.rds) or scanpy anndata object (.h5ad)\n\n--output-prefix OUTPUT_PREFIX\n  * Filepath prefix to write output file. Extension will be dependent on the inclusion of --output-txt argument. By default the extension will be the same as the input object type. Default value is \"output\"\n\n#### example basic usage\n\n##### predict mode\n\nAn example of cell type prediction on a Seurat .RDS object\n```bash\npollock predict from_seurat --module-filepath <path_to_module_directory> --seurat-rds-filepath <filepath_to_RDS_object> --output-prefix output\n```\n\nAn example of cell type prediction on a Seurat .RDS object, but writing to a txt file instead of an RDS object\n```bash\npollock predict from_seurat --module-filepath <path_to_module_directory> --seurat-rds-filepath <filepath_to_RDS_object> --output-prefix output --txt-output\n```\n\nAn example of cell type prediction on a scanpy .h5ad object\n```bash\npollock predict from_scanpy --module-filepath <path_to_module_directory> --scanpy-h5ad-filepath <filepath_to_scanpy_h5ad> --output-prefix output\n```\n\nAn example of cell type prediction on cellranger output\n```bash\npollock predict from_10x --module-filepath <path_to_module_directory> --counts-10x-filepath </filepath/to/cellranger/outs/raw_feature_bc_matrix> --output-prefix output\n```\n\n##### train mode\n\nAn example of training a model on a Seurat .RDS object that has cell type labels in @active.idents slot. Note this is where cell type labels are typically stored in Seurat workflows.\n```bash\npollock train from_seurat --module-filepath <path_to_write_output_module> --seurat-rds-filepath <filepath_to_RDS_object> \n```\n\nAn example of training a model on a Seurat .RDS object that has cell type labels stored in a metadata column named \"my_special_cell_types\".\n```bash\npollock train from_seurat --module-filepath <path_to_write_output_module> --seurat-rds-filepath <filepath_to_RDS_object> --cell-type-key my_special_cell_types\n\n```\n\nAn example of training a model on a Seurat .RDS object where cell type labels are in a file.\n```bash\npollock train from_seurat --module-filepath <path_to_write_output_module> --seurat-rds-filepath <filepath_to_RDS_object> --cell-type-key <filepath_to_cell_labels>\n```\n\n\nAn example of training a model on a Seurat .RDS object with custom model hyperparamters\n```bash\npollock train from_seurat --module-filepath <path_to_write_output_module> --seurat-rds-filepath <filepath_to_RDS_object>  --alpha .0001 --epochs 20 --latent-dim 25 --n-per-cell-type 500\n```\n\nAn example of training a model on a scanpy .h5ad object that has cell type labels stored in a column in .obs named \"my_special_cell_types\".\n```bash\npollock train from_scanpy --module-filepath <path_to_write_output_module> --scanpy-h5ad-filepath <filepath_to_h5ad_object> --cell-type-key my_special_cell_types\n```\n\n\n\n## docker\nDockerfiles for pollock can be found in the `docker/` directory. They can also be pulled from estorrs/pollock-cpu on dockerhub. To pull the latest pollock docker image run the following:\n```bash\ndocker pull estorrs/pollock-cpu:0.0.10\n```\n\n#### example basic usage of comand line tool within a docker container\n\nWhen using docker, the input and ouput file directories need to be mounted as a volume using the docker -v argument.\n\nBelow is an example of predicting cell types from within a docker container. Sections outlined by <> need to be replaced. Note file and directory paths in the -v flag must be absolute. For more examples of how the pollock command line tool is used see the above usage examples.\n\nding lab only: the </path/to/modules/directory/> would be /diskmnt/Projects/Users/estorrs/pollock/modules on katmai\n```bash\ndocker run -v </path/to/directory/with/seurat/rds>:/inputs -v </path/to/output/directory>:/outputs -v </path/to/modules/directory/>:/modules -t estorrs/pollock-cpu:0.0.10 pollock predict from_seurat --module-filepath /modules/<module_name> --seurat-rds-filepath /inputs/<name_of_seurat_rds_file> --output-prefix /outputs/output\n```\n\n\n",
    "bugtrack_url": null,
    "license": "",
    "summary": "A tool for single cell classification and characterization.",
    "version": "0.0.14",
    "split_keywords": [
        "single",
        "cell",
        "classification",
        "expression",
        "machine",
        "learning",
        "deep",
        "learning"
    ],
    "urls": [
        {
            "comment_text": "",
            "digests": {
                "md5": "91b404dc562c111b2084cd06a12b0f78",
                "sha256": "d2e42b44b7029df0043ddd818b990ef4e68ce15bbbfe9f15e7a75849102fc56c"
            },
            "downloads": -1,
            "filename": "dinglab_pollock-0.0.14-py3-none-any.whl",
            "has_sig": false,
            "md5_digest": "91b404dc562c111b2084cd06a12b0f78",
            "packagetype": "bdist_wheel",
            "python_version": "py3",
            "requires_python": ">=3.6",
            "size": 29252,
            "upload_time": "2020-11-15T02:06:35",
            "upload_time_iso_8601": "2020-11-15T02:06:35.173008Z",
            "url": "https://files.pythonhosted.org/packages/e6/4c/0f364e8f073715fae094876607512002f11f3a5dc72f35e9bfe27bd1e979/dinglab_pollock-0.0.14-py3-none-any.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": "",
            "digests": {
                "md5": "7578b74f8e7d6cb5653fe6ad66ec4151",
                "sha256": "f5bfce77d753eadf694599a94bb7d0826c5a993c610ead84d50fed87cdcf45e1"
            },
            "downloads": -1,
            "filename": "dinglab-pollock-0.0.14.tar.gz",
            "has_sig": false,
            "md5_digest": "7578b74f8e7d6cb5653fe6ad66ec4151",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": ">=3.6",
            "size": 45160613,
            "upload_time": "2020-11-15T02:06:37",
            "upload_time_iso_8601": "2020-11-15T02:06:37.688830Z",
            "url": "https://files.pythonhosted.org/packages/1e/dd/803f31b33f11095aa4e5c604528ff50642de11664e96ec4ba430621d7f57/dinglab-pollock-0.0.14.tar.gz",
            "yanked": false,
            "yanked_reason": null
        }
    ],
    "upload_time": "2020-11-15 02:06:37",
    "github": true,
    "gitlab": false,
    "bitbucket": false,
    "github_user": null,
    "github_project": "ding-lab",
    "error": "Could not fetch GitHub repository",
    "lcname": "dinglab-pollock"
}
        
Elapsed time: 0.14142s