Looping through list of podcast episodes using Python

[johnkmayo]

I've been able to transcribe one of my podcast episodes using the "Code tutorial: Transcribe pre-recorded audio" demo code in the dashboard.

The demo code has the bulk of the logic in the main() routine, including the information on the file being processed. The main body of the script it simply:
asyncio.run(main())

I'm not familiar with asyncio and why it is needed.

I'm looking for guidance on how to loop through multiple files to transcribe using the asyncio call. I'm familiar with how to loop through files in Python but the use of asyncio has me a bit confused.

[geekchick]

Hi @johnkmayo which Operating System and version of Python are you using?

[geekchick]

@johnkmayo Can you please share your code?

[geekchick]

Also, I'm working on a non-async Python SDK so you can transcribe your prerecorded files without asyncio. I'm hoping to have it published in the next two weeks.

[johnkmayo]

It is the Python demo code from the "Code tutorial: Transcribe pre-recorded audio" demo code in the dashboard:

from deepgram import Deepgram
import asyncio, json

# The API key we created in step 3
DEEPGRAM_API_KEY = 'YOUR_SECRET'

# Hosted sample file
AUDIO_URL = "https://static.deepgram.com/examples/Bueller-Life-moves-pretty-fast.wav"

async def main():
    # Initializes the Deepgram SDK
    dg_client = Deepgram(DEEPGRAM_API_KEY)
    source = {'url': AUDIO_URL}
    options = { "punctuate": True, "model": "general", "language": "en", "tier": "enhanced" }

    print('Requesting transcript...')
    print('Your file may take up to a couple minutes to process.')
    print('While you wait, did you know that Deepgram accepts over 40 audio file formats? Even MP4s.')
    print('To learn more about customizing your transcripts check out developers.deepgram.com')

    response = await dg_client.transcription.prerecorded(source, options)
    print(json.dumps(response, indent=4))

asyncio.run(main())

[geekchick]

Ok, I'll take a look. Are you getting any kind of error(s)?

[johnkmayo]

The demo code works but I haven't figured out how to process a list of episodes with it. normally I would have renamed the main() to something like process_podcast_episode() and moved the AUDIO_URL from a module level constant to a parameter passed into process_podcast_episode(). I would then loop through a list of episodes and pass each one into process_podcast_episode(). But, given that main() isn't called but passed into asyncio(), I don't even know where to start to put some simple looping around the demo code.

[geekchick]

You could do something like the below example I created. The only difference is the files are on my local machine in a folder called speeches and not hosted.

from deepgram import Deepgram
import asyncio, json
import os

DEEPGRAM_API_KEY="DEEPGRAM_API_KEY"

async def get_audio_files():
    path_of_the_speeches = 'speeches'
    for filename in os.listdir(path_of_the_speeches):
        audio_file = os.path.join(path_of_the_speeches,filename)
        if os.path.isfile(audio_file):
            await main(audio_file)


    return audio_file



async def main(file):
    print(f"Speech Name: {file}")

    # Initializes the Deepgram SDK
    deepgram = Deepgram(DEEPGRAM_API_KEY)
    # Open the audio file
    with open(file, 'rb') as audio:
        # ...or replace mimetype as appropriate
        source = {'buffer': audio, 'mimetype': 'audio/mp3'}
        response = await deepgram.transcription.prerecorded(source, {'punctuate': True})

        print(json.dumps(response, indent=4))
        
 asyncio.run(get_audio_files())

[geekchick]

If you provide me your hosted files I can try with those.

[johnkmayo]

This page (http://comicbookpage.com/PodcastContents/ShowNotes/EpisodeArchive.php) has download links to all of my podcast episodes.

My episodes average around an hour with some being shorter and a few being much longer. Obviously for budget reasons, I'm not going to pump them all through this sort of process at once. I'm still trying to figure out if episode transcripts are worth having. I need to figure out an overall gameplan for episode transcripts and pumping a couple of episodes through the process would give me a sense of the usefulness of automated transcripts.

[geekchick]

Hi @johnkmayo, thank you for the link! I'm able to loop through the hosted transcripts with the code I created below. I created a list called audio_urls that holds the hosted files, then looped through each to get the transcript. Would this solution work for you?

from deepgram import Deepgram
import asyncio, json
import os

DEEPGRAM_API_KEY="DEEPGRAM_API_KEY"

audio_urls = ["https://static.deepgram.com/examples/Bueller-Life-moves-pretty-fast.wav", 
            "http://www.comicbookpage.com/Podcast/EpisodeArchive/MonthlyComicsSpotlight/MonthlyComicsSpotlight-027-2022-09.mp3",
            "http://www.comicbookpage.com/Podcast/EpisodeArchive/TelevisionSpotlight/StarTrekStrangeNewWorldsSeason1.mp3"]


async def main():
    dg_client = Deepgram(DEEPGRAM_API_KEY)

    for audio_file in audio_urls:
        print(f"Speech Name: {audio_file}")
        source = {'url': audio_file}
        options = { "punctuate": True, "model": "general", "language": "en", "tier": "enhanced" }

        response = await dg_client.transcription.prerecorded(source, options)
        print(json.dumps(response, indent=4))

asyncio.run(main())

[johnkmayo]

Great. Thanks for the code.

[geekchick]

Sure thing! If that works for you, just let me know! You can also check the Mark as answer button in this thread. As always, please feel to reach out if you have any questions related to Deepgram and/or Python. We're more than happy to help!

[geekchick]

Also, in terms of asyncio it's really not needed for prerecorded audio transcriptions because that type doesn't use websockets like streaming or real-time transcription. It allows one to run code concurrently. For example, if you're trying to run multiple tasks in your code with asyncio you don't have to wait until the task is finished to run the next task, they can happen at the same time. So I suppose asyncio makes the code runtime a little faster.