Scrum Summarizer

Scenario

Goal: summarize the scrum in points

record audio in ubuntu with python and flask and send to my another local API as a batch of streams.

Every 5 minutes, I will have to send audio to the API in the batch.

Also, I need to transcribe the multiple audio batches in flask and show the transcribed content in jinja2.

High-Level Steps

Record Audio: Use a Python library like sounddevice or pyaudio to record audio.
Save and Batch Audio Files: Save the audio files locally, and batch them every 5 minutes.
Send Batches to Another API: Use the requests library to send audio batches to your second API endpoint.
Transcribe Audio: Use a transcription service or library (e.g., OpenAI Whisper, Google Speech-to-Text, or SpeechRecognition) to process the audio.
Display Transcription in Jinja2: Store the transcription data and render it in a Flask template using Jinja2.

Implementation Details

1. Record Audio

Install the necessary libraries:

pip install sounddevice numpy flask

Example code to record audio:

import sounddevice as sd
from scipy.io.wavfile import write
import os

def record_audio(file_name, duration=60, sample_rate=44100):
    print(f"Recording {file_name}...")
    recording = sd.rec(int(duration * sample_rate), samplerate=sample_rate, channels=2, dtype='int16')
    sd.wait()
    write(file_name, sample_rate, recording)
    print(f"Saved: {file_name}")

2. Save and Batch Audio Files

Use a task scheduler (e.g., apscheduler) to batch files every 5 minutes.

pip install apscheduler

Example code for batching:

from apscheduler.schedulers.background import BackgroundScheduler
import glob
import requests

audio_dir = "audio_batches"

def batch_and_send():
    print("Batching audio...")
    files = glob.glob(f"{audio_dir}/*.wav")
    if files:
        with open("batch.zip", "wb") as batch_file:
            for file in files:
                with open(file, "rb") as f:
                    batch_file.write(f.read())
        send_to_api("batch.zip")
        for file in files:
            os.remove(file)  # Clean up after batching
    else:
        print("No files to batch.")

def send_to_api(batch_file):
    print(f"Sending {batch_file} to API...")
    response = requests.post("http://localhost:5001/api/upload", files={"file": open(batch_file, "rb")})
    print(f"API Response: {response.status_code}, {response.text}")

scheduler = BackgroundScheduler()
scheduler.add_job(batch_and_send, 'interval', minutes=5)
scheduler.start()

3. Transcribe Audio

Install a transcription library like SpeechRecognition or OpenAI Whisper.

pip install SpeechRecognition

Transcription example:

import speech_recognition as sr

def transcribe_audio(file_name):
    recognizer = sr.Recognizer()
    with sr.AudioFile(file_name) as source:
        audio = recognizer.record(source)
    try:
        transcription = recognizer.recognize_google(audio)
        print(f"Transcription: {transcription}")
        return transcription
    except sr.UnknownValueError:
        return "Could not understand audio"
    except sr.RequestError as e:
        return f"Error: {e}"

4. Display Transcriptions in Flask with Jinja2

Flask app example:

from flask import Flask, render_template, request
import os

app = Flask(__name__)

@app.route("/")
def index():
    transcriptions = []
    audio_dir = "audio_batches"
    files = glob.glob(f"{audio_dir}/*.wav")
    for file in files:
        transcription = transcribe_audio(file)
        transcriptions.append({"file": os.path.basename(file), "text": transcription})
    return render_template("index.html", transcriptions=transcriptions)

if __name__ == "__main__":
    app.run(debug=True)

5. Create Jinja2 Template

templates/index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Audio Transcriptions</title>
</head>
<body>
    <h1>Transcriptions</h1>
    <ul>
        {% for transcription in transcriptions %}
            <li>
                <strong>{{ transcription.file }}</strong>: {{ transcription.text }}
            </li>
        {% endfor %}
    </ul>
</body>
</html>

Summary of Workflow

Record audio files and save them locally.
Batch the files every 5 minutes and send them to the API.
The API processes the batch, transcribes them, and stores the results.
Use Flask and Jinja2 to display the transcriptions on a web page.

Let me know if you'd like any additional clarifications or improvements!

PreviousCricket NextTemplate

Last updated 1 year ago