semvec/pypi-packages huggingface dataset:
validators-rs 0.1.1
High-performance Rust implementation of validators - validate emails, URLs, IPs, and more
Requires Python: >=3.8
Keywords: validators, validation, email, url, performance, rust

# validators-rs

High-performance Rust implementation of validators - validate emails, URLs, IPs, and more.

## Overview

`validators-rs` is a Rust-powered Python library that provides fast validation for common data types including emails, URLs, IP addresses, and more.

## Installation

```bash
pip install validators-rs
```

## Features

- 🚀 **High Performance**: Built with Rust for maximum speed
- ✅ **Comprehensive Validation**: Email, URL, IP, domain, and more
- 🔄 **Compatible**: Drop-in replacement for the validators library
- 🐍 **Python 3.8+**: Supports Python 3.8 through 3.14
- 🌍 **Cross-Platform**: Pre-built wheels for Linux, macOS, and Windows

## Quick Start

```python
from validators_rs import email, url, ipv4, domain

# Validate email addresses
print(email("user@example.com"))  # True
print(email("invalid.email"))     # False

# Validate URLs
print(url("https://example.com"))  # True
print(url("not a url"))           # False

# Validate IP addresses
print(ipv4("192.168.1.1"))  # True
print(ipv4("999.999.999.999"))  # False

# Validate domain names
print(domain("example.com"))  # True
print(domain("invalid..domain"))  # False
```

## Available Validators

- `email()`: Validate email addresses
- `url()`: Validate URLs
- `ipv4()`: Validate IPv4 addresses
- `ipv6()`: Validate IPv6 addresses
- `domain()`: Validate domain names
- `mac_address()`: Validate MAC addresses
- `uuid()`: Validate UUIDs
- And more!

## Performance

`validators-rs` provides significant performance improvements over pure Python implementations, making it ideal for high-throughput validation scenarios.

## License

MIT License

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
tabulate-rs 0.1.1
High-performance Rust implementation of tabulate - pretty-print tabular data with multiple output formats
Requires Python: >=3.8
Keywords: tabulate, table, formatting, performance, rust

# tabulate-rs

High-performance Rust implementation of tabulate - pretty-print tabular data with multiple output formats.

## Overview

`tabulate-rs` is a Rust-powered Python library that provides fast table formatting functionality, compatible with the popular `tabulate` library but with significantly improved performance.

## Installation

```bash
pip install tabulate-rs
```

## Features

- 🚀 **High Performance**: Built with Rust for maximum speed
- 🔄 **Drop-in Replacement**: Compatible with Python's tabulate library
- 📊 **Multiple Formats**: Support for various table output formats
- 🐍 **Python 3.8+**: Works with Python 3.8 through 3.14
- 🌍 **Cross-Platform**: Pre-built wheels for Linux, macOS, and Windows

## Quick Start

```python
from tabulate_rs import tabulate

data = [
    ["Alice", 24, "Engineer"],
    ["Bob", 19, "Student"],
    ["Charlie", 30, "Designer"]
]

headers = ["Name", "Age", "Occupation"]

print(tabulate(data, headers=headers, tablefmt="grid"))
```

## Performance

`tabulate-rs` offers significant performance improvements over the pure Python implementation, especially for large datasets.

## License

MIT License

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
packaging-rs 0.1.1
High-performance Rust implementation of packaging - version parsing and comparison utilities
Requires Python: >=3.8
Keywords: packaging, version, semver, performance, rust

# packaging-rs

High-performance Rust implementation of packaging - version parsing and comparison utilities.

## Overview

`packaging-rs` is a Rust-powered Python library that provides fast version parsing and comparison, compatible with Python's packaging library but with significantly improved performance.

## Installation

```bash
pip install packaging-rs
```

## Features

- 🚀 **High Performance**: Built with Rust for maximum speed
- 📦 **Version Handling**: Parse and compare package versions
- 🔄 **Compatible**: Works with PEP 440 version specifications
- 🐍 **Python 3.8+**: Supports Python 3.8 through 3.14
- 🌍 **Cross-Platform**: Pre-built wheels for Linux, macOS, and Windows

## Quick Start

```python
from packaging_rs import Version, parse

# Parse versions
v1 = Version("1.2.3")
v2 = Version("2.0.0")
v3 = parse("1.2.3a1")  # Pre-release version

# Compare versions
print(v1 < v2)   # True
print(v2 > v1)   # True
print(v1 == Version("1.2.3"))  # True

# Version information
print(v1.major)  # 1
print(v1.minor)  # 2
print(v1.micro)  # 3
```

## Version Formats

Supports PEP 440 version formats:
- Standard versions: `1.2.3`
- Pre-releases: `1.2.3a1`, `1.2.3b2`, `1.2.3rc1`
- Post-releases: `1.2.3.post1`
- Development releases: `1.2.3.dev1`
- Local versions: `1.2.3+local.version`

## Performance

`packaging-rs` delivers significant performance improvements over pure Python implementations, especially when processing large numbers of version comparisons.

## License

Apache License 2.0

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
humanize-rs 0.1.1
High-performance Rust implementation of humanize - turn numbers and dates into human-readable strings
Requires Python: >=3.8
Keywords: humanize, formatting, numbers, dates, performance, rust

# humanize-rs

High-performance Rust implementation of humanize - turn numbers and dates into human-readable strings.

## Overview

`humanize-rs` is a Rust-powered Python library that makes numbers and dates more human-friendly, providing fast formatting with a simple, intuitive API.

## Installation

```bash
pip install humanize-rs
```

## Features

- 🚀 **High Performance**: Built with Rust for maximum speed
- 📊 **Number Formatting**: Format large numbers, file sizes, and more
- 🕒 **Time Humanization**: Convert dates to relative time descriptions
- 🔄 **Drop-in Replacement**: Compatible with the humanize library
- 🐍 **Python 3.8+**: Supports Python 3.8 through 3.14
- 🌍 **Cross-Platform**: Pre-built wheels for Linux, macOS, and Windows

## Quick Start

```python
from humanize_rs import naturalsize, intcomma, naturaltime
from datetime import datetime, timedelta

# Format file sizes
print(naturalsize(1024))  # "1.0 kB"
print(naturalsize(1024 * 1024))  # "1.0 MB"

# Format large numbers
print(intcomma(1000000))  # "1,000,000"

# Format time differences
now = datetime.now()
past = now - timedelta(hours=2)
print(naturaltime(past))  # "2 hours ago"
```

## Available Functions

- `naturalsize()`: Convert bytes to human-readable file sizes
- `intcomma()`: Add commas to large numbers
- `naturaltime()`: Convert timestamps to relative time
- `scientific()`: Format numbers in scientific notation
- And more!

## Performance

`humanize-rs` delivers significant performance improvements over pure Python implementations, especially when processing large datasets.

## License

MIT License

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
dateutil-rs 0.1.1
High-performance Rust implementation of python-dateutil - flexible datetime parsing with multiple format support
Requires Python: >=3.8
Keywords: datetime, dateutil, parsing, performance, rust

# dateutil-rs

High-performance Rust implementation of python-dateutil - flexible datetime parsing with multiple format support.

## Overview

`dateutil-rs` is a Rust-powered Python library that provides fast datetime parsing functionality, offering compatibility with python-dateutil's parser while delivering significantly improved performance.

## Installation

```bash
pip install dateutil-rs
```

## Features

- 🚀 **High Performance**: Built with Rust for maximum speed
- 📅 **Flexible Parsing**: Supports multiple date and time formats
- 🔄 **Compatible**: Works with common dateutil patterns
- 🐍 **Python 3.8+**: Supports Python 3.8 through 3.14
- 🌍 **Cross-Platform**: Pre-built wheels for Linux, macOS, and Windows

## Quick Start

```python
from dateutil_rs import parse

# Parse various date formats
dt1 = parse("2023-01-15 14:30:00")
dt2 = parse("January 15, 2023")
dt3 = parse("15/01/2023")
dt4 = parse("2023-01-15T14:30:00Z")

print(dt1)  # datetime.datetime(2023, 1, 15, 14, 30, 0)
```

## Supported Formats

- ISO 8601: `2023-01-15T14:30:00Z`
- US Format: `01/15/2023`
- European Format: `15.01.2023`
- Natural Language: `January 15, 2023`
- And many more!

## Performance

`dateutil-rs` provides significant performance improvements over pure Python implementations, especially when parsing large volumes of datetime strings.

## License

Apache License 2.0

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
colorama-rs 0.1.1
High-performance Rust implementation of colorama - cross-platform colored terminal text
Requires Python: >=3.8
Keywords: colorama, color, terminal, ansi, performance, rust

# colorama-rs

High-performance Rust implementation of colorama - cross-platform colored terminal text.

## Overview

`colorama-rs` is a Rust-powered Python library for producing colored terminal text and cursor positioning, offering cross-platform support with enhanced performance.

## Installation

```bash
pip install colorama-rs
```

## Features

- 🚀 **High Performance**: Built with Rust for maximum speed
- 🎨 **Colored Output**: Easy-to-use API for colored text
- 🖥️ **Cross-Platform**: Works on Windows, Linux, and macOS
- 🔄 **Compatible**: Drop-in replacement for colorama
- 🐍 **Python 3.8+**: Supports Python 3.8 through 3.14
- 🌍 **Pre-built Wheels**: Available for all major platforms

## Quick Start

```python
from colorama_rs import Fore, Back, Style

# Print colored text
print(Fore.RED + 'Red text')
print(Fore.GREEN + 'Green text')
print(Back.BLUE + 'Blue background')
print(Style.BRIGHT + 'Bright text' + Style.RESET_ALL)

# Combine colors
print(Fore.YELLOW + Back.BLUE + 'Yellow on blue' + Style.RESET_ALL)
```

## Available Colors

### Foreground Colors
- BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE
- LIGHTBLACK_EX, LIGHTRED_EX, LIGHTGREEN_EX, etc.

### Background Colors
- Same as foreground colors but with `Back.` prefix

### Styles
- BRIGHT, DIM, NORMAL, RESET_ALL

## Cross-Platform Support

`colorama-rs` automatically handles Windows console API calls and ANSI codes on other platforms, providing a consistent experience across all operating systems.

## Performance

Built with Rust, `colorama-rs` offers improved performance over the pure Python implementation, especially for applications with heavy terminal output.

## License

BSD License

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
charset-normalizer-rs 0.1.1
High-performance Rust implementation of charset-normalizer - universal character encoding detection
Requires Python: >=3.8
Keywords: charset, encoding, detection, unicode, performance, rust

# charset-normalizer-rs

High-performance Rust implementation of charset-normalizer - universal character encoding detection.

## Overview

`charset-normalizer-rs` is a Rust-powered Python library that provides fast and accurate character encoding detection for text files and byte streams.

## Installation

```bash
pip install charset-normalizer-rs
```

## Features

- 🚀 **High Performance**: Built with Rust for maximum speed
- 🔍 **Accurate Detection**: Reliably detect character encodings
- 🌏 **Universal Support**: Handles encodings from around the world
- 🔄 **Compatible**: Drop-in replacement for charset-normalizer
- 🐍 **Python 3.8+**: Supports Python 3.8 through 3.14
- 🌍 **Cross-Platform**: Pre-built wheels for Linux, macOS, and Windows

## Quick Start

```python
from charset_normalizer_rs import from_bytes, from_path

# Detect encoding from bytes
with open('mystery_file.txt', 'rb') as f:
    raw_data = f.read()
    results = from_bytes(raw_data)
    best_match = results.best()
    print(f"Detected encoding: {best_match.encoding}")
    print(f"Decoded text: {str(best_match)}")

# Detect encoding from file path
results = from_path('mystery_file.txt')
best_match = results.best()
print(f"Encoding: {best_match.encoding}")
```

## Common Use Cases

- **File Processing**: Automatically detect and decode text files with unknown encodings
- **Web Scraping**: Handle web content with various character encodings
- **Data Migration**: Convert legacy data with different encodings
- **Log Analysis**: Process log files from different systems and locales

## Supported Encodings

Supports all major character encodings including:
- UTF-8, UTF-16, UTF-32
- ISO-8859 series
- Windows code pages (cp1252, cp1251, etc.)
- Asian encodings (GB2312, Big5, Shift-JIS, etc.)
- And many more!

## Performance

`charset-normalizer-rs` provides significant performance improvements over pure Python implementations, especially when processing large files or analyzing many documents.

## License

MIT License

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
optimum-haystack 2.0.0
Component to embed strings and Documents using models loaded with the HuggingFace Optimum library. This component is designed to seamlessly inference models using the high speed ONNX runtime.
Requires Python: >=3.10

# optimum-haystack

[![PyPI - Version](https://img.shields.io/pypi/v/optimum-haystack.svg)](https://pypi.org/project/optimum-haystack)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/optimum-haystack.svg)](https://pypi.org/project/optimum-haystack)

- [Integration page](https://haystack.deepset.ai/integrations/optimum)
- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/optimum/CHANGELOG.md)

---

Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).
sip-core 0.0.1
Core elements of the SIP protocol (RFC 3261)
Requires Python: >=3.8
Keywords: RFC3261, SIP

# sip-core

[![PyPI - Version](https://img.shields.io/pypi/v/sip-core.svg)](https://pypi.org/project/sip-core)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sip-core.svg)](https://pypi.org/project/sip-core)

-----
Core elements of the SIP protocol (RFC 3261)

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install sip-core
```

## License

`sip-core` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.