semvec/pypi-packages huggingface dataset:
filmtagger 0.3.0
A simple CLI to tag film scans with EXIF metadata
Requires Python: >=3.8
Keywords: exif, film, metadata, photography

# filmtagger

A simple CLI to tag film scans with EXIF metadata.

## Installation

```bash
pip install filmtagger
```

### Requirements

This package uses the [pyexiv2](https://pypi.org/project/pyexiv2/) library for EXIF/XMP metadata manipulation, which provides Python bindings for the Exiv2 library. The pyexiv2 package includes pre-compiled binaries for most platforms, making installation straightforward without requiring system-level dependencies.

## Usage

```bash
# Show help
filmtagger --help

# Tag a single image
filmtagger tag image.jpg

# Tag multiple images
filmtagger tag *.jpg
```

## Development

This project uses [Hatch](https://hatch.pypa.io/) for development and package management.

### Setup Development Environment

1. Install Hatch:
```bash
pip install hatch
```

2. Create and activate development environment:
```bash
hatch shell
```

### Running Tests

```bash
# Run all tests
hatch run test

# Run tests with coverage
hatch run test-cov

# Run linting checks
hatch run lint:all

# Format code
hatch run lint:fmt
```

### Building and Publishing

```bash
# Build the package
hatch build

# Publish to PyPI
hatch publish
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## Usage examples

To set the date of all images to 12 June 2019, specifying camera and 
film as well:

    $ filmtagger -d 2019-06-12 -c "Leica M6" -f "E100G" *.jpg

Filmtagger supports fuzzy-matching against its database of cameras and 
films, so your input strings needn't be exact.  Likewise, it attempts to 
autodetect a variety of date/time input.

## Configuration

You may configure your own camera and film definitions to override the
system-wide ones.

Create a `~/.config/filmtagger/cameras.toml` file that looks like this:

```toml
["Mamiya RB67"]
"Exif.Image.Make" = "Mamiya"
"Exif.Image.Model" = "RB67"
```

And a `~/.config/filmtagger/films.toml` like this:

```toml
["Ilford HP5 Plus"]
"Exif.Photo.ISOSpeedRatings" = 400
"Xmp.AnalogExif.FilmMaker" = "Ilford"
"Xmp.iptcExt.DigitalSourceType" = "http://cv.iptc.org/newscodes/digitalsourcetype/negativeFilm"
```

The section headings will be fuzzy-matched from the command-line 
arguments.  The key-value pairs that follow will be set as metadata, 
assuming they are [valid tag names](https://exiv2.org/metadata.html).
In addition to the standard Exiv2 tag schema, [AnalogExif 
tags](http://analogexif.sourceforge.net/help/analogexif-xmp.php) are 
also supported.
prefect-tool-state 0.0.8
A high-throughput progress publisher for Prefect tools with optimized batching
Requires Python: >=3.8

# Prefect Tool State

A high-throughput tool state publisher for Prefect tools with optimized batching capabilities.

## Features

- **High-frequency publishing**: Optimized for scenarios where tool state updates are sent after each file is processed
- **Batch optimization**: Collects messages over 1-second intervals and publishes them as a single JSON array
- **Background worker**: Non-blocking interface with async background processing
- **Thread-safe**: Safe to use from multiple threads
- **Automatic resource management**: Handles Redis connection lifecycle automatically

## Installation

```bash
pip install prefect-tool-state
```

## Quick Start

```python
# Quick Start updated for state publisher
from prefect_tool_state import get_tool_state_publisher, ToolStatePublisher, ToolState

# Get the global state publisher instance
publisher = get_tool_state_publisher()

# Publish tool state updates (non-blocking)
state_publisher = get_tool_state_publisher()
tool_state = ToolState(
    tool_run_id="tool-123",
    status="processing",
    current_file="example.txt",
    # ... other fields
)
state_publisher.publish_data(tool_state)
```

## Configuration

The publisher requires Redis messaging environment variables:
- `PREFECT_REDIS_MESSAGING_HOST`: Redis host
- `PREFECT_REDIS_MESSAGING_PASSWORD`: Redis password

## How It Works

1. **Queue-based**: Your calls to `publish_data()` are queued in memory (non-blocking)
2. **Batched publishing**: A background worker wakes up every second to process all queued messages
3. **Optimized payload**: All messages are serialized into a single JSON array and published as one Redis message
4. **Consumer compatibility**: The consumer must handle the batch format (array of tool states)

## Performance

- **Before**: 1000 file updates = 1000 Redis operations
- **After**: 1000 file updates = 1 Redis operation per second
- **Latency**: Sub-millisecond for `publish_data()` calls
- **Throughput**: Handles thousands of updates per second

## License

MIT License