semvec/pypi-packages huggingface dataset:
pyluxa4 1.7
Luxafor flag control library/tool.
Requires Python: >=3.8
Keywords: luxafor

# Python Luxafor

> **warning**
> This library has only been tested on the [Luxafor Flag](https://luxafor.com/product/flag/). It may or may not work on
> other devices.

`pyluxa4` is a Python library for controlling [Luxafor](https://luxafor.com/) devices. You can set colors, blink them,
fade them, apply a wave effect, and even run its built-in patterns. All of this is done by running a small server that
is accessed locally on port 5000 (the port can be changed). Once running, you can issue commands from the CLI tool,
which in turns communicates with the server using a REST API.

Since the server uses a REST API, you could easily write scripts in other languages to control the device once running.

If desired, you can import the `pyluxa4.usb` library in a script and control the device directly without running a
server. Or you could import `pyluxa4.client` and write your own application that uses the REST API to control the device
through the server.

`pyluxa4` requires [libusb/hidapi](https://github.com/libusb/hidapi) to be installed in order for the controller portion
of the library to be functional.

## Documentation

Documentation is found here: https://facelessuser.github.io/pyluxa4/

## License

MIT License
cinemaot 0.0.5
Causal INdependent Effect Module Attribution + Optimal Transport
Requires Python: >=3.7

# Causal INdependent Effect Module Attribution + Optimal Transport (CINEMA-OT)

CINEMA-OT is a **causal** framework for perturbation effect analysis to identify **individual treatment effects** and **synergy** at the **single cell** level.

## Architecture

<img width="1460" alt="image" src="https://user-images.githubusercontent.com/68533876/228745549-8328ea36-25c6-4665-9c68-bab1e1a78ef9.png">


Read our preprint on bioRxiv:

- Dong, Mingze, et al. "Causal identification of single-cell experimental perturbation effects with CINEMA-OT". bioRxiv (2022).
[https://www.biorxiv.org/content/10.1101/2022.07.31.502173v3](https://www.biorxiv.org/content/10.1101/2022.07.31.502173v3)

## System requirements
### Hardware requirements
`CINEMA-OT` requires only a standard computer with enough RAM to perform in-memory computations.
### OS requirements
The `CINEMA-OT` package is supported for all OS in principle. The package has been tested on the following systems:
* macOS: Monterey (12.4)
* Linux: RHEL Maipo (7.9), Ubantu (18.04)
### Dependencies
See `setup.cfg` for details.

## Installation
CINEMA-OT requires `python` version 3.7+.  Install directly from pip with:

    pip install cinemaot

The installation should take no more than a few minutes on a normal desktop computer.


## Usage

For detailed usage, follow our step-by-step tutorial here:

- [Getting Started with CINEMA-OT](https://github.com/vandijklab/CINEMA-OT/blob/main/cinemaot_tutorial.ipynb)

Download the data used for the tutorial here:

- [Ex vivo stimulation of human peripheral blood mononuclear cells (PBMC) with interferon](https://drive.google.com/file/d/1A3rNdgfiXFWhCUOoUfJ-AiY7AAOU0Ie3/view?usp=sharing)
Pillows 0.0.13
Pillows
Keywords: python

Description:
Pillows is a versatile Python package designed to streamline the generation of random numbers for a wide array of applications. Whether you're involved in simulations, data augmentation, or any project requiring randomness, Pillows offers an intuitive and efficient solution.

Key Features:

Seamless Integration: Easily integrate Pillows into your Python projects with a straightforward and well-documented API. The package is crafted to be user-friendly, simplifying the process of random number generation.

Customization Options: Tailor the randomness to your specific needs with a variety of customization options. Set seed values for reproducibility, define ranges, and choose from different probability distributions to fine-tune the generated numbers according to your project requirements.

Diverse Distributions: Pillows supports a range of probability distributions, including uniform, normal, exponential, and more. This diversity ensures that you can simulate various scenarios accurately and efficiently.

Efficient Performance: The package is optimized for performance, ensuring that random number generation is both fast and resource-efficient. This is particularly crucial for applications involving large datasets or simulations.

Statistical Validity: Pillows adheres to statistical best practices to ensure the generated random numbers exhibit the desired statistical properties. This ensures that your simulations and experiments accurately reflect real-world scenarios.

Documentation and Examples: Comprehensive documentation and illustrative examples are provided to guide users through the package's functionality. Whether you are a beginner or an experienced developer, getting started with Pillows is a breeze.

Active Community Support: Join a vibrant community of users and developers to exchange ideas, seek assistance, and contribute to the continuous improvement of Pillows. Stay updated with the latest developments and best practices in random number generation.
asaas_sqs_module 0.0.2
SQS Module
Requires Python: >=3.10,<4.0


# Welcome to your CDK Python project!

This is a blank project for CDK development with Python.

The `cdk.json` file tells the CDK Toolkit how to execute your app.

This project is set up like a standard Python project.  The initialization
process also creates a virtualenv within this project, stored under the `.venv`
directory.  To create the virtualenv it assumes that there is a `python3`
(or `python` for Windows) executable in your path with access to the `venv`
package. If for any reason the automatic creation of the virtualenv fails,
you can create the virtualenv manually.

To manually create a virtualenv on MacOS and Linux:

```
$ python3 -m venv .venv
```

After the init process completes and the virtualenv is created, you can use the following
step to activate your virtualenv.

```
$ source .venv/bin/activate
```

If you are a Windows platform, you would activate the virtualenv like this:

```
% .venv\Scripts\activate.bat
```

Once the virtualenv is activated, you can install the required dependencies.

```
$ pip install -r requirements.txt
```

At this point you can now synthesize the CloudFormation template for this code.

```
$ cdk synth
```

To add additional dependencies, for example other CDK libraries, just add
them to your `setup.py` file and rerun the `pip install -r requirements.txt`
command.

## Useful commands

 * `cdk ls`          list all stacks in the app
 * `cdk synth`       emits the synthesized CloudFormation template
 * `cdk deploy`      deploy this stack to your default AWS account/region
 * `cdk diff`        compare deployed stack with current state
 * `cdk docs`        open CDK documentation

Enjoy!