semvec/pypi-packages huggingface dataset:
farewell 0.1.0
Simple, unobtrusive script exit notifications.
Requires Python: <4.0,>=3.9

# Farewell

Simple, unobtrusive script exit notifications.

## Installation

```python
pip install farewell
```

## Quickstart

The `farewell` module is designed to be used in a script that eventually exits.

### Basic usage

```python
from farewell import on_exit

def on_success():
    print("✅ Everything worked!")

def on_error(error):
    print(f"❌ Failed: {error['type']} - {error['message']}")

on_exit(succes_func=on_success,
        error_func=on_error)

# You actual script logic below - completely unchanged!
print("Script running...")

# Uncomment to test error:
# raise ValueError("Test error!")

print("Script finished!")
```

### Usage with a main()

```python
from farewell import on_exit

def setup_notifications() :
    def success_notification():
        print("✅ Everything worked!")
    
    def error_notification(error):
        print(f"❌ Failed: {error['type']} - {error['message']}")

    on_exit(success_notification, error_notification)

def main():
    print("Script running...")
    
    # Uncomment to test error:
    # raise ValueError("Test error!")
    
    print("Script finished!")

if __name__ == "__main__":
    setup_notifications() # could also be called inside main()
    main()
```

### Example with AWS SNS notifications

Also checkout `./examples/sns.py` for a more complete example.

```python
from farewell import on_exit
import boto3

sns = boto3.client('sns')

def notify_success():
    sns.publish(TopicArn="...", Message="✅ Everything worked!")

def notify_error(err):
    sns.publish(TopicArn="...", Message=f"❌ Failed: {err['type']} - {err['message']}")

on_exit(succes_func=notify_success,
        error_func=notify_error)

# You actual script logic below - completely unchanged!
```

## next
tiled-convolution 0.1.1
A tiled convolution implementation for PyTorch
Requires Python: >=3.10
Keywords: sample, setuptools, development

# Tiled Convolution
A library for performing convolution on large 2D arrays. \
Uses a tiled approach to break the convolution into batches, which reduces maximum memory usage.

## Installation
from pypi
```bash
pip install tiled_convolution
```
from source
```bash
pip install https://github.com/RichieHakim/tiled_convolution.git
```
or
```bash
git clone https://github.com/RichieHakim/tiled_convolution
cd tiled_convolution
pip install -e .
```
linux-hwinfo64 0.1.3
A lightweight, terminal-based system monitoring tool for Linux that provides real-time hardware metrics (CPU and GPU) in both text and graphical formats
Requires Python: >=3.10

# Linux HWINFO64

Written in Python    
This is a scaled down proof of concept. It's a simple script to output a system's hardware information and some simple metrics for the CPU and GPU
In the future, I might expand this to include more of the features of hwinfo64, but it's a simple MVP for now    

## Requirements
- `nvidia-smi` for Nvidia GPUs
- `rocm-smi` for AMD GPUs

## GPU Detection
It first checks for NVIDIA GPUs using nvidia-smi        
Then it checks for AMD GPUs by:            
- Looking at vendor ID in `/sys/class/drm/card0/device/vendor`         
- Using `lspci` to search for AMD graphics adapters       
- The most accurate way to get usage is using rocm-smi, otherwise it relies on `/sys/class/drm/card0/device/gpu_busy_percent`[1]


## Usage Notes:

### CLI Arguments
- `--graph` or `-g`: Run the monitor in graph mode
- `--record` or `-r`: Record metrics to a CSV file for later analysis
- `--output` or `-o`: Specify the output CSV file name (default: hw_metrics.csv)

### Graph Mode
A new display mode that shows line graphs of your hardware metrics over the last 2 minutes
- CPU usage history
- Memory usage history
- GPU utilization history (if available)
- GPU memory usage history (if available)

![Screenshot of tool running in graph mode](assets/graph-view.png)

## Notes
For AMD GPUs, some metrics might not be available depending on your specific card and drivers:
- Temperature reading paths can vary between different AMD cards              
- Memory usage requires ROCm tools to be installed                
- GPU utilization might not be available on older cards/drivers                

![Screenshot of the tool running in the terminal](assets/linux_hw_monitor_screenshot.png)


Additional requirements for AMD GPU support:
- For basic detection: standard Linux utilities like lspci
- For more detailed metrics: AMD's ROCm tools (rocm-smi)

## Links:
- Docs for installing `rocm` for AMD
  - https://rocm.docs.amd.com/projects/install-on-linux/en/latest/install/quick-start.html

[1] I don't know a lot about how linux determines device number, but it will increment the value for `card0` if you ever change your graphics card (presumably it stores the previous device values / configs / whatever). I plan to investigate this further
fastrtc-whisper-cpp 0.1.2
Fast RTC Whisper CPP package
Requires Python: >=3.10

# Whisper CPP for FastRTC

A PyPI package that wraps Whisper.cpp for speech-to-text (STT) transcription, compatible with the FastRTC STTModel protocol. This package provides efficient, CPU-based speech recognition using the optimized Whisper.cpp implementation.

## Installation

```bash
pip install fastrtc-whisper-cpp
```

For audio file loading capabilities, install with the audio extras:

```bash
pip install "fastrtc-whisper-cpp[audio]"
```

For development:

```bash
pip install "fastrtc-whisper-cpp[dev]"
```

## Usage

### Basic Usage

```python
from fastrtc_whisper_cpp import get_stt_model
import numpy as np

# Create the model (downloads from HF if not cached)
model = get_stt_model()

# Example: Create a sample audio array (actual audio would come from a file or mic)
sample_rate = 16000
audio_data = np.zeros(16000, dtype=np.float32)  # 1 second of silence

# Transcribe
text = model.stt((sample_rate, audio_data))
print(f"Transcription: {text}")
```

### Loading Audio Files

If you've installed with the audio extras:

```python
from fastrtc_whisper_cpp import get_stt_model, load_audio

# Load model
model = get_stt_model()

# Load audio file (automatically resamples to 16kHz)
audio = load_audio("path/to/audio.wav")

# Transcribe
text = model.stt(audio)
print(f"Transcription: {text}")
```

### Using with FastRTC

```python
from fastrtc_whisper_cpp import get_stt_model

# Create the model
whisper_model = get_stt_model()

# Use within FastRTC applications
# (Follow FastRTC documentation for integration details)
```

## Available Models

The package supports various Whisper.cpp models with different sizes and quantization levels:

- English-only models (faster, smaller):
  - `tiny.en`, `tiny.en-q5_1`, `tiny.en-q8_0`
  - `base.en`, `base.en-q5_1`, `base.en-q8_0`
  - `small.en`, `small.en-q5_1`, `small.en-q8_0`
  - `medium.en`, `medium.en-q5_0`, `medium.en-q8_0`

- Multilingual models:
  - `tiny`, `tiny-q5_1`, `tiny-q8_0`
  - `base`, `base-q5_1`, `base-q8_0`
  - `small`, `small-q5_1`, `small-q8_0`
  - `medium`, `medium-q5_0`, `medium-q8_0`
  - `large-v1`
  - `large-v2`, `large-v2-q5_0`, `large-v2-q8_0`
  - `large-v3`, `large-v3-q5_0`
  - `large-v3-turbo`, `large-v3-turbo-q5_0`, `large-v3-turbo-q8_0`

Example:

```python
from fastrtc_whisper_cpp import get_stt_model

# Choose a specific model
model = get_stt_model("medium.en-q8_0")
```

## Advanced Configuration

You can configure the model with specific parameters:

```python
from fastrtc_whisper_cpp import WhisperCppSTT

# Configure with specific model and models directory
model = WhisperCppSTT(
    model="medium.en",
    models_dir="/path/to/models"  # Optional custom models directory
)
```

## Requirements

- Python 3.10+
- numpy
- pywhispercpp
- librosa (optional, for audio file loading)
- click (for CLI features)

## Development

Clone the repository and install in development mode:

```bash
git clone https://github.com/mahimairaja/fastrtc-whisper-cpp.git
cd fastrtc-whisper-cpp
pip install -e ".[dev,audio]"
```

## License

MIT
faucet-extractor-poc 1.4.0
Testnet faucet extractor (Proof of Concept)
Requires Python: >=3.10
Keywords: testnet, faucet, ethereum, erc20, web3

# Faucet Extractor PoC

This project is a Proof of Concept (PoC) for a faucet extractor. It sends a request to a given URL of a faucet and tries to claim a testnet token.

## Features

- Sends a request to a specified faucet URL
- Attempts to claim testnet tokens

## Requirements

- Python 3.10
- `requests` library
- `python-dotenv` library

## Environment Variables

The following environment variables need to be set before using the project:

- `DISCORD_WEBHOOK_URL` (optional) - Discord webhook URL for notifications
- `ERC20_ADDRESSES` - Comma-separated list of ERC20 addresses
- `BERA_FAUCET_URL` - Bera faucet URL
- `MONAD_FAUCET_URL` - Monad faucet URL

## Installation

### Method 1: Install from PyPI (Recommended)

Install the package directly from PyPI:

```bash
pip install faucet-extractor-poc
```

### Method 2: Install from Source

1. Clone the repository:

    ```bash
    git clone https://github.com/niagarafinance/faucet-extractor-poc.git
    ```

2. Navigate to the project directory:

    ```bash
    cd faucet-extractor-poc
    ```

3. Install the package in development mode:

    ```bash
    pip install -e .
    ```

## Usage

Before running the project, make sure to set the required environment variables.

```bash
export BERA_FAUCET_URL="https://bera-faucet-url.com"
export MONAD_FAUCET_URL="https://monad-faucet-url.com"
```

To run the project, use the appropriate command:

### Using the installed package

```bash
faucet-extractor --faucet MON 0x1234567890123456789012345678901234567890
```

### Multiple addresses with faucet type

```bash
faucet-extractor --faucet BERA 0xAddress1 0xAddress2 0xAddress3
```

### Using environment variable with faucet

```bash
export ERC20_ADDRESSES="0xAddress1,0xAddress2"
faucet-extractor --faucet BERA
```

### Running directly from the source

If you installed from source, you can also run the module directly:

```bash
python -m src.faucet_extractor_poc.extract --faucet MON 0x1234567890123456789012345678901234567890
```

### Show help

```bash
faucet-extractor --help
```