semvec/pypi-packages huggingface dataset:
scp-infer 0.0.1
Utility for applying causal inference algorithms perturbed single-cell gene exression data
Requires Python: >=3.11

# scp-infer: Causal Inference using perturbed single-cell gene expression data
Apply a number of causal inference algorithms to experimental perturbed single-cell gene exression data.
Built using scanpy

## 1. Installation

There are two options provied to setup the usage of this package. 

1. As a simple option we reccommend to first create a clean python envrionment, where care has to be taken to select the correct python version `3.11.13` (otherwise older versions such as `3.11.8` or `3.10.x` should work as well). Then this repository can be cloned, and the requirements listed in `requirements.txt` installed using pip, e.g:

```
conda create -n <env-name> python=3.11.13
conda activate <env-name>
pip install -r requirements.txt
```
Activation of the environment for Jupyter:
```
ipython kernel install --user --name=<env-name>
```
2. Alternatively we provide a dockerfile in `\docker-deploy` for installing the package in a containerized environment. The image can be automatically configured with the `download_infer_pkg.sh` executable, which would require `docker-compose` to be installed.

## 2. Tutorials:

under [tutorials](tutorials) there are three jupyter notebooks giving examples of how to use the package:

1. [sergio-knockdown-run](tutorials/sergio-knockdown-run.ipynb) shows how synthetic gene expression data using SERGIO can be generated.
2. [synthetic_data](tutorials/synthetic_data.ipynb) gives an example of applying the GRN inference algorithms to a synthetically genrdated dataset.
3. [experimental_data](tutorials/experimental_data.ipynb) gives an example of applying the GRN inference algorithms to experimental CRISPR screen data, where first pre-processing and annotation is carried out. The used dataset, which is already highly filtered, can be replaced with other experimental datasets, where then care has to be taken with precprocessing and feature selection.

## 2. Documentation:
For Documentation of the usage of all the included functions see: [documentation - docs/build/html/index.html](docs/build/html/scp_infer.html)

[comment]: <> (https://html-preview.github.io/?url=https://github.com/jan-spr/scp_infer/blob/main/sphinx_doc/build/html/scp_infer.html)

## 2. Contents:
### 1. [scp_infer](src/scp_infer)
Module that cointains all of the functionality for GRN inference:
#### a. adata:
Data manipulation and annotation using Anndata/scanpy
#### b. inference:
Apllication of inference algorithms
#### c. eval:
Evaluation of predicted Networks using data-driven and biological approaches
#### d. utils:
A few utilites to help with the management e.g. of train and validation splits of Data and Evaluation of Networks on these.

### 1. [sergio_kd](src/sergio_kd)
Module that cointains the functionality for synthetic data generation using SERGIO.
spiderweb-framework 2.2.1
A small web framework, just big enough for a spider.
Requires Python: >=3.11

# spiderweb

<p align="center">
    <img
    src="https://img.shields.io/pypi/v/spiderweb-framework.svg?style=for-the-badge"
    alt="PyPI release version for Spiderweb"
    />
    <img
        src="https://img.shields.io/badge/gitmoji-%20😜%20😍-FFDD67.svg?style=for-the-badge"
        alt="Gitmoji"
    />
    <img 
        src="https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge"
        alt="Code style: Black"
    />
</p>

As a professional web developer focusing on arcane uses of Django for arcane purposes, it occurred to me a little while ago that I didn't actually know how a web framework _worked_.

So I built one.

`spiderweb` is a small web framework, just big enough to hold a spider. Getting started is easy:

```shell
uv add spiderweb-framework
# or
pip install spiderweb-framework
```

Create a new file and drop this in it:

```python
from spiderweb import SpiderwebRouter
from spiderweb.response import HttpResponse

app = SpiderwebRouter()

@app.route("/")
def index(request):
    return HttpResponse("HELLO, WORLD!")

if __name__ == "__main__":
    app.start()
```

## [View the docs here!](https://itsthejoker.github.io/spiderweb/#/)

### Development (using uv)

This repository uses uv for local development and testing.

- Create a virtual environment: `uv venv`
- Activate it (Windows): `.venv\Scripts\activate`
- Activate it (POSIX): `source .venv/bin/activate`
- Install deps (editable + dev): `uv pip install -e .[dev]`
- Run tests: `uv run python -m pytest`
- Lint/format: `uv run ruff check .` and `uv run black .`

My goal with this framework was to do three things:

  1. Learn a lot
  2. Create an unholy blend of Django and Flask
  3. Not look at any existing code. Go off of vibes alone and try to solve all the problems I could think of in my own way

And, honestly, I think I got there. Here's a non-exhaustive list of things this can do:

- Function-based views
- Optional Flask-style URL routing
- Optional Django-style URL routing
- URLs with variables in them a lá Django
- Full middleware implementation
- Limit routes by HTTP verbs
- Custom error routes
- Built-in dev server
- Gunicorn support
- HTML templates with Jinja2
- Static files support
- Cookies (reading and setting)
- Optional append_slash (with automatic redirects!)
- CSRF middleware
- CORS middleware
- Optional POST data validation middleware with Pydantic
- Session middleware with built-in session store
- Database support (using SQLAlchemy, but you can use whatever you want as long as there's a SQLAlchemy driver for it)
- Tests (currently roughly 89% coverage)