semvec/pypi-packages huggingface dataset:
pixelator 1.3.0
Pixelate images to a specified size and color palette for AI/ML and various other purposes
Requires Python: >=3.7

Pixelator
==========
A simple python package to pixelate images given a color palette

Features
--------

- Users can:
  1. Load in array data, image files or capture directly from a camera
  2. Pixelate images to a specific color palette and image resolution
  3. Access pixelated array data or write it back to an image file

Technical Docs
--------
https://connor-makowski.github.io/pixelator/pixelator/pixelator.html

Setup
----------

Make sure you have Python 3.6.x (or higher). You can download it [here](https://www.python.org/downloads/).

### Installation

```
pip install pixelator
```

### Getting Started
Import the pixelator into your project
```
from pixelator import Pixelator
```

Some important notes:
- All data is stored and processed as BGR (to match open cv2)
  - EG: Provided pallettes should be in BGR

### Examples

Load from a file:
```
from pixelator import Pixelator
# Use the input filename provided
image = Pixelator(filename='./images/input.jpg')
# Pixelate the image to a 28x28 black and white array
pixelated_image = image.pixelate(
    width=28,
    height=28,
    palette=[[0,0,0],[255,255,255]]
)
# Write to `output.png` scaled up to a 300x300 image (to be easily viewed)
pixelated_image.write(filename='./images/output_test_1.jpg', width=300, height=300)
```
Input:
![](images/input.jpg)

Output:
![](images/output_test_1.jpg)

Capture from a webcam:
```
from pixelator import Pixelator
# Capture from a webcam since no data or filename is provided
image = Pixelator()

# Pixelate the image to a 64x64 black, white and multiple gray array
pixelated_image = image.pixelate(
    width=64,
    height=64,
    palette=[[0,0,0],[80,80,80],[160,160,160],[200,200,200],[255,255,255]]
)
# Write to `output.png` scaled up to a 500x500 image (to be easily viewed)
pixelated_image.write(filename='./images/output_test_3.jpg', width=300, height=300)
```
![](images/output_test_3.jpg)

Access Pixelator Data:
```
from pixelator import Pixelator
# Use the input filename provided
image = Pixelator(filename='./images/input.jpg')
# Pixelate the image to a 28x28 black and white array
pixelated_image = image.pixelate(
    width=28,
    height=28,
    palette=[[0,0,0],[255,255,255]]
)
# Show pixelated image data
print(pixelated_image.data)
# Show Color Counts:
print(pixelated_image.get_color_counts())
```
consgfx 0.0.2
Python console graphics display with Sixels and Kitty
Requires Python: >=3.8

## Development

```
python3 -m venv .venv
source .venv\Scripts\activate.bat
pip install git+https://github.com/wjakob/nanobind 'scikit-build-core[pyproject]'
pip install --no-build-isolation -ve .
```

### Configuring the libsixel build

```
meson setup --reconfigure \
    -Dimg2sixel=enabled \
    -Dgdk-pixbuf2=disabled \
    -Dgd=disabled \
    -Dlibcurl=disabled \
    -Dpng=disabled \
    -Djpeg=disabled \
    build
```
test-package-ibonn-20240129 0.0.1
This is a test package
Requires Python: >=3.8

# test_package_ibonn_20240129

This is a test package

![PyPI - Python Version](https://img.shields.io/pypi/v/test_package_ibonn_20240129)
![PyPI - Downloads](https://img.shields.io/pypi/dm/test_package_ibonn_20240129)
cpcat 0.1
A portable, scalable, and fast AI Data Lakehouse.
Requires Python: >=3.9

![deltacat-header-logo](media/deltacat-logo-alpha.png)

DeltaCAT is a portable Multimodal Data Lakehouse powered by [Ray](https://github.com/ray-project/ray). It lets you define and manage
fast, scalable, ACID-compliant Multimodal data lakes, and has been used to [successfully manage exabyte-scale enterprise
data lakes](https://aws.amazon.com/blogs/opensource/amazons-exabyte-scale-migration-from-apache-spark-to-ray-on-amazon-ec2/).

It uses the Ray distributed compute framework together with [Apache Arrow](https://github.com/apache/arrow) and
[Daft](https://github.com/Eventual-Inc/Daft) to efficiently scale common table management tasks, like petabyte-scale
merge-on-read and copy-on-write operations.

DeltaCAT provides four high-level components:
1. **Catalog**: High-level APIs to create, discover, organize, and manage datasets.
2. **Compute**: Distributed data management jobs to read, write, and optimize datasets.
3. **Storage**: In-memory and on-disk multimodal dataset formats.
4. **Sync**: Synchronize DeltaCAT datasets with other data warehouses and table formats.


## Getting Started

DeltaCAT is rapidly evolving. Usage instructions will be posted here soon!

For now, feel free to peruse some of our examples:
* https://github.com/ray-project/deltacat/tree/2.0/deltacat/examples/rivulet
* https://github.com/ray-project/deltacat/tree/2.0/deltacat/examples/iceberg