semvec/pypi-packages huggingface dataset:
parlona 1.0.5
Call analytics pipeline for speech-to-text, summarization, and insights extraction
Requires Python: >=3.9
Keywords: speech-to-text, call-analytics, whisper, llm, summarization

# Parlona

Call analytics pipeline for speech-to-text, summarization, and insights extraction.

## Installation

```bash
pip install parlona
```

Set your LLM API key (for OpenAI):

```bash
export OPENAI_API_KEY="your-api-key"
```

## Quick Start

```python
import parlona

# Process an audio file
result = parlona.process("call.wav")

# Access results
print(result.transcript)
print(result.summary)
print(result.headline)
print(f"Sentiment: {result.sentiment.label} ({result.sentiment.score})")
print(f"Entities: {result.entities}")
```

## Features

- **Speech-to-Text**: Powered by faster-whisper with stereo channel diarization
- **Call Summarization**: LLM-powered summaries via OpenAI, Groq, vLLM, or Ollama
- **Sentiment Analysis**: Automatic sentiment detection and scoring
- **Entity Extraction**: Named entity recognition with speaker attribution
- **Multi-language Support**: Automatic language detection

## Advanced Usage

```python
from parlona import CallProcessor, STTConfig, LLMConfig

# Custom configuration
stt_config = STTConfig(
    model_name="Systran/faster-whisper-medium",
    device="cuda",
    diarization_mode="stereo_channels",
    speaker_mapping={0: "agent", 1: "customer"}
)

llm_config = LLMConfig(
    backend="openai",
    api_key="your-api-key",
    model="gpt-4o-mini"
)

# Create processor and process
processor = CallProcessor(stt_config=stt_config, llm_config=llm_config)
result = processor.process("call.wav")
```

## Modular Usage

Use STT and LLM components separately:

```python
from parlona.stt import STTEngine, STTConfig
from parlona.llm import LLMClient, LLMConfig

# STT only
stt_engine = STTEngine(STTConfig())
transcription = stt_engine.transcribe("audio.wav")

# LLM only
llm_client = LLMClient(LLMConfig(backend="openai"))
summary, headline, lang, sentiment, entities, score = \
    llm_client.summarize_with_headline(transcript)
```

## Requirements

- Python 3.9+
- OpenAI API key (or other LLM backend)

## License

Apache-2.0
pac0-cli 0.21.0
Outil en ligne de commande (CLI) du projet PAC
Requires Python: >=3.13

# pac cli

```
______________________________ 
________________ ________  __ \
_____  __ \  __ `/  ___/  / / /
____  /_/ / /_/ // /__ / /_/ / 
___  .___/\__,_/ \___/ \____/  
__/_/                          

```

Outil en ligne de commade (CLI) du projet pac (Plateforme Agréée Communautaire).
En plus de l'usage CLI, un mode application console est disponible.

Caractéristiques principales:
- utilise les librairies python typer et textual
- appelé par la commande `pac-cli` or `pac`
- publié sur pypi avec le nom `pac-cli`

Caractéristiques principales de la version CLI:
- commande `pac-cli setup tool` qui vérifie les versions d'outils et les installe si besoin (selon un fichier YAML de référence). Exemple: nats-server, natscli, seaweedfs ...
- commande `pac-cli setup source` qui clone le dépôt github https://github.com/paxpar-tech/PA_Communautaire
- commande `pac-cli run pac0` qui lance `uv run fastapi dev src/pac0/service/api_gateway/main.py` du dépôt cloné
- commande `pac-cli run pac0 --svc 01-api-gateway` qui lance `uv run fastapi dev src/pac0/service/api_gateway/main.py` du dépôt cloné ou un autre service selon la valeur de `--svc`
- commande `pac-cli test all` qui lance une commande via subprocess


Caractéristiques principales de la version console:
- commande `pac-cli` ou `pac-cli console` qui lance la version console
- reproduire l'ergonomie générale de l'application console [k9s](https://k9scli.io/)
- avoir une palette de commande
- avoir des raccourcis clavier
- avoir une page `services` où lister les services pac0
- pouvoir afficher le log d'un service
- avoir une page `stats` où afficher des compteurs (factures reçues, factures traitées, erreur, ...)
- avoir une page `tests` où lister les tests depuis un fichier xml testsuites
aecg 0.1.3
Python parser and viewer for Annotated ECG HL7 files
Requires Python: >=3.12

# aECG (Python parser for annotated ECG HL7 files)

Python library to parse and visualize [aECG files](https://en.wikipedia.org/wiki/HL7_aECG).

<img src="https://raw.githubusercontent.com/ghilesmeddour/aecg/13aafa7f29d7142f6d3d28baa41b9805dafbb965/res/aecg.png" width="900">

## Demo

[![Open in Streamlit](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://annotated-ecg.streamlit.app/)

## Installation

```
pip install aecg
```

## Usage

- Read your aECG xml file.

```python
import aecg

file_path = r"tests/data/Example aECG.xml"
aecg_o = aecg.read(file_path)
```

- Use `summary` to get an overview of the data.

```python
aecg_o.summary()
```

```python
{
    'id': UUID('61d1a24f-b47e-41aa-ae95-f8ac302f4eeb'),
    'date': datetime.datetime(2002, 11, 22, 9, 10),
    'series_count': 1,
    'annotations_count': 167,
}
```

- Get waveforms dataframes and their associated plots.

```python
titles = []
dfs = []
figs = []

for serie in aecg_o.series:
    for i, seq_set in enumerate(serie.sequence_sets, 1):
        title = f"Serie {serie.id} | Sequence set {i}"
        df = seq_set.get_sequences_df()
        fig = aecg.plotter.plot_seq_set(df, title=title)
        dfs.append(df)
        titles.append(title)
        figs.append(fig)

    for i, seq_set in enumerate(serie.derived_sequence_sets, 1):
        title = f"Serie {serie.id} | Derived sequence set {i}"
        df = seq_set.get_sequences_df()
        fig = aecg.plotter.plot_seq_set(df, title=title)
        dfs.append(df)
        titles.append(title)
        figs.append(fig)
```

```python
dfs[0]
```

<img src="res/df_1.png">

```python
figs[0].show()
```

<img src="res/seq_plot_1.png">

- You can choose to plot all the curves together.

```python
aecg.plotter.plot_seq_set(dfs[0], plot_mode="one")
```

<img src="res/seq_plot_1_mode_one.png">