semvec/pypi-packages huggingface dataset:
CoutureCypher 0.0.2
A Cypher
Requires Python: >=3.9

# CoutureCypher
A two stage encoder made with a mix of a caesar ciphers.

To initialize call the class with and object to either decrypt or encrypt

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install Couture-Cypher.

```bash
pip install Couture-Cypher
```

## Utilization

```python
from Couture-Cypher import *

# Initializes with an initial string
cipher = cypher('initial-string')

# returns decrypted variation of the initial string
cipher.decrypt()

# returns encrypted variation of the initial string
cipher.encrypt()
```


## License

[MIT](https://choosealicense.com/licenses/mit/)
distquant 0.1.0
Distributional Quantization
Requires Python: >=3.6

# Distributional Quantization

![distquant_logo](https://github.com/Felix-Petersen/distquant/blob/main/images/distquant_logo.png?raw=true)

**Distributional quantization provides an information theoretically optimal and efficient quantization of data following a distributional prior.**

This repository includes a [pre-print of an excerpt of the distributional quantization paper](preprint.pdf).

Simulation plots can be found [here](SIMULATIONS.md).

The `distquant` package requires PyTorch and can be installed via 
```shell
pip install distquant
```


## 💻 Usage

The `distquant` package can be used to efficiently and effectively quantize tensors (e.g., embeddings to be stored or weights of a neural network) using distributional quantization.
In particular, the API of the package provides two core functions:
* `distquant.quantize(data, k=k)` for quantizing a Tensor `data` of floating point values.
* `distquant.dequantize(quantized_data, **info)` for dequantizing `quantized_data`.

In detail, the API is specified as
```python
import torch
from distquant import quantize, dequantize

data = torch.randn(10_000)

q_data, info = quantize(
    data,
    k=4,              # number of bits to quantize to; alternatively specify `n`. 
    # n=15,           # number of quantization points; mutually exclusive to `k`.
    dist='gaussian',  # distributional assumption
    packbits=True,    # Packs the results into int64, e.g., for `k=4`, there will be 16 values in each element 
                      # for storing. If set to `False`, the indices are returned in raw format.
    beta=1.0,         # Factor hyperparameter for adjusting the range of values (esp. important for small `k`).
    zero=None         # Can enforce a particular zero (by setting it to a resp. float, e.g., `0.`)
)

deq_data = dequantize(data, **info)
```

* Bitpacking (`packbits=True`) allows storing the data efficiently, e.g., 21 3-bit values can be stored in a single int64.
* `beta` may be set `None` (default), which will cause an automatic search for the optimal choice. This can be more expensive but is valuable for smaller `k` / `n`.
* Setting `dist=None` searches for the best distribution to quantize the provided data.

Supported options for `dist`: 
```python
['gaussian' 'gaussian_cdf', 'logistic', 'logistic_cdf', 'gumbel', 'gumbel_cdf', 'exponential', 'exponential_cdf', 'cauchy_cdf']
```


## 📖 Citing

```bibtex
@article{petersen2023distributional,
  title={{Distributional Quantization}},
  author={Petersen, Felix and Sutter, Tobias},
  year={2021--2023}
}
```


## 📜 License

`distquant` is released under the MIT license. See [LICENSE](LICENSE) for additional details about it.
flask-pypprof 0.1.18
Pypprof Flask wrapper
Requires Python: >=3.8,<=3.11

# flask-pypprof

Blueprint for pprof profiling endpoints a la GO's that can be added to python Flask applications. *flask-pypprof* is a wrapper of [pypprof] and based on [django-pypprof] ideas.

## Installation

```bash
pip install flask-pypprof
```

## Usage

To add the pprof endpoints to your application, simply register the blueprint:

```python
from flask_pypprof import get_pprof_blueprint

app.register_blueprint(get_pprof_blueprint())
```

Once registered, you will be able to access the following endpoints:

* `/debug/pprof/profile`: will return a CPU profile
* `/debug/pprof/heap`: will return a heap profile
* `/debug/pprof/thread`: will return a thread profile
* `/debug/pprof/wall`: will return a wall time profile(work in progress)

## Configuration

You can configure the memory sample rate by setting the following environment variable:

* `MEMORY_PROFILER_ENABLED`: enables the memory profiler (default: false)
* `MEMORY_SAMPLE_RATE`: sets the memory profiling sample rate (default: 128 * 1024)

```bash
export MEMORY_PROFILER_ENABLED = false
export MEMORY_SAMPLE_RATE = 128 * 1024
```

## Fetching profiles from your application
Fetch a 30 seconds CPU profile:

```bash
go tool pprof -http=:8088 http://localhost:8081/debug/pprof/profile?seconds=30
```

Fetch a heap profile:

```bash
go tool pprof -http=:8088 http://localhost:8081/debug/pprof/heap
```
![image_2023-05-09_16-27-22](https://github.com/dpsoft/flask-pypprof/assets/2567525/33f36ed4-0b97-44fc-89e7-2fbbbbb7132a)


## Compatibility 
Python **3.8**, **3.9**, **3.10** and Flask >= **2.0.0** and **Linux** only.
    
## Known issues
* `zprofile issue with python 3.11`:  https://github.com/timpalpant/zprofile/pull/2 
* `mprofile only works on linux/amd64 or at least linux/arm64 is not supported`. Also see timpalpant/mprofile#3.


## License
This code base is available under the Apache License, version 2.

[pypprof]: https://github.com/timpalpant/pypprof
[django-pypprof]:https://gitlab.com/prologin/tech/packages/django-pypprof
mvSPC 1.0.17
Plug and play statistical process control functions for Python
Requires Python: >=3.7

# Statistical Process Control with Python

This Python package implements various methods from the field of Statistical Process Control (SPC).

The idea of the package is to make easily available a lot of functionality from the SPC
field for Python as we feel this is not currently available in one single package.

Most of the basic functionality is based on the book "Statistical Quality Control" from 2013, 7th Edition, 
by Douglas C. Montgomery. All references to equations and otherwise are to this book if
not stated otherwise.

The aim of the functions is to have a consistent and standardized, easy-to-use API, so
that each procedure is used in roughly the same way. Some 
inspiration for this comes from the popular scikit-learn library, especially the fit() method API. 

This package contains some advanced SPC methods as well in the form of dynamic principal components analysis 
and orthogonal autoencoders.