semvec/pypi-packages huggingface dataset:
qrconsole 1.1.0
A library to display QR codes in console.
Requires Python: >=3.6

# QRConsole
A library to display QR codes in console.

## Requirements
**Pillow>=7.0.0** - Download using `python` or `python3 -m pip install "Pillow>=7.0.0"`

## Installation
### PyPI
To get the module through PyPi: `pip install qrconsole`.  
### GitHub (Pulled Repo)
To install the module by pulling the repo: `python setup.py install`.  

## How to use
QRConsole is pretty straight-forward. Provide an image, and it will return a string with the console-ified version.  
The image provided must be black-and-white. If there are greys, they will be turned into white or black depending on which they are closer to.  
A good site for creation is [this one](https://www.the-qrcode-generator.com/), since there is no rounding or styling, just b&w pixels.  
**It is recommended to keep the images as small as possible, since every pixel of the image is two characters in the console. The example image is 65x65 px.**  

## Use
### In a project
1. Initialize  
```python
from qrconsole import QRConsole
qr = QRConsole(char="@") # char = The character to use for white in the QR Code. Must have a length of 1.
```
2. Console-ify image  
There are two ways to do this. The first way is to provide a path to the image:  
```python
print(qr.consoleify(qr_img="path_to_code.png", resize_factor=1))
# `qr_img: str` - The path to the QR Code image.
# `resize_factor: float` - How much to shrink/grow the image by (`width/resize_factor`, `height/resize_factor`)
```  
And the second way is to provide a Pillow Image object:  
```python
from PIL import Image
img = Image.open("path_to_code.png")
print(qr.consoleify(qr_img=img, resize_factor=1))
# `qr_img: Image` - A Pillow Image object.
# `resize_factor: float` - How much to shrink/grow the image by (`width/resize_factor`, `height/resize_factor`)
```
Some libraries (for example the `qrcode` library) can turn codes into Images natively, so this method would be easier to use to avoid unnecessary file-writing.
### Through `python -m`
It is also possible to use QRConsole as a command line tool. After installing the package, run `python` or `python3 -m qrconsole <image path> <resize factor (optional)>`.
linearly-varying-binomial-distribution 1.0.3
computes ununiform step-increasing probability problems

# linearly varying_binomial distribution calculations

```
pip install linearly-varying-binomial-distribution
```

This is a wrapper module for the previous repo: [C PROGRAM](https://github.com/cleoold/linearly_varying_binomial_distribution_calcs)

### Description of the math

Imagine the cardpool of a ptw game looks like:

One can flip a card. there is a probability (here say 0.02) to have a prize at the beginning.
* If one does not have the prize for 50 attempts in a row, the constant (here say 0.02) will be added to the existing probability (so that the chance of having the prize is increasing) until one finally has the prize, at which point the chance will reset to the original one.

For example, one tried 52 times and there have been no successes. At this point their chance for success for the 53rd time will be 0.08. If the 53-rd try is a success, then the chance for the 54-th try will be reset to 0.02, otherwise the chance becomes 0.10. Also the maximum number of tries allowed here is calculated 99, where the chance is 1.

If he tries 60 times, we can calculate the chance of getting the prize with the following code:
```py
from lvbdist import LVBdistribution
x = LVBdistribution(
    0.02, # the starting probability 
    0.02, # the constant to add
    50    # numbr of failures before triggering the addition
)
x.have_success_within_n_attempts(60) # 0.911490

```
How about the probability they just get the prize at the 60th turn
```py
x.have_first_success_at_n(60) # 0.024964
```

We can calculate the average number of attempts they need to make to have the prize:
```py
x.have_first_success_at_n_E() # 34.59455
```

We can also calculate the average successes in 60 attempts:
```py
x.have_m_successes_within_n_attempts_E(60) # 1.443428
```

Function names are self-descriptive. Note that functions ending with `_E` are expectated values. There always exist a function without the `_E` suffix.

Refer to [the lazily generated doc](https://cdn.statically.io/gh/cleoold/linearly_varying_binomial_distribution_calcs_Python/master/doc/index.html) for all functions.


### Building

Requirements: setuptools, and any modern C compiler shall work

Clone the repository:
```bash
git clone --recurse-submodules https://github.com/cleoold/linearly_varying_binomial_distribution_calcs_Python
```

You can install the package by running
```bash
make install
```

#### Developing

(Optional) set up a virtual env
```bash
python3 -m venv . # pyvenv .
source bin/activate
```

build the package in-place in the `lvbdist` folder by running
```bash
make debugging
```
And then build the distributable:
```bash
bin/pip3 install wheel
make release
```
varfilter 1.0.0a10
filtra variables de distintas fuentes
Requires Python: >=3.6

# pyVarfilter

Simplificación de obtención de variables del exterior, y filtrado básico.

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

### Prerequisites

python3 >= 3.5
python3-pip
pylama
bandit3


## Deployment

pip3 install pyVarfilter


## Authors

* **Esteban Barón** - *Initial work* - [gomibaya](https://github.com/gomibaya)


## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details
Dellingr 0.9.5
Error supression and variant calling pipeline for Illumina sequencing data
Requires Python: >=3.5

[![Build Status](https://travis-ci.org/morinlab/Dellingr.svg?branch=master)](https://travis-ci.org/morinlab/Dellingr)

# Dellingr
An error supression and variant calling pipeline for Second-Generation sequencing data

## Description

See the full wiki page for more information: http://produse.readthedocs.io/en/latest/

## Installation 

### Dependencies

You will need to install the following before installing Dellingr:

* `python>=3.5`
* `bwa>=0.7.0`
* `samtools>=1.3.1`

Dellingr will check these dependencies prior to running the pipeline

To install the Dellingr package run the following command:

### Install using the Python Package Index (PyPI)
```bash
pip install Dellingr
```

### Install from Github
```bash
git clone https://github.com/morinlab/Dellingr.git
cd Dellingr
python setup.py install
```
All required python dependencies will be installed during this step

## Running Dellingr

### The Analysis Pipeline: Very Quick Start

You can view more detailed instructions on the [wiki](http://produse.readthedocs.io/en/latest/)

All parameters required to run ProDuSe can be viewed using the following:
```bash
    dellingr run_dellingr -h
```

Alternatively, if you wish to run Dellingr without installing it, you can run `DellingrPipeline.py` manually in a similar manner:
```bash
    /path/to/Dellingr/DellingrPipeline.py -h
```

While these parameters can be specified individually, they can also be provided using a configuration file

To run the analysis pipeline you simply need to run the following command:
```bash
    dellingr run_dellingr
    -c /path/to/github/clone/etc/dellingr_config.ini
```

Alternatively:
```bash
    /path/to/Dellingr/DellingrPipeline.py 
    -c /path/to/github/clone/etc/dellingr_config.ini
```

This will run the entire Dellingr pipeline on all samples specified in the sample_config.ini file, which can be found in 
etc/sample_config.ini

Results will be located in the following directory:

```bash
ls ./dellingr_analysis_directory
```

### Helper Scripts

The Dellingr package is comprised of several stages to aid in the analysis of duplex sequencing data.

These stages can be be viewed by running the following:

```bash
dellingr -h
```

#### dellingr adapter_predict

If you need to confirm the expected adapter sequence of a sample you should run the following command:

```bash
dellingr adapter_predict -i input1.fastq input2.fastq
```

This tool will print a predicted adapter sequence based off of ACGT abundances at each position. It uses these observed abundances and finds the closest expected abundance for an IUPAC unambiguous or ambiguous base.

#### External links
[The Morin Laboratory at SFU](https://morinlab.github.io/team/)