semvec/pypi-packages huggingface dataset:
deadleaves 0.1.1
A package to generate dead leaves images.
Requires Python: >=3.12

# DeadLeaves

<p align=center>
An open-source Python package for creating dead leaves images in a systematic, yet flexible way.
</p>

[![Tests](https://github.com/ag-perception-wallis-lab/deadleaves/actions/workflows/test.yml/badge.svg)](https://github.com/ag-perception-wallis-lab/deadleaves/actions/workflows/test.yml)
[![Py versions](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
[![Documentation Status](https://readthedocs.org/projects/deadleaves/badge/?version=latest)](https://deadleaves.readthedocs.io/en/latest/?badge=latest)

<p align=center>
<img src=docs/_static/logo_dead_leaves.png width=300>
</p>


## Core functionalities

- generating dead leaves images with properties (e.g. sizes, orientations, colors) drawn from a wide range of distributions (e.g. uniform, normal, Poisson, power-law, constant) or directly from an image.
- picking from various leaf shapes (circles, ellipsoids, rectangles, regular polygons).
- sampling in different color spaces (RGB, HSV, Gray-scale).
- applying different noise or image textures, either to the entire image or per-leaf.
- varying the image area covered by leaves, i.e. choosing between sparser or denser sampling and position mask.
- creating arbitrarily complex leaf configurations by adding dependencies between leaf features (e.g. space-dependent color gradients).

![](docs/_static/figures/examples.png)

## Installation

You may install `deadleaves` from PyPI using `pip`:

```
pip install deadleaves
```

OR (for developers), install from source:

1. Clone the repository from GitHub:
```
git clone git@github.com:ag-perception-wallis-lab/deadleaves.git
```
2. Install `deadleaves` to your local python library using pip, by running from the top-level directory:
```
pip install .
```
To install in developer/editable mode run `pip install -e .` at the root directory. 
This makes changes to files immediately usable, rather than having to reinstall the package after every change.


## Dependencies

We recommend using a Python version `3.12` or newer.
The dependencies should be automatically installed (at least using `pip`). `deadleaves`s required dependencies are: 

- [PyTorch](https://pytorch.org/)
- [Torchquad](https://torchquad.readthedocs.io/en/main/)
- [Torchvision](https://docs.pytorch.org/vision/stable/index.html)
- [Pandas](https://pandas.pydata.org/)
autoinput-makssem13 1.1
Easier input for Python
Requires Python: >=3.9

# Autoinput
This library is for easier input in Python. It is 100% that you don't want to do this:

```Python
while 1:
      try:
          x = int(input())
          break
      except:
          print("Please input a number")
```

because it is 6 lines when you can have 1 line:

```Python
x = autoinput("", autoinput_type.INTEGER)
```

and everything is inside the function. No work by hands.

## how to use
Here is the definition

```Python
def autoinput(outstring: str, typeel, pipe_in: Callable[[str], str]=input, pipe_out: Callable[[str], None]=print, pipe_out_end_name: str="end", parser=None) -> Any:
```

First argument  - `outstring`, string to show.

Second argument - `typeel`, use autoinput_type enum to form this (example: `autoinput_type.INTEGER | autoinput_type.ARRAY`)

kwargs:

  `pipe_in`  - for custom input function (for example if you use GUI)

  `pipe_out` - for custom output function

  `parser`   - for custom parser (don't use with `autoinput_type` except of `autoinput_type.ARRAY`)

  `pipe_out_end_name` - if your custom output function doesn't have parameter like `print`'s `end` use `None`, if has but called not `end` use the parameter to specify the name.
boto3-errors 0.1.2
Typed, statically-importable exception classes for every AWS service
Requires Python: <3.15,>=3.10
Keywords: aws, boto3, botocore, errors, exceptions, types

# (Better) boto3 errors

[![Python 3.10 | 3.11 | 3.12 | 3.13 | 3.14](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue.svg)](https://www.python.org/downloads/)
[![PyPI](https://img.shields.io/pypi/v/boto3_errors.svg)](https://pypi.org/project/boto3_errors/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Typed, statically-importable exception classes for every AWS service.

## Install

```bash
pip install boto3-errors
```

## Quick start

```python
import boto3
from boto3_errors import patch_client
from boto3_errors.dynamodb import ConditionalCheckFailedException

client = boto3.client("dynamodb")
patch_client(client)

try:
    client.put_item(
        TableName="users",
        Item={"pk": {"S": "user#1"}, "name": {"S": "Ada"}},
        ConditionExpression="attribute_not_exists(pk)",
    )
except ConditionalCheckFailedException as e:
    print(e.message)  # "The conditional request failed"
    print(e.error_code)  # "ConditionalCheckFailedException"
    print(e.item)  # {"pk": {"S": "user#1"}, "name": {"S": "Ada"}}
```

## The problem

Every boto3 error comes back as a `ClientError`. The only way to distinguish them is by parsing `e.response["Error"]["Code"]` — a stringly-typed dict lookup with no autocomplete, no type checking, and no IDE support. A typo in the error code string won't be caught until it crashes.

## What you get

All AWS services with exception classes auto-generated from botocore's service model.

### Exception hierarchy

```text
ClientError                     # botocore base — still works
└── Boto3Error                  # boto3-errors base
    └── DynamoDBError           # per-service base
        ├── ConditionalCheckFailedException
        ├── ResourceNotFoundException
        ├── TransactionCanceledException
        └── ...
```

Every exception is a `ClientError` subclass, so existing `except ClientError` handlers keep working.

### Built-in properties

Every `Boto3Error` exposes:

| Property | Type | Source |
| ------------------ | ----- | ----------------------------------- |
| `message` | `str` | `Error.Message` |
| `error_code` | `str` | `Error.Code` |
| `http_status_code` | `int` | `ResponseMetadata.HTTPStatusCode` |
| `request_id` | `str` | `ResponseMetadata.RequestId` |

### Service-specific properties

Some exceptions expose extra fields from the API response:

```python
from boto3_errors.dynamodb import (
    ConditionalCheckFailedException,
    TransactionCanceledException,
)

# ConditionalCheckFailedException.item -> dict | None
# TransactionCanceledException.cancellation_reasons -> list | None
```
vtlengine 1.5.0
Run and Validate VTL Scripts
Requires Python: >=3.9
Keywords: vtl, sdmx, vtlengine, Validation and Transformation Language

# VTL Engine

|              |                                                                                                                                                                                |
|--------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Testing      | [![Testing](https://github.com/Meaningful-Data/vtlengine/actions/workflows/testing.yml/badge.svg)](https://github.com/Meaningful-Data/vtlengine/actions/workflows/testing.yml) |
| Package      | [![PyPI Latest Release](https://img.shields.io/pypi/v/vtlengine.svg)](https://pypi.org/project/vtlengine/)                                                                     |
| License      | [![License - AGPL 3.0](https://img.shields.io/pypi/l/vtlengine.svg)](https://github.com/Meaningful-Data/vtlengine/blob/main/LICENSE.md)                                        |
| Mentioned in | [![Mentioned in Awesome Official Statistics ](https://awesome.re/mentioned-badge.svg)](https://github.com/SNStatComp/awesome-official-statistics-software)                                               |

## Introduction

The VTL Engine is a Python library that allows you to validate, format and execute VTL scripts.

It is a Python-based library around
the [VTL Language 2.1](https://sdmx-twg.github.io/vtl/2.1/html/index.html).

## Useful Links

- [MeaningfulData: who we are](https://www.meaningfuldata.eu)
- [Documentation](https://docs.vtlengine.meaningfuldata.eu)
- [Source Code](https://github.com/Meaningful-Data/vtlengine)
- [Bug Tracker](https://github.com/Meaningful-Data/vtlengine/issues?q=is%3Aopen+is%3Aissue+label%3Abug)
- [New features Tracker](https://github.com/Meaningful-Data/vtlengine/issues?q=is%3Aopen+is%3Aissue+label%3Aenhancement)

## Installation

### Requirements

The VTL Engine requires Python 3.9 or higher.

### Install with pip

To install the VTL Engine on any Operating System, you can use pip:

```bash

pip install vtlengine

```

*Note: it is recommended to install the VTL Engine in a virtual environment.*

### S3 extra

If you want to use the S3 functionality, you can install the VTL Engine with the `s3` extra:

```bash
pip install vtlengine[s3]
```

## Documentation

The documentation for the VTL Engine is available
at [docs.vtlengine.meaningfuldata.eu](https://docs.vtlengine.meaningfuldata.eu).
AQLES 0.1.0
Anti Quantum Leak Encryption System CLI & Library
Requires Python: >=3.8

**# AQLES**



**\*\*AQLES (Anti Quantum Leak Encryption System)\*\* is a high-security encryption system designed to resist attacks even from quantum computers.**  

**It provides both a Python library and a command-line interface (CLI) for encrypting and decrypting messages using a 256-character key hashed in multiple layers.**



**---**



**## Features**



**- Multi-layered key derivation:**

  **- 256-character initial key**

  **- Each character hashed individually**

  **- Combined hashes hashed again to create the final key**

**- Encryption with AES-256 (future support for SPHINCS+ post-quantum cryptography)**

**- CLI support: encrypt and decrypt messages directly from the terminal**

**- Python library support for integration into other projects**

**- Designed to be future-proof against quantum attacks**



**---**



**## Installation**



**Install AQLES directly from PyPI:**



**```bash**

**pip install AQLES**
growingupvideo-slideshow 1.0.0
Generate HTML slideshows from photos with smooth CSS transitions
Requires Python: >=3.8
Keywords: slideshow, photo, image, transition, growing-up, growingupvideo, html-slideshow, gallery, css-transitions, timeline, before-after

# growingupvideo-slideshow

Generate self-contained HTML slideshows from photos with smooth CSS transitions. Zero dependencies.

Perfect for showcasing growing-up photo collections, before-and-after timelines, or any image sequence.

[![PyPI version](https://badge.fury.io/py/growingupvideo-slideshow.svg)](https://pypi.org/project/growingupvideo-slideshow/)

## Installation

```bash
pip install growingupvideo-slideshow
```

## CLI Usage

```bash
growingupvideo-slideshow baby.jpg toddler.jpg teen.jpg adult.jpg -o growing-up.html
```

Options:

| Flag | Description | Default |
|------|-------------|---------|
| `-o, --output` | Output HTML file | `slideshow.html` |
| `-t, --transition` | `fade`, `slide`, or `zoom` | `fade` |
| `-i, --interval` | Slide interval in ms | `3000` |
| `-d, --duration` | Transition duration in ms | `800` |
| `--title` | Page title | `Photo Slideshow` |
| `--no-autoplay` | Disable auto-advance | |
| `--no-controls` | Hide prev/next buttons | |

## Python API

```python
from growingupvideo_slideshow import generate_slideshow, create_slideshow_file

# Generate HTML string
html = generate_slideshow(
    ["baby.jpg", "child.jpg", "teen.jpg", "adult.jpg"],
    transition="fade",
    interval=4000,
    title="Growing Up",
)

# Or write directly to file
create_slideshow_file(
    ["photo1.jpg", "photo2.jpg", "photo3.jpg"],
    "my-slideshow.html",
    transition="zoom",
    interval=3000,
)
```

### Using URLs

```python
html = generate_slideshow(
    ["https://example.com/photo1.jpg", "https://example.com/photo2.jpg"],
    transition="slide",
)
```

## Transitions

- **fade** — Smooth opacity crossfade
- **slide** — Horizontal slide with fade
- **zoom** — Subtle zoom-out reveal

## Output

Generates a single self-contained HTML file with:
- Embedded base64 images (for local files) or image URLs
- CSS transitions (no JavaScript animation libraries)
- Keyboard navigation (arrow keys)
- Responsive design

## Use Cases

- **Growing-up timelines** — Baby to adult photo sequences
- **Before/after comparisons** — Renovation, fitness, makeover
- **Event photo recaps** — Weddings, birthdays, trips
- **Portfolio presentations** — Quick image showcase

## Want AI-Powered Video Transitions?

This package creates simple HTML slideshows. If you want **AI-generated smooth video transitions** between your photos (morphing faces, aging effects, cinematic transitions), check out [GrowingUpVideo](https://growingupvideo.com) — it uses AI to create videos from your growing-up photos.

## License

MIT