semvec/pypi-packages huggingface dataset:
phonexia-replay-attack-detection-client 2.1.0
Replay Attack Detection Client
Requires Python: >=3.9
Keywords: grpc, voice, voice-biometry, speech, replay, attack, replay attack, replay attack detection

![](https://www.phonexia.com/wp-content/uploads/phonexia-logo-transparent-500px.png)
# Phonexia Replay Attack Detection client

This module contains client for communication with [Replay attack detection microservice](https://hub.docker.com/repository/docker/phonexia/replay-attack-detection/general) developed by [Phonexia](https://phonexia.com).

To use this client you will first need a running instance of any *Phonexia Replay Attack Detection microservice*. If you don't yet have any running instance, don't hesitate to [contact our sales department](mailto:info@phonexia.com).

You can learn more about the speaker identification technology [here](https://docs.phonexia.com/products/speech-platform-4/technologies/speaker-identification/).

On [this page](https://docs.phonexia.com/products/speech-platform-4/grpc/api/phonexia/grpc/technologies/replay_attack_detection/experimental/replay_attack_detection.proto), you will find a *gRPC API* reference for *Replay Attack Detection microservice*.
llama-index-readers-datasets 0.1.0
llama-index readers HuggingFace Datasets integration
Requires Python: <4.0,>=3.9
Keywords: datasets, huggingface

# LlamaIndex Readers Integration: HuggingFace Datasets

## Overview

HuggingFace Datasets Reader is a tool designed to load HuggingFace datasets as documents.

### Installation

You can install HuggingFace Datasets Reader via pip:

```bash
pip install llama-index-readers-datasets
```

## Usage

```python
from llama_index.readers.datasets import DatasetsReader
from datasets import load_dataset

reader = DatasetsReader()

# Load train split (default) as metadata
docs = reader.load_data("lhoestq/demo1")

# Load test split as metadata
docs = reader.load_data("lhoestq/demo1", split="test")

# Load specify the dictionary key to use as text value
docs = reader.load_data("lhoestq/demo1", text_key="review")

# Pass additional arguments to datasets.load_dataset
docs = reader.load_data("lhoestq/demo1", cache_dir="/tmp/huggingface")

# Load from a preloaded dataset (ignore all other arguments)
dataset = load_dataset("lhoestq/demo1", split="train")
docs = reader.load_data(dataset=dataset)

# Lazy loading (stream samples)
for it in reader.lazy_load_data(
    "lhoestq/demo1", split="test", text_key="review", doc_id_key="id"
):
    print(it)
```
uvpy 0.1.1
Portable Python App Framework with isolated venvs via uv
Requires Python: >=3.10
Keywords: cli, framework, offline, portable, sandbox, uv, venv

# uvpy - Portable Python App Framework

**Version 0.1.0** | **Python 3.12**

A fully portable, offline-capable CLI framework for modular Python apps.

## Features

- **Portable**: Bundled Python, no system dependencies
- **Offline**: All packages from local `pypi/` mirror
- **Isolated**: Each app has its own venv (via uv)
- **Secure**: Sandbox - localhost only, no telemetry
- **Modular**: Apps as plugins in `apps/`

## Dual Mode Operation

uvpy supports two modes:

1. **Portable Mode**: With bundled Python, uv binary, and offline packages
2. **Installed Mode**: `pip install uvpy` - uses system Python, apps from `./apps/`

## Quickstart

### Portable Mode

```bash
# 1. Install portable Python (once)
curl -LO https://github.com/indygreg/python-build-standalone/releases/download/20240224/cpython-3.12.2+20240224-x86_64-unknown-linux-gnu-install_only.tar.gz
tar xzf cpython-*.tar.gz

# 2. Run an app
./uvpy hello
./uvpy --list-apps
```

### Installed Mode

```bash
pip install uvpy
uvpy --list-apps
uvpy hello
```

## Structure

```
uvpy/
├── uvpy             # Launcher (Linux/macOS)
├── uvpy.bat         # Launcher (Windows)
├── src/uvpy/        # Package source
├── python/          # Portable Python 3.12
├── apps/            # App modules
├── pypi/            # Offline packages (.whl)
└── bin/             # uv binary
```

## Commands

```bash
./uvpy --help              # Help
./uvpy --list-apps         # List apps
./uvpy <app>               # Run app

# Portable mode only:
./uvpy venv --list         # Show venv status
./uvpy venv <app>          # Create venv (offline)
./uvpy venv <app> --online # Create venv (online)

./uvpy download --list     # Show packages in pypi/
./uvpy download --online numpy pandas  # Download packages
```

## Creating a New App

```bash
mkdir -p apps/myapp
```

**apps/myapp/manifest.json:**
```json
{
  "name": "myapp",
  "version": "1.0.0",
  "description": "My application"
}
```

**apps/myapp/pyproject.toml:**
```toml
[project]
name = "myapp"
version = "1.0.0"
dependencies = ["numpy==1.26.4"]
```

**apps/myapp/main.py:**
```python
def register(subparser):
    subparser.add_argument("--name", default="World")

def run(args):
    import numpy as np
    print(f"Hello {args.name}! NumPy version: {np.__version__}")
    return 0
```

```bash
./uvpy venv myapp    # Create venv
./uvpy myapp         # Run app
```

## Security Sandbox

uvpy includes a security sandbox that:

- Blocks all network connections except localhost
- Disables telemetry (Streamlit, Matplotlib, etc.)
- Sets headless backends for GUI libraries

```python
from uvpy import activate_sandbox
activate_sandbox()
```

## License

MIT License - see [LICENSE](LICENSE)