semvec/pypi-packages huggingface dataset:
pyprinty 2.1.0
Extensions to the print command and strings in general.
License: MIT
Requires Python: >=3.8
Keywords: print, terminal, text, output, effects, colors, strings, str, fonts, console

```text
██████╗ ██╗   ██╗██████╗ ██████╗ ██╗███╗   ██╗████████╗██╗   ██╗
██╔══██╗╚██╗ ██╔╝██╔══██╗██╔══██╗██║████╗  ██║╚══██╔══╝╚██╗ ██╔╝
██████╔╝ ╚████╔╝ ██████╔╝██████╔╝██║██╔██╗ ██║   ██║    ╚████╔╝
██╔═══╝   ╚██╔╝  ██╔═══╝ ██╔═══╝ ██║██║╚██╗██║   ██║     ╚██╔╝
██║        ██║   ██║     ██║     ██║██║ ╚████║   ██║      ██║
╚═╝        ╚═╝   ╚═╝     ╚═╝     ╚═╝╚═╝  ╚═══╝   ╚═╝      ╚═╝
```
# version 2.1.0.


## Description:
Extensions for printing and strings in general.
Create simple animations, loading bars, manage user messages in custom fonts.
Text designs, and special prints.
And all - by yourself.

## Documentation:
For documentation via github [Click here.](https://yedist.github.io/pyprinty/)

## license:
MIT © 2025 Yedidya steinmetz

## simple example:

```text
from pyprinty import Font, Fonts


my_font = Font(load=Fonts.CLASSIC) #  Creating a font, using a ready-made font

# Printing a message to the user from the font we created
print(my_font("hello ", input("What is your name?"), sep=" "), end="!")

# You don't have to use ready-made fonts, you can create your own, and much more!

```

## little more:
This is just a part:
```text
from pyprinty import Font, Fonts
from pyprinty import Colors, Color
from pyprinty import Effects, Cursor
from pyprinty import Animation
from pyprinty import size


# Creating the fonts:
my_font = Font(
    text_color=Colors.RED,  # Ready color
    base_color=Color(0, 255, 0),  # Background color, Custom color
    effects=[Effects.Bold, Effects.Speedblink]  # Two ready-made effects
)
error_font = Font(load=Fonts.ERROR)  # Creating a font and loading ready-made font settings Error
# Creating a management animation of the prints
my_animation = Animation(
    load={  # Loading by dict, this can also be done in font
        # Creates an animated object, sets the font, and makes it into a normal print mode.
        "message": {"font": my_font, "mode": "print"}
    }
)
# Adding an object manually, on glossy print mode
my_animation.add_font("error", error_font, mode="glare")
# Using the message object we created
my_animation.send(
    "message",  # the object
    "hello", input("What is your name?"),  # the text
    sep=" ", end=""  # The library preserves all parameters.
)
Cursor.PRINT(Cursor.CLEAR_ALL)  # Reset the entire terminal (there are many more such commands)
# Demonstration of printing via the print command using the error font
print(
    error_font(
        # Print the current line size and number of lines of the terminal
        "your consul size is", size(), sep=" "
    ),
    end="!"
)
# There's a lot more in this library!

```
pixelatelib 0.1.0
Learn image processing by building it. A NumPy-based library that exposes both naive and optimized algorithms for side-by-side understanding.
License: MIT
Requires Python: >=3.10

# Pixelate
[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/)

Pixelate is an educational image processing library built to compare naive loop-based algorithms with their vectorized NumPy counterparts. Each operation has a `slow` and `fast` implementation so you can explore the performance and readability differences between the two styles.

## Features

- **Pixel Operations**: invert colors, convert to grayscale, and adjust brightness.
- **Geometric Transformations**: horizontal flip and nearest-neighbor resize.
- **Convolution Filters** for applying arbitrary kernels.
- **Utilities** for loading and saving images via Pillow.
- Ready-to-run **benchmarks** and **tests** demonstrating correctness and speed differences.

The modules are organized so that every function has a matching fast (vectorized) and slow (naive) version:

```
pixelate/
  fast/
    filters.py
    pixel_ops.py
    transformations.py
  slow/
    filters.py
    pixel_ops.py
    transformations.py
  utils/
    helpers.py
    image_io.py
```

## Installation

Clone the repository and install the requirements:

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

You can also install the package directly:

```bash
pip install pixelate
```

The project requires Python 3.10 or newer.

## Usage Example

```python
import numpy as np
from pixelate.fast.pixel_ops import invert_color_fast
from pixelate.slow.pixel_ops import invert_color_slow
from pixelate.utils.image_io import load_image, save_image

img = load_image("path/to/image.png")

# Compare slow and fast implementations
slow_result = invert_color_slow(img)
fast_result = invert_color_fast(img)

save_image(fast_result, "out_fast.png")
```

Check the `benchmarks/` folder for scripts that measure execution time for the slow and fast versions of each operation.

## Running Tests

Use `pytest` to run the unit tests:

```bash
pytest
```

## License

Pixelate is distributed under the MIT License. See the [LICENSE](LICENSE) file for details.