semvec/pypi-packages huggingface dataset:
rtcpconnection 1.6.3
fix http error for python 3.11+ 

# rtcpconnection

**rtcpconnection** is a simple and powerful Python module for building real-time communication applications. Inspired by the rtcpconnection standard, it allows you to handle audio, video, and P2P data with low latency and minimal syntax.

---

## Features

* **P2P Communication**: Direct data exchange between clients without a central server.
* **Audio & Video**: Real-time transmission with low latency.
* **Data Channels**: Send and receive text or JSON messages instantly.
* **Event Handling**: Simple callbacks for `on_connect`, `on_message`, `on_disconnect`.
* **Secure**: Built-in DTLS/SRTP encryption.
* **Interoperable**: Compatible with browsers and other rtcpconnection clients.

---

## Installation

```bash
pip install rtcpconnection
```



---

## Basic Usage

### Create a client and connect

```python
from rtcpconnection import rtcpconnectionClient

# Initialize the client
client = rtcpconnectionClient(username="Alice")

# Event triggered when a message is received
@client.on("message")
def handle_message(sender, content):
    print(f"{sender} says: {content}")

# Connect to a peer
client.connect("bob_peer_id")

# Send a message
client.send("bob_peer_id", "Hi Bob!")

# Listen for events
client.listen()
```

### Audio/Video example

```python
client.connect_audio()
client.connect_video()
```

---

## Use Cases

* Real-time audio and video chats
* P2P multiplayer games
* Streaming and data sharing
* Collaborative tools (drawing, shared documents)

---
ai-music-remixer 3.0.0
AI-powered intelligent music remixer with optional neural transitions
Requires Python: >=3.8

# AI Music Remixer

AI-powered intelligent music remixer with optional neural transitions.

## Features

- Intelligent audio remixing using Spleeter for stem separation
- Optional PyTorch-based neural transition model for smoother transitions
- Beat-synchronized remixing with automatic tempo detection
- Command-line interface for easy usage
- Safe fallback to deterministic smoothing if neural model is unavailable

## Installation

```bash
pip install ai_music_remixer
```

For GPU support (optional):
```bash
pip install ai_music_remixer[gpu]
```

## Usage

### Command Line

Basic remix:
```bash
ai-remix input.mp3 -o output.wav
```

Beat-synchronized remix:
```bash
ai-remix input.mp3 --beats -o output.wav
```

With custom BPM:
```bash
ai-remix input.mp3 --beats --bpm 120 -o output.wav
```

### Python API

```python
from ai_music_remixer import ai_remix, ai_remix_beatsync

# Basic remix
ai_remix("input.mp3", "output.wav")

# Beat-synchronized remix
ai_remix_beatsync("input.mp3", "output.wav", beats_per_minute=120)
```

## Neural Transition Model

The package includes an optional PyTorch-based neural transition model. If you place a trained checkpoint file at `models/transition_ckpt.pt`, the remixer will automatically use it for smoother transitions. Without a checkpoint, the package falls back to deterministic Gaussian smoothing.

To train a model (requires PyTorch):
```bash
python -m ai_music_remixer.neural.train_transition
```

## Requirements

- Python >= 3.8
- pydub
- librosa
- soundfile
- spleeter
- numpy
- scipy

Optional:
- torch (for neural transitions)

## License

MIT
ukbeaver 0.3.2
Add your description here
Requires Python: >=3.12

# ukbeaver 🦫

![ukbeaver mascot](assets/ukbeaver.png)

**A lightweight toolkit for working with UK Biobank (UKB) tabular and imaging data**

UK Biobank (UKB) provides one of the world’s largest biomedical datasets, containing extensive **tabular information** (phenotypes, biomarkers, questionnaires, etc.) and **imaging data** (MRI, retinal scans, X-rays, etc.). While rich in potential, accessing and organizing UKB data can be cumbersome due to its **complex file structures, field IDs, and modality-specific formats**.

**ukbeaver** is designed to streamline this process. It provides a convenient interface to:

- 🗂 **Access and organize tabular data** — handle field IDs, instances, and arrays with ease.  
- 🖼 **Work with imaging data** — load and manage different modalities without manual overhead.  
- 🔎 **Query efficiently** — simplify the process of extracting subsets of data for analysis.  
- ⚡ **Integrate with existing workflows** — built to be lightweight, flexible, and compatible with Python data science tools.  

With ukbeaver, researchers can focus on **analysis and discovery**, instead of wrestling with data preprocessing.  

---

## 🚀 Getting Started  

### Installation  
```bash
pip install ukbeaver
```

### Minimal Example  

```python
from ukbeaver.tabular import Phenotype

# init with a UKB-style tab-delimited file
ph = Phenotype("pheno_table.tsv")

# load everything
df, field_map = ph.get_df()

# select specific field IDs
df_50, _ = ph.get_df(fids=["50"])

# select only instance 0
df_i0, _ = ph.get_df(ins=0)
```

---

⚠️ **Note**: Access to UK Biobank data requires an approved UKB project application. `ukbeaver` does not bypass these restrictions; it only assists in handling datasets you are authorized to use.
block-cascade 3.1.0
Library for model training in multi-cloud environment.
Requires Python: <3.13,>=3.9

# cascade

Cascade is a library for submitting and managing jobs across multiple cloud environments. It is designed to integrate seamlessly into existing Prefect workflows or can be used as a standalone library.

## Getting Started

### Installation
  
  ```bash 
  poetry add block-cascade
  ```
or 
```
pip install block-cascade
```

### Example Usage

```python
from block_cascade import remote
from block_cascade import GcpEnvironmentConfig, GcpMachineConfig, GcpResource

machine_config = GcpMachineConfig("n2-standard-4", 1)
environment_config = GcpEnvironmentConfig(
    project="example-project",
    region="us-west1",
    service_account=f"example-project@vertex.iam.gserviceaccount.com",
    image="us.gcr.io/example-project/cascade/cascade-test",
    network="projects/123456789123/global/networks/shared-vpc"
)
gcp_resource = GcpResource(
    chief=machine_config,
    environment=environment_config,
)

@remote(resource=gcp_resource)
def addition(a: int, b: int) -> int:
    return a + b

result = addition(1, 2)
assert result == 3
```

### Configuration
Cascade supports defining different resource requirements via a configuration file titled either cascade.yaml or cascade.yml. This configuration file must be located in the working directory of the code execution to be discovered at runtime.

```yaml
calculate:
  type: GcpResource
  chief:
    type: n1-standard-1
You can even define a default configuration that can be overridden by specific tasks to eliminate redundant definitions.

default:
    GcpResource:
        environment:
            project: example-project
            service_account: example-project@vertex.iam.gserviceaccount.com
            region: us-central-1
        chief:
            type: n1-standard-4
```

### Authorization
Cascade requires authorization both to submit jobs to either GCP or Databricks and to stage picklied code to a cloud storage bucket. In the GCP example below, an authorization token is obtained via IAM by running the following command:

```bash
gcloud auth login --update-adc
```
No additional configuration is required in your application's code to use this token.

However, for authenticating to Databricks and AWS you will need to provide a token and secret key respectively. These can be passed directly to the `DatabricksResource` object or set as environment variables. The following example shows how to provide these values in the configuration file.

## For Developers

### Using hermit for managing Python
When developing cascade, you can optionally use [hermit](https://cashapp.github.io/hermit/usage/get-started/) to manage the Python executable used by cascade. Together with using poetry to manage dependencies, this will ensure that your development environment is identical to other contributors. Follow the linked instructions for installing hermit and then you can create a virtualenv with Python@3.9 by running:

`. ./bin/activate-hermit`

Then, install the dependencies with poetry:
`poetry install`