semvec/pypi-packages huggingface dataset:
tablequiz 0.1.3
Tool for running table quizes
Requires Python: >=3.12

# Table Quiz Master

Run table quizes using Python and Reveal.js.

Put your questions and answers into a `quiz.yaml` and use `tablequiz serve quiz.yaml` to run a server with all the questions, answers and other slides you specify ready to go.

# Basic Use

If you want to run directly without installing you can use `pipx` or `uvx`:

- For pipx: `pipx run tablequiz serve quiz.yaml`
- For uvx: `uvx tablequiz serve quiz.yaml`

Otherwise you can install `tablequiz` as a dependency.
video_compressing 0.1.4
Package to compress multiple large .MOV or .MP4 videos into a single light .mp4 video.
Requires Python: <4.0.0,>=3.12.0

# Video Compressing

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

A Python library for reducing the size of and merging multiple video files. This package is designed for simplicity and efficiency, leveraging FFmpeg for video compression and manipulation.

## Features
- Reduce Video Size: Scale down video dimensions and bitrate using a customizable reduction factor.
- Merge Multiple Videos: Combine multiple video files into a single output.
- Command-Line Interface: Use the package directly from the terminal for quick processing.

## Installation
Clone the Repository
```bash
git clone https://github.com/Gabriel-melki/video_compressing.git
cd video_compressing
```

### Install Dependencies
This project uses Poetry for dependency management. Install Poetry if you don’t have it:
```bash
pip install poetry
```
Install the dependencies and activate the vitual environment:
```bash
poetry install
poetry shell
```

Ensure FFmpeg is installed on your system:

**Ubuntu/Debian:**
```bash
sudo apt update && sudo apt install ffmpeg
```
**MacOS (with Homebrew):**
```bash
brew install ffmpeg
```

**Windows:**

Download FFmpeg and add it to your PATH.

### Usage
Command-Line Tool
You can run the VideoCompressing tool directly from the terminal.

```bash
python -m src.video_compressing.reduce_video input1.mp4 input2.mp4 -r 0.5 -o output.mp4
```
Parameters:
 - input_files: List of input video files (required)
 - -r, --reduction-factor: A float value to scale down videos (required).
 Example: 0.5 reduces the size by 50%.
 - o, --output-file: Name of the output file (optional).
 Default: Automatically generated if not provided.

### Example:
Reduce and merge video1.mp4 and video2.mp4 by 50% into output.mp4:

```bash
python -m src.video_compressing.reduce_video video1.mp4 video2.mp4 -r 0.5 -o output.mp4
```

Without an output file:
```bash
python -m src.video_compressing.reduce_video video1.mp4 video2.mp4 -r 0.5
```

Using as a Library
Import and call the reduce_and_merge_videos function directly in your Python code:

```python
from video_compressing.tools import reduce_and_merge_videos

reduce_and_merge_videos(
    input_files=["video1.mp4", "video2.mp4"],
    reduction_factor=0.5,
    output_file="output.mp4"
)
```
PyFAT12 0.8.post2
A library for reading (from) and writing (to) FAT12 file systems
Requires Python: >=3.5


# PyFAT12

PyFAT12 is a Python 3 library that allows handling FAT12 file systems. FAT12,
or original FAT, is a file system designed by Microsoft that was used primarily
on 5.25-inch and 3.5-inch floppy disks.

Currently PyFAT12 supports 3.5-inch high density (1.44 MB) floppy disk images
and handling any FAT12 file systems on them. It is also possible to format
a new FAT12 volume. Files can be opened, overwritten, created, renamed, deleted
and so on; subdirectory and volume label support is also present.

This library has not been tested extensively, but basic functionality appears
to work. There might still be bugs.

## Installation

PyFAT12 has been tested on recent Python 3 versions and does not require
any libraries beyond the standard library Python comes with.

```
pip install pyfat12
```

## Documentation

The library comes with docstrings which can be viewed with `help`. Currently
no documentation exists other than this README and the docstrings, but there
are plans to improve the situation.

## Examples

The following example creates a new 3.5-inch high density (1.44 MB) floppy
image called `DISK1.IMG` in the current directory. The image contains a blank,
formatted FAT12 file system:

```python3
from pyfat12 import FloppyImage, FAT12
floppy = FloppyImage()
fs = FAT12.format(floppy, "Disk label")
floppy.save("DISK1.IMG")
```

Opening up an existing image and lists all files from its root directory:

```python3
from pyfat12 import FloppyImage, FAT12
floppy = FloppyImage.open("DISK1.IMG")
fs = FAT12(floppy)
fileCount = 0

for file in fs.listfiles("/"):
    fileCount += 1
    print(file.name, file.size)

print(fileCount, "files in total")
```

Opening up an existing image, adding a new file (or overwriting an existing
one) and saving:

```python3
from pyfat12 import FloppyImage, FAT12
floppy = FloppyImage.open("DISK1.IMG")
fs = FAT12(floppy)
fs.write_file("/HELLO.TXT", b"Hello World!\r\n")
floppy.save("DISK1.IMG")
```

## License

MIT License. See `LICENSE`.