semvec/pypi-packages huggingface dataset:
soundcharts 1.0.2
A Python package for interacting with the Soundcharts API.
Requires Python: >=3.8

# Soundcharts Module

A Python package for interacting with the Soundcharts API.

## API Documentation

Full documentation of the API is available here: [Soundcharts API Documentation](https://developers.soundcharts.com/documentation/getting-started)

You will need a Soundcharts API subscription to use this package.

## Features

- Easily pull data from Soundcharts' API.
- Every endpoint from the documentation is available as a Python function.
  - For example, the "get audience" endpoint in the "playlist" category is accessible via `playlist.get_audience()`.
- Synchronous and Asynchronous support.
- Automatically loops through endpoints to get around API limitations, such as the limit of 100 items per request.
- Configurable error handling.

## Installation

`pip install soundcharts`

## Usage

**Synchronous Client**

Best for standard scripts, Jupyter notebooks, or scheduled cron jobs.

```python
from soundcharts import SoundchartsClient

sc = SoundchartsClient(app_id="your_app_id", api_key="your_api_key")

# Example with Billie Eilish's UUID
billie_metadata = sc.artist.get_artist_metadata("11e81bcc-9c1c-ce38-b96b-a0369fe50396")
print(billie_metadata)
```

**Asynchronous Client**

Recommended for high-performance applications, FastAPI, or when integrating with other asyncio libraries. This avoids blocking the event loop and allows for faster execution in concurrent environments.

```python
import asyncio
from soundcharts import SoundchartsClientAsync

async def main():
    sc = SoundchartsClientAsync(app_id="your_app_id", api_key="your_api_key")

    # Use 'await' for all API calls
    billie_uuid = "11e81bcc-9c1c-ce38-b96b-a0369fe50396"
    billie_metadata = await sc.artist.get_artist_metadata(billie_uuid)
    print(billie_metadata)

asyncio.run(main())
```

## Error handling

You can set the severity of the console logs, file logs, and exceptions:

```python
from soundcharts.client import SoundchartsClient
import logging

sc = SoundchartsClient( app_id="your_app_id",
                        api_key="your_api_key",
                        console_log_level=logging.INFO,
                        file_log_level=logging.WARNING,
                        exception_log_level=logging.ERROR)
```

Setting the level of the console or file log to `logging.DEBUG` will log each request send to the API.

## Parallel processing

You can specify the number of requests to run in parallel. 
It's especially useful when looping through a lot of calls, like in this case fetching 3 months of Billie Eilish's radio airplay (about 3,000 calls):

```python
from soundcharts.client import SoundchartsClient
import logging

sc = SoundchartsClient( app_id="your_app_id",
                        api_key="your_api_key",
                        parallel_requests=10)

billie = "11e81bcc-9c1c-ce38-b96b-a0369fe50396"

response = sc.artist.get_radio_spins(
    billie, start_date="2025-01-01", end_date="2025-03-31", limit=None
)
```
pytest-dbt-duckdb 0.1.15
Fearless testing for dbt models, powered by DuckDB.
Requires Python: >=3.11

# PyTest dbt Duckdb 🦆

Fearless testing for dbt models, powered by DuckDB.

## What is this?
**pytest-dbt-duckdb** is an open-source testing framework that allows you to validate dbt models end-to-end, using DuckDB as
an in-memory execution engine. Designed for speed, portability, and CI/CD automation, it enables you to test dbt
transformations before deployment, ensuring trust in your data.

## 🩺 Why This Exists

"Assumptions are dangerous."
An untested model is a ticking time bomb—silent, unseen, but waiting to fail at the worst possible moment.
This library ensures your transformations, dependencies, and outputs are battle-tested before deployment.

---

## 💡 Data must be tested, not trusted.

Modern analytics teams **move fast**—but in their race to ship, they often **skip a crucial step**: rigorous testing.
A broken transformation can mean misreported revenue, misleading product insights, or silent failures that creep into dashboards.

> "Each dbt model untested is a story unfinished."

Here, in the shadows of SQL models and YAML configurations, we forge a guardian—a pytest plugin
that ensures every dbt model is **battle-tested**, **validated**, and **ready** before it touches production.

With DuckDB as the testing engine, you can:

- [x] **Define** test cases with simple YAML scenarios.
- [x] **Execute** them in DuckDB, locally and instantly—no warehouse needed.
- [x] **Integrate** with **CI/CD pipelines**, catching errors before deployment.
- [x] **Extend** with **custom DuckDB functions** for specialized assertions.

> Data must be tested, not trusted. Let’s test fearlessly.

![Image title](docs/images/dbt-flow.jpg)

---

## 🚀 Who is this for?


> Whether you are a **craftsman of data** or a **guardian of analytics**, this library is **your lantern in the dark,
guiding you toward precision and reliability**.

- [x] **Data Engineers** → Validate dbt models before they reach production.
- [x] **Analytics Engineers** → Ensure clean, tested data in dashboards.
- [x] **CI/CD Developers** → Automate SQL testing in pull requests.

---

## 🎯 Key Features

| Feature                  | Description                                                      |
|:-------------------------|:-----------------------------------------------------------------|
| ✅ **Fast Testing**       | Runs entirely in DuckDB—no warehouse costs.                      |
| 🛠️ **YAML-Based Tests** | Define test scenarios using declarative YAML.                    |
| ♻️ **CI/CD Ready**       | Seamless integration with GitHub Actions, Jenkins, GitLab CI/CD. |
| 🔌 **Custom Functions**  | Extend with user-defined DuckDB functions.                       |
| 🧪 **Snapshot Testing**  | Compare actual vs. expected outputs with precision.              |

---

## How It Works

➡️ See the [Usage Section](https://afranzi.github.io/pytest-dbt-duckdb/usage/)
radis-client 0.5.4
RADIS client library to connect to a RADIS server.
Requires Python: <4.0,>=3.12

# RADIS Client

## About

RADIS Client is the official Python client of [RADIS (Radiology Report Archive and Discovery System)](https://github.com/openradx/radis).

## Usage

### Prerequisites

- Generate an API token in your RADIS profile.
- Make sure you have the permissions to access the RADIS API.
- Also make sure you have the permissions for the resources you like to access.

### Code

```python
server_url = "https://radis" # The host URL of the RADIS server
auth_token = "my_token" # The authentication token generated in your profile
client = RadisClient(server_url=server_url, auth_token=auth_token)
```

## License

- AGPL 3.0 or later
py-sofistik-utils 0.0.1
The Studio W SOFiSTiK package
Requires Python: >=3.12

# py-sofistik-utils

Python utilities for the *SOFiSTiK* finite element analysis software.

---

> [!IMPORTANT]  
> **SOFiSTiK is a registered trademark of SOFiSTiK AG.**
>
> *py-sofistik-utils* is **NOT** affiliated with, endorsed by or vetted by SOFiSTiK AG. It is an open-source collection of tools that interfaces with certain proprietary SOFiSTiK's DLLs, which are **NOT** distributed with this repository nor with the PyPI wheels and must be supplied by the user. The project is intended for business and educational use.
>

## Dependencies

- [pandas](https://pandas.pydata.org/) (`v3.0.0`)

## Documentation

Reference documentation is available in [HTML](XXX) and [PDF](XXX) formats.

## License and attribution

All material in this repository is licensed under a three-clause [BSD
license](LICENSE).

Please use the following BibTeX template to cite py-sofistik-utils:

```bibtex
@misc{py-sofistik-utils,
  author = {Studio W Engineers},
  title = {py-sofistik-utils: Python utilities for the SOFiSTiK finite element analysis software},
  year = {2026},
  url = {https://github.com/StudioWEngineers/py-sofistik-utils}
}
```
song-schema 0.1.0
Pydantic models for defining Ableton Live song configurations
Requires Python: >=3.11

# Song Schema

Pydantic models for defining Ableton Live song configurations.

## Overview

This package provides a comprehensive schema for defining songs as JSON configurations that can be executed against Ableton Live via the OSC API.

## Installation

```bash
poetry install
```

## Usage

```python
from song_schema import SongConfig
from song_schema.validate import validate

# Load a song configuration
song = SongConfig.load("examples/lofi-beat.json")

# Validate it
result = validate(song)
print(result.summary())

# Access properties
print(f"Tempo: {song.metadata.tempo}")
print(f"Tracks: {list(song.tracks.keys())}")

# Save changes
song.save("my_song.json")
```

## Schema Structure

- **metadata**: Tempo, key, scale, time signature, groove, loop settings
- **structure**: Song sections (intro, verse, chorus, etc.) mapped to Ableton scenes
- **tracks**: MIDI/audio tracks with devices, clips, and mix settings
- **mixing**: Return tracks and master processing chain

## Examples

See the `examples/` directory:
- `minimal.json` - Simplest valid song configuration
- `lofi-beat.json` - A realistic lo-fi hip-hop beat
- `full-coverage.json` - Every field populated for reference

## Related Projects

- `ableton-mcp-server` - MCP server that exposes OSC tools to Claude
- `ableton-osc-client` - Python client for AbletonOSC
langchange 0.1.0
Python Library for Language Change
Requires Python: >=3.8

# LanguageChange

LanguageChange is a Python toolkit for exploring lexical semantic change across corpora and time. It bundles data loaders, embedding pipelines, alignment strategies, and evaluation utilities so you can go from raw corpora to change scores and visual analyses in a single workflow.

## Key Features
- Ready-to-use benchmarks (SemEval 2020 Task 1, DWUG) plus helpers for your own corpora.
- Static and contextualised representation pipelines (count, PPMI, SVD, transformer-based) with caching.
- Alignment and comparison utilities (e.g. Orthogonal Procrustes) and standard change metrics such as PRT and APD.
- Plotting helpers for DWUG graphs and embeddings to inspect model behaviour visually.

## Installation

```bash
pip install languagechange
```

LanguageChange targets Python 3.8+ and depends on PyTorch, transformers, and several NLP/visualisation libraries. Installing inside a virtual environment is recommended.

## Quickstart

```python
from pathlib import Path
from languagechange.benchmark import SemEval2020Task1
from languagechange.models.representation.static import CountModel, PPMI, SVD

# Download the English SemEval 2020 Task 1 benchmark to the local cache
benchmark = SemEval2020Task1("EN")
corpus = benchmark.corpus1_lemma

artifacts = Path("artifacts")
artifacts.mkdir(exist_ok=True)

# Build a count-based space, transform it with PPMI, then reduce with SVD
count = CountModel(corpus, window_size=10, savepath=artifacts / "corpus1_count")
count.encode()

ppmi = PPMI(count, shifting_parameter=5, smoothing_parameter=0.75, savepath=artifacts / "corpus1_ppmi")
ppmi.encode()

svd = SVD(ppmi, dimensionality=100, gamma=1.0, savepath=artifacts / "corpus1_svd")
svd.encode()
svd.load()

print(svd["plane_nn"])  # vector for a target lemma
```

More end-to-end walkthroughs live in the [examples](examples):
- [Compare static representations](examples/compare-representations/) across time slices.
- [Visualise DWUG usage graphs](examples/visualizations/) to inspect annotator judgements.

## Development Setup

Clone the repository and install an editable build with the project extras you need:

```bash
git clone https://github.com/ChangeIsKey/languagechange.git
cd languagechange
python -m venv .venv && source .venv/bin/activate
pip install -e .
```

Running the examples may require additional packages listed under each example directory.

## Documentation

For more detailed information, read the [API reference guide](https://languagechange.readthedocs.io/en/latest/).

## Citation

The library is under active development. If it supports your research, please cite it as:

```
@misc{languagechange,
  title = {LanguageChange: A Python library for studying semantic change},
  author = {{Change is Key!}},
  year = {n.d.}
}
```

## Credits

LanguageChange is developed by the [*Change is Key!*](https://www.changeiskey.org/) team with support from Riksbankens Jubileumsfond (grant M21-0021). Contributions and feedback are very welcome—feel free to open issues or pull requests.