semvec/pypi-packages huggingface dataset:
cellanova 0.1.0
Cell state space analysis of variance for signal recovery with batch correction
Requires Python: >=3.7

# CellANOVA: Cell State Space Analysis of Variance

- [Introduction](#introduction)
- [Installation](#installation)
- [Tutorials](#tutorials)
- [License](#license)



## Introduction

CellANOVA is a Python package, for batch correction with signal recovery. It contructs a pool of control samples to estimate a latent linear space that captures cell- and gene-specific unwanted variations, which can then be used to remove batch effects from cells across all samples.  By using only samples in the control pool in the estimation of the batch variation space, CellANOVA preserves any biological differences in the non-control samples that lie outside this space.  Importantly, CellANOVA produces a batch corrected gene expression matrix which can be used for gene- and pathway-level downstream analyses, and is fast and scalable to data sets containing millions of cells. 

CellANOVA can be applied to multiple settings:
* Case-control design
* Longitudinal design
* Irregular block design

For more model details, validation results and real dataset analysis, please check out our paper (to add link). If you use our method, please use the following citation:




## Installation
### Dependencies

Our Python package has been tested on python=3.7, 3.8, 3.9. It depends on numpy>=1.20.3, scipy>=1.7.1, pandas>=1.3.2, scikit-learn>=1.0.2, anndata>=0.7.6, scanpy>=1.8.1, harmonypy>=0.0.6. 

If you use conda environment, you can use the following command for an easy setup. It will build a seperate cellanova environment, and have all dependencies installed.

```bash
conda env create -f environment.yml
```

### Download



## Tutorials
### Quick Start

The following is an quick example showing CellANOVA integration pipeline.

```python
## load required package
import anndata as ad
import scanpy as sc
from cellanova import *

## load and preprocess data
adata = sc.read_h5ad('raw_data.h5ad')
adata_prep = preprocess_data(adata, integrate_key='dataidx')

## construct control pool
control_dict = {
    'pool1': list(set(adata_prep[adata_prep.obs['condition']=='control',].obs['dataidx'])),
}

## model fitting
adata_prep= calc_ME(adata_prep, integrate_key='dataidx')
adata_prep = calc_BE(adata_prep, integrate_key, control_dict)
adata_prep = calc_TE(adata_prep, integrate_key)

## create an independent anndata object for cellanova-integrated data
integrated = ad.AnnData(adata_prep.layers['denoised'], dtype=np.float32)
integrated.obs = adata_prep.obs.copy()
integrated.var_names = adata_prep.var_names
```


### Example Notebooks

For more detailed examples, please refer to the following jupyter notebooks:
 * CellANOVA integration workfolow (link)
 * Evaluation of batch removal performance (link)
 * Evaluation of distortion (link)
 * Evaluation of signal preservation (link)



## License
pythonGPT3 1.0.1
"The ChatGPT Requests module is a Python package that provides a convenient interface for making requests to the ChatGPT language model."
Requires Python: >=3.6

# pythonGPT

pythonGPT Requests Module

The pythonGPT Requests module is a Python package that provides a convenient interface for making requests to the ChatGPT language model. It abstracts away the complexity of interacting with the model's API, allowing developers to easily integrate ChatGPT into their applications.

You can ask one question by request function, or you can send a file of questions separated by a question mark to requests function, and you will get a text file with the answers.


you can have your APi key from this link after signing in
https://platform.openai.com/account/api-keys

Key Features:
- Simple API: The module provides a high-level API that simplifies the process of sending messages and receiving responses from the ChatGPT model.
- Stateful Conversations: It supports stateful conversations, enabling users to have multi-turn interactions by maintaining context across messages.
- Error Handling: The module includes robust error handling to gracefully handle API errors and timeouts, ensuring a reliable integration.

Usage Example:
```python
from pythonGPT import PythonGPT

chatgpt = ChatGPT(api_key='your-api-key')

# Making a request
response = chatgpt.request("Hello, how are you?")
print(response)

# Submit multiple requests by txt file
response = chatgpt.requests('file.txt')
print(response)




MIT License

Copyright (c) 2023 Ahmed Sheded

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
file-managers 0.24.0
A Python Package to manage your files and folders easily in different ways.

# File Managers

A Python Package to manage your files and folders easily in different ways

[![Release](https://github.com/MusfiqDehan/file-managers/actions/workflows/release.yml/badge.svg)](https://github.com/MusfiqDehan/file-managers/actions/workflows/release.yml)

[![Update Changelog](https://github.com/MusfiqDehan/file-managers/actions/workflows/changelog.yml/badge.svg)](https://github.com/MusfiqDehan/file-managers/actions/workflows/changelog.yml)

## Quick Install

```
pip3 install file-managers
```
fabric-cf 1.4.7
Fabric Control Framework
Requires Python: >=3.9
Keywords: Swagger,Fabric Control Framework

[![PyPI](https://img.shields.io/pypi/v/fabric-cf?style=plastic)](https://pypi.org/project/fabric-cf/)

# Control Framework
This repository contains Fabric Control Framework and Actor implementations.

## Overview
Fabric Control Framework has 3 actors
- Controller
- Broker
- Aggregate Manager

## Broker
Broker is an agent of CF that collects resource availability information from multiple aggregate managers and can make resource promises on their behalf. More details can be found [here](fabric_cf/broker/Readme.md)

## Aggregate Manager
AM is a CF agent responsible for managing aggregate resources. Is under the control of the owner of the aggregate. Provides promises of resources to brokers and controllers/ orchestrators. More details can be found [here](fabric_cf/authority/Readme.md)

## Orchestrator
Orchestrator is an agent of CF that makes allocation decisions (embedding) of user requests into available resources. Communicates with user to collect slice requests, communicates with broker or aggregate managers to collect resource promises, communicates with aggregate managers to provision promised resources. Creates slices, configures resources, maintains their state, modifies slices and slivers. More details can be found [here](fabric_cf/orchestrator/README.md)

## Architecture
The following diagram depicts an overall architecture for the Control Framework.
![Architecture](./images/cf.png)

## Requirements
Python 3.9+

## Build Docker Images

### Authority Docker Image
```
docker build -f Dockerfile-auth -t authority .
```

### Broker Docker Image
```
docker build -f Dockerfile-broker -t broker .
```

### Orchestrator Docker Image
```
docker build -f Dockerfile-orchestrator -t orchestrator .
```

## Configuration pre-requisites
- Kafka Configuration
  - Request topic, consumer and producer credentials for each Actor from [Song](ywsong2@g.uky.edu) 
  - Request Hosts running the Actors to be added to Kafka Brokers and Schema Registry Firewall
  - Make sure to configure consumer.group.id different for each actor
cinipy 0.0.2
An app for custom logging

# cinipy

cinipy is an app for custom logging.

## Installation

You can install the app using pip:
  
`pip install cinipy`

## Usage

```python
from cinipy import log_info, log_warning, log_error

log_info("This is an info message.")
log_warning({"key": "value", "key2": [1, 2, 3]})
log_error(["error", {"key": "value"}])
```

### Future features

- [ ] Custom Formatting
- [ ] Log handlers
  - [ ] Write logs to a file
  - [ ] Send logs to remote server
  - [ ] Stream to Elasticsearch, logstash, ...
- [ ] More configure options
- [ ] Filtering