semvec/pypi-packages huggingface dataset:
awesome-caller-boi 0.2.4
A FastAPI router + Twilio⇆OpenAI realtime streaming helper
Requires Python: >=3.8

# awesome_caller_boi

A small Python package that exposes a FastAPI router to connect Twilio’s voice streaming directly to the OpenAI realtime API (GPT-4o). It handles incoming calls, establishes the WebSocket media stream with Twilio, forwards audio to OpenAI, and sends back OpenAI’s audio response to the caller.

## Features

- Provides a FastAPI router for Twilio voice webhooks.
- Streams inbound audio from Twilio to OpenAI in real time.
- Encodes and forwards OpenAI’s audio responses back to Twilio.
- Automatically handles speech interruptions (caller starts speaking mid-response).
- Easy to configure with your own `get_system_message()` and `get_system_greeting()` callbacks.
- Put your OpenAi key in your enviornment variables and call it OPENAI_API_KEY

## Installation

From PyPI (once published):
```bash
pip install awesome_caller_boi

## Usage Example 

from awesome_caller_boi.call_handler import create_call_router
from models.transcripts import Transcript

def my_middleware_fn(transcript: Transcript) -> dict:
    # extract name, order, etc., or send it to your database
    print("Got a finished call from:", transcript.phone_number)
    print("Full transcript text:", transcript.call_text)
    return {"status": "ok"}

app.include_router(
    create_call_router(
        get_system_message=my_system_message,
        get_system_greeting=my_system_greeting,
        voice="alloy",
        on_call_complete=my_middleware_fn
    )
)
bindcurve 0.1.2
A Python package for fitting and plotting of binding curves.
Requires Python: >=3.8

# Welcome to BindCurve

[![License: MIT](https://img.shields.io/github/license/choutkaj/bindcurve)](https://github.com/choutkaj/bindcurve/blob/main/LICENSE)
[![Pylint](https://github.com/choutkaj/bindcurve/actions/workflows/pylint.yml/badge.svg)](https://github.com/choutkaj/bindcurve/actions/workflows/pylint.yml)



This repository contains `bindcurve` - a lightweight Python package for fitting and plotting of binding curves (dose-response curves). It contains the logistic model for fitting $`\text{IC}_{50}`$ or $`\text{logIC}_{50}`$ and also  exact polynomial models for fitting $K_d$ from both direct and competitive binding experiments. Fixing lower and upper asymptotes of the models during fitting is supported, as well as fixing the slope in the logistic model. Additionally, $`\text{IC}_{50}`$ values can be converted to $K_d$ using conversion models.

`bindcurve` is intended as a simple tool for Python-based workflows in Jupyter notebooks or similar tools. Even if you have never used Python before, you can fit your binding curve in less than 5 lines of code. The results can be conveniently plotted with another few lines of code or simply reported in formatted output.



## Documentation
The `bindcurve` documentation can be found at https://choutkaj.github.io/bindcurve/.

## Installation
`bindcurve` is installed from pip using

```python
pip install bindcurve
```

If you want to upgrade to the latest version, use

```python
pip install --upgrade bindcurve
```

## Basic usage
`bindcurve` contains functions that are executed directly on Pandas DataFrames, which are used to store the data. The following example demonstrates the most basic usage. See the tutorials for more instructions and examples.

### Fitting
```python
# Import bindcurve
import bindcurve as bc

# Load data from csv file
input_data = bc.load_csv("path/to/your/file.csv")

# This DataFrame will now contain preprocessed input data
print(input_data)

# Fit IC50 from your data
IC50_results = bc.fit_50(input_data, model="IC50")
print(IC50_results)

# Fit Kd from your data
Kd_results = bc.fit_Kd_competition(input_data, model="comp_3st_specific", RT=0.05, LsT=0.005, Kds=0.0245)
print(Kd_results)
```
### Plotting
```python
# Import matplotlib
import matplotlib.pyplot as plt

# Initiate the plot
plt.figure(figsize=(6, 5))

# Plot your curves from the IC50_results dataframe
bc.plot(input_data, IC50_results)

# Just use matplotlib to set up and show the plot 
plt.xlabel("your x label")
plt.ylabel("your y label")
plt.xscale("log")
plt.legend()
plt.show()
```



## How to cite
No dedicated DOI is available yet. Please cite this repository.

## License

`bindcurve` is published under the MIT license.
altex 0.2.0
A simple wrapper on top of Altair to make charts with an express API
Requires Python: <3.14,>=3.9
Keywords: altair, charts, python, streamlit, visualization

# Altex

A simple wrapper on top of Altair to make charts in Streamlit with an express API. 

If you're lazy and/or familiar with Altair, this is probably a good fit! Inspired by tvst/plost and plotly-express.

## Installation

```bash
pip install altex
```

Or with uv (recommended):
```bash
uv add altex
```

## Quick Start

```python
import streamlit as st
import altex
import pandas as pd

# Create sample data
data = pd.DataFrame({
    'x': range(10),
    'y': [i**2 for i in range(10)]
})

# Create and display charts in Streamlit
altex.line_chart(data=data, x='x', y='y', title='My Chart')
altex.bar_chart(data=data, x='x', y='y', color='x')
altex.scatter_chart(data=data, x='x', y='y', opacity=0.7)
```

## 🎨 Demo App

Try the interactive demo:

```bash
# Clone this repository
git clone https://github.com/arnaudmiribel/altex.git
cd altex
uv sync
uv run streamlit run streamlit_app.py
```

The demo showcases:
- 📊 Beautiful chart examples
- ✨ Sparklines for dashboards  
- 🚀 Quick start guide
- 📝 Simple API examples

## Chart Types

- `line_chart()` - Line charts
- `bar_chart()` - Bar charts  
- `area_chart()` - Area charts
- `scatter_chart()` - Scatter plots
- `hist_chart()` - Histograms
- `sparkline_chart()` - Sparkline charts
- `sparkbar_chart()` - Spark bar charts
- `sparkarea_chart()` - Spark area charts

## Features

- Simple, express-like API
- Built on top of Altair
- Automatic Streamlit integration when available
- Sample data utilities
- Support for rolling averages, custom styling, and more

## License

Apache-2.0