semvec/pypi-packages huggingface dataset:
ndata 0.1.4
Automated Data Preprocessing Library
Requires Python: >=3.6

# Ndata

Ndata is a Python library for automating common data preprocessing tasks, such as missing value imputation, feature scaling, categorical encoding, and outlier detection.

## Features

- **Handle Missing Values**: Automatically fill missing values using strategies like mean, median, or a constant.
- **Scale Numerical Features**: Standardize or normalize your data.
- **Encode Categorical Variables**: Easily convert categorical features into numerical form.
- **Detect and Remove Outliers**: Use Z-score or IQR methods to handle outliers.

## Installation

You can install Ndata from PyPI:

```bash
pip install ndata
qr-code-reader 1.1.5
A simple QR code reader
Requires Python: >=3.6


# QR Code Reader

A simple Python package for reading QR codes from input and managing a queue.

## Installation

```bash
pip install qr_code_reader
```
## USAGE
```bash
 qr_reader = QRCodeReader(queue.Queue())
 codebarre = qr_reader.Read()
```
keelib 0.1.3
KEE by Jaegerwald, but as a library.
Requires Python: >=3.6

<h1 align="center"><img src="https://raw.githubusercontent.com/TheZoidMaster/KEELib/refs/heads/main/graphics/kee_github.svg" height="256px"><br>KEELib</h1>

<p align="center"><strong>An unoffical KEE library.</strong></p>

# Topics

1. [About](#about)
2. [Installation](#installation)
3. [Usage](#usage)
    - [Encrypting/Decrypting files with a key](#encryptingdecrypting-files-with-a-key)
4. [License](#license)

# About

> "KEE is a joke turned real project. Originally I wanted to have my own cipher system (similar to a caesar cipher) for some of my friends, but then I moved on to ciphering on a binary level, and it became more of an encryption system. After a bit of back-and-forth messaging, I decided to actually make an encryption system and language." - [JaegerwaldDev](https://github.com/JaegerwaldDev)

KEELib is an unoffical KEE library. The original project is [here](https://github.com/JaegerwaldDev/KEE).

Please show Jae some support and star the KEE repo if you like it.

# Installation

To install KEELib, simply run `pip install keelib`.

It has only been tested on Python 3.11 and 3.12 at the time of writing.

# Usage

~~This section will explain every feature of KEE and XKEE, if you want to skip to certain parts, look [here](https://github.com/JaegerwaldDev/KEE/tree/main?tab=readme-ov-file#topics)!~~

This section will only explain how to use the library. To learn how to use XKEE and KEE, please refer to [KEE](https://github.com/JaegerwaldDev/KEE).

## Encrypting/Decrypting files with a key

Encrypting/Decrypting files with a key is simple. First set up an encryptor with your KEE file.

```py
from keelib import Encryptor
encryptor = Encryptor(key_path)
```

Then you can encrypt/decrypt files with the encryptor.

```py
encryptor.encrypt_file(input_file_path, output_file_path)
encryptor.decrypt_file(input_file_path, output_file_path)
```

# License

This work is licensed under a
[Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License][cc-by-nc-sa].

[![CC BY-NC-SA 4.0][cc-by-nc-sa-image]][cc-by-nc-sa]

[cc-by-nc-sa]: http://creativecommons.org/licenses/by-nc-sa/4.0/
[cc-by-nc-sa-image]: https://licensebuttons.net/l/by-nc-sa/4.0/88x31.png
tw-vid 0.1.0
A simple library for extracting and corrupting frames from videos.
Requires Python: >=3.6

# tw_vid

A simple library for extracting and corrupting frames from videos.

## Installation

`pip install tw_vid`

> [!NOTE]
> This has only been tested on Python 3.11 and 3.12.

## Usage

See [example.py](https://github.com/Martyrdome/12Vid/blob/main/example.py).
synaptogen 0.2.0
A fast generative model for stochastic memory cells
Requires Python: >=3.8

# Synaptogen.py

This is a quick translation of Synaptogen into Python.

The code is not highly optimized and is considerably slower than the Julia version.

## Installation

```
pip install synaptogen
```

## Examples

This basic example does the following:
- Initialize a million memory cells (in their high resistance states)
- Apply -2 V to each cell, putting them into their low resistance states
- Apply a random voltage to each cell
- Make a current readout of all the cells individually (at a default of 0.2 V)
- Perform a "Vector Matrix Multiplication" by 1024×1024 crossbar readout


```python
from synaptogen import *
import numpy as np
M = 1024 * 1024
cells = CellArrayCPU(M)

applyVoltage(cells, -2)

voltages = np.random.randn(M)
applyVoltage(cells, voltages)

I = Iread(cells)

col_voltages = np.random.randn(2**5) * .2
row_currents = cells @ col_voltages
```
velociraptor-python 0.18.0
Velociraptor catalogue reading routines.
Requires Python: >3.10.0

Velociraptor Python Library
===========================

[![Documentation Status](https://readthedocs.org/projects/velociraptor-python/badge/?version=latest)](https://velociraptor-python.readthedocs.io/en/latest/?badge=latest)

[Velociraptor](http://github.com/pelahi/velociraptor-stf) catalogues provide
a signifciant amount of information, but applying units to it can be painful.
Here, the `unyt` python library is used to automatically apply units to
velociraptor data and perform generic halo-catalogue reduction. This library
is primarily intended to be used on [SWIFT](http://swiftsim.com) data that
has been post-processed with velociraptor, but can be used for any
velociraptor catalogue.

The internals of this library are based heavily on the internals of the
[`swiftsimio`](http://github.com/swiftsim/swiftsimio) library, and essentially
allow the velociraptor catalogue to be accessed in a lazy, object-oriented
way. This enables users to be able to reduce data quickly and in a
computationally efficient manner, without having to resort to using the
`h5py` library to manually load data (and hence manually apply units)!

Requirements
------------

The velociraptor library requires:

+ `unyt` and its dependencies
+ `h5py` and its dependencies
+ `python3.6` or above

Note that for development, we suggest that you have `pytest` and `black`
installed. To create the plots in the example directory, you will need
the plotting framework `matplotlib`.

Installation
------------

You can install this library from PyPI using:
```
pip3 install velociraptor
```

Documentation
-------------

Full documentation is available on [ReadTheDocs](https://velociraptor-python.readthedocs.io/).

Why a custom library?
---------------------

This custom library, instead of something like `pandas`, allows us to
only load in the data that we require, and provide significant
context-dependent features that would not be available for something
generic. One example of this is the automatic labelling of properties,
as shown in the below example.

```python
from velociraptor import load
from velociraptor.tools import get_full_label

catalogue = load("/path/to/catalogue.properties")

stellar_masses = catalogue.apertures.mass_star_30_kpc
stellar_masses.convert_to_units("msun")

print(get_full_label(stellar_masses))
```
This outputs "Stellar Mass $M_*$ (30 kpc) $\left[M_\odot\right]$", which is
easy to add as, for example, a label on a plot.