init commit

.gitignore

@@ -0,0 +1,2 @@
+venv/
+.idea/

app/app.py

@@ -0,0 +1,463 @@
+import json
+
+import gradio as gr
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+import requests
+
+from helpers import make_header, upload_file, request_transcript, make_polling_endpoint, wait_for_completion, \
+    make_html_from_topics, make_paras_string, create_highlighted_list, make_summary, \
+    make_sentiment_output, make_entity_dict, make_entity_html, make_true_dict, make_final_json, make_content_safety_fig
+
+from helpers import transcription_options_headers, audio_intelligence_headers, language_headers
+
+
+def change_audio_source(radio, plot, file_data, mic_data):
+    """When the audio source radio selector is changed, update the wave plot and change the audio selector accordingly"""
+
+    # Empty plot
+    plot.update_traces(go.Line(y=[]))
+    # Update plot with appropriate data and change visibility audio components
+    if radio == "Audio File":
+        sample_rate, audio_data = file_data
+        plot.update_traces(go.Line(y=audio_data, x=np.arange(len(audio_data)) / sample_rate))
+        return [gr.Audio.update(visible=True),
+                gr.Audio.update(visible=False),
+                plot,
+                plot]
+    elif radio == "Record Audio":
+        sample_rate, audio_data = mic_data
+        plot.update_traces(go.Line(y=audio_data, x=np.arange(len(audio_data)) / sample_rate))
+        return [gr.Audio.update(visible=False),
+                gr.Audio.update(visible=True),
+                plot,
+                plot]
+
+
+def plot_data(audio_data, plot):
+    """Updates plot and appropriate state variable when audio is uploaded/recorded or deleted"""
+    # If the current audio file is deleted
+    if audio_data is None:
+        # Replace the state variable for the audio source with placeholder values
+        sample_rate, audio_data = [0, np.array([])]
+        # Update the plot to be empty
+        plot.update_traces(go.Line(y=[]))
+    # If new audio is uploaded/recorded
+    else:
+        # Replace the current state variable with new
+        sample_rate, audio_data = audio_data
+        # Plot the new data
+        plot.update_traces(go.Line(y=audio_data, x=np.arange(len(audio_data)) / sample_rate))
+
+    # Update the plot component and data state variable
+    return [plot, [sample_rate, audio_data], plot]
+
+
+def set_lang_vis(transcription_options):
+    """Sets visibility of language selector/warning when automatic language detection is (de)selected"""
+    if 'Automatic Language Detection' in transcription_options:
+        text = w
+        return [gr.Dropdown.update(visible=False),
+                gr.Textbox.update(visible=True),
+                text]
+    else:
+        text = ""
+        return [gr.Dropdown.update(visible=True),
+                gr.Textbox.update(visible=False),
+                text]
+
+
+def option_verif(language, selected_tran_opts, selected_audint_opts):
+    """When the language is changed, this function automatically deselects options that are not allowed for that
+    language."""
+
+    not_available_tran, not_available_audint = get_unavailable_opts(language)
+
+    current_tran_opts = list(set(selected_tran_opts) - set(not_available_tran))
+    current_audint_opts = list(set(selected_audint_opts) - set(not_available_audint))
+
+    return [current_tran_opts,
+            current_audint_opts,
+            current_tran_opts,
+            current_audint_opts]
+
+
+# Get tran/audint opts that are not available by language
+def get_unavailable_opts(language):
+    """Get transcription and audio intelligence options that are unavailable for a given language"""
+    if language in ['Spanish', 'French', 'German', 'Portuguese']:
+        not_available_tran = ['Speaker Labels']
+        not_available_audint = ['PII Redaction', 'Auto Highlights', 'Sentiment Analysis', 'Summarization',
+                                'Entity Detection']
+
+    elif language in ['Italian', 'Dutch']:
+        not_available_tran = ['Speaker Labels']
+        not_available_audint = ['PII Redaction', 'Auto Highlights', 'Content Moderation', 'Topic Detection',
+                                'Sentiment Analysis', 'Summarization', 'Entity Detection']
+
+    elif language in ['Hindi', 'Japanese']:
+        not_available_tran = ['Speaker Labels']
+        not_available_audint = ['PII Redaction', 'Auto Highlights', 'Content Moderation', 'Topic Detection',
+                                'Sentiment Analysis', 'Summarization', 'Entity Detection']
+
+    else:
+        not_available_tran = []
+        not_available_audint = []
+
+    return not_available_tran, not_available_audint
+
+
+# When selecting new tran option, checks to make sure allowed by language and
+# then adds to selected_tran_opts and updates
+def tran_selected(language, transcription_options):
+    """When a transcription option is selected, """
+    unavailable, _ = get_unavailable_opts(language)
+    selected_tran_opts = list(set(transcription_options) - set(unavailable))
+
+    return [selected_tran_opts, selected_tran_opts]
+
+
+# When selecting new audint option, checks to make sure allowed by language and
+# then adds to selected_audint_opts and updates
+def audint_selected(language, audio_intelligence_selector):
+    """Deselected"""
+    _, unavailable = get_unavailable_opts(language)
+    selected_audint_opts = list(set(audio_intelligence_selector) - set(unavailable))
+
+    return [selected_audint_opts, selected_audint_opts]
+
+
+def create_ouput(r, paras, language, transc_opts=None, audint_opts=None):
+    """From a transcript response, return all outputs for audio intelligence"""
+    if transc_opts is None:
+        transc_opts = ['Automatic Language Detection', 'Speaker Labels', 'Filter Profanity']
+
+    if audint_opts is None:
+        audint_opts = ['Summarization', 'Auto Highlights', 'Topic Detection', 'Entity Detection',
+         'Sentiment Analysis', 'PII Redaction', 'Content Moderation']
+
+    # DIARIZATION
+    if "Speaker Labels" in transc_opts:
+        utts = '\n\n\n'.join([f"Speaker {utt['speaker']}:\n\n" + utt['text'] for utt in r['utterances']])
+    else:
+        utts = " NOT ANALYZED"
+
+    # HIGHLIGHTS
+    if 'Auto Highlights' in audint_opts:
+        highlight_dict = create_highlighted_list(paras, r['auto_highlights_result']['results'])
+    else:
+        highlight_dict =[["NOT ANALYZED", 0]]
+
+    # SUMMARIZATION'
+    if 'Summarization' in audint_opts:
+        chapters = r['chapters']
+        summary_html = make_summary(chapters)
+    else:
+        summary_html = "<p>NOT ANALYZED</p>"
+
+    # TOPIC DETECTION
+    if "Topic Detection" in audint_opts:
+        topics = r['iab_categories_result']['summary']
+        topics_html = make_html_from_topics(topics)
+    else:
+        topics_html = "<p>NOT ANALYZED</p>"
+
+    # SENTIMENT
+    if "Sentiment Analysis" in audint_opts:
+        sent_results = r['sentiment_analysis_results']
+        sent = make_sentiment_output(sent_results)
+    else:
+        sent = "<p>NOT ANALYZED</p>"
+
+    # ENTITY
+    if "Entity Detection" in audint_opts:
+        entities = r['entities']
+        t = r['text']
+        d = make_entity_dict(entities, t)
+        entity_html = make_entity_html(d)
+    else:
+        entity_html = "<p>NOT ANALYZED</p>"
+
+    # CONTENT SAFETY
+    if "Content Moderation" in audint_opts:
+        cont = r['content_safety_labels']['summary']
+        content_fig = make_content_safety_fig(cont)
+    else:
+        content_fig = go.Figure()
+
+    return [language, paras, utts, highlight_dict, summary_html, topics_html, sent, entity_html, content_fig]
+
+
+def submit_to_AAI(api_key,
+                  transcription_options,
+                  audio_intelligence_selector,
+                  language,
+                  radio,
+                  audio_file,
+                  mic_recording):
+    # Make request header
+    header = make_header(api_key)
+
+    # Map transcription/audio intelligence options to AssemblyAI API request JSON dict
+    true_dict = make_true_dict(transcription_options, audio_intelligence_selector)
+
+    final_json, language = make_final_json(true_dict, language)
+    final_json = {**true_dict, **final_json}
+
+    # Select which audio to use
+    if radio == "Audio File":
+        audio_data = audio_file
+    elif radio == "Record Audio":
+        audio_data = mic_recording
+
+    # Upload the audio
+    upload_url = upload_file(audio_data, header, is_file=False)
+
+    # Request transcript
+    transcript_response = request_transcript(upload_url, header, **final_json)
+
+    # Wait for the transcription to complete
+    polling_endpoint = make_polling_endpoint(transcript_response)
+    wait_for_completion(polling_endpoint, header)
+
+    # Fetch results JSON
+    r = requests.get(polling_endpoint, headers=header, json=final_json).json()
+
+    # Fetch paragraphs of transcript
+    transc_id = r['id']
+    paras = make_paras_string(transc_id, header)
+    return create_ouput(r, paras, language, transcription_options, audio_intelligence_selector)
+
+
+def example_output(language):
+    """Displays example output"""
+    with open("../example_data/paras.txt", 'r') as f:
+        paras = f.read()
+
+    with open('../example_data/response.json', 'r') as f:
+        r = json.load(f)
+
+    return create_ouput(r, paras, language)
+
+
+with open('styles.css', 'r') as f:
+    css = f.read()
+
+with gr.Blocks(css=css) as demo:
+    '''
+    gr.HTML("<script>"
+            "window.addEventListener('load', function () {"
+            "gradioURL = window.location.href"
+            "if (!gradioURL.endsWith('?__theme=light')) {"
+            "window.location.replace(gradioURL + '?__theme=light');"
+            "}"
+            "});"
+            "</script>")
+    '''
+    # Load image
+    gr.HTML('<a href="https://www.assemblyai.com/"><img src="file/images/logo.png" class="logo"></a>')
+
+    # Load descriptions
+    gr.HTML("<h1 class='title'>Audio Intelligence Dashboard</h1>"
+            "<br>"
+            "<p>Check out the [BLOG NAME] blog to learn how to build this dashboard.</p>")
+
+    gr.HTML("<h1 class='title'>Directions</h1>"
+            "<p>To use this dashboard:</p>"
+            "<ul>"
+            "<li>1)  Paste your AssemblyAI API Key into the box below - you can copy it from <a href=\"https://app.assemblyai.com/signup\">here</a> (or get one for free if you don't already have one)</li>"
+            "<li>2)  Choose an audio source and upload or record audio</li>"
+            "<li>3)  Select the types of analyses you would like to perform on the audio</li>"
+            "<li>4)  Click <i>Submit</i></li>"
+            "<li>5)  View the results at the bottom of the page</li>"
+            "<ul>"
+            "<br>"
+            "<p>You may also click <b>Show Example Output</b> below to see an example without having to enter an API key.")
+
+    gr.HTML('<div class="alert alert__warning"><span>'
+            'Note that this dashboard is not an official AssemblyAI product and is intended for educational purposes.'
+            '</span></div>')
+
+    # API Key title
+    with gr.Box():
+        gr.HTML("<p class=\"apikey\">API Key:</p>")
+        # API key textbox (password-style)
+        api_key = gr.Textbox(label="", elem_id="pw")
+
+    # Gradio states for - plotly Figure object, audio data for file source, and audio data for mic source
+    plot = gr.State(px.line(labels={'x': 'Time (s)', 'y': ''}))
+    file_data = gr.State([1, [0]])  # [sample rate, [data]]
+    mic_data = gr.State([1, [0]])  # [Sample rate, [data]]
+
+    # Options that the user wants
+    selected_tran_opts = gr.State(list(transcription_options_headers.keys()))
+    selected_audint_opts = gr.State(list(audio_intelligence_headers.keys()))
+
+    # Current options = selected options - unavailable options for specified language
+    current_tran_opts = gr.State([])
+    current_audint_opts = gr.State([])
+
+    # Selector for audio source
+    radio = gr.Radio(["Audio File", "Record Audio"], label="Audio Source", value="Audio File")
+
+    # Audio object for both file and microphone data
+    with gr.Box():
+        audio_file = gr.Audio(interactive=True)
+        mic_recording = gr.Audio(source="microphone", visible=False, interactive=True)
+
+    # Audio wave plot
+    audio_wave = gr.Plot(plot.value)
+
+    # Checkbox for transcription options
+    transcription_options = gr.CheckboxGroup(
+        choices=list(transcription_options_headers.keys()),
+        value=list(transcription_options_headers.keys()),
+        label="Transcription Options",
+    )
+
+    # Warning for using Automatic Language detection
+    w = "<div class='alert alert__warning'>" \
+        "<p>Automatic Language Detection not available for Hindi or Japanese. For best results on non-US " \
+        "English audio, specify the dialect instead of using Automatic Language Detection. " \
+        "<br>" \
+        "Some Audio Intelligence features are not available in some languages. See " \
+        "<a href='https://airtable.com/shr53TWU5reXkAmt2/tblf7O4cffFndmsCH?backgroundColor=green'>here</a> " \
+        "for more details.</p>" \
+        "</div>"
+
+    auto_lang_detect_warning = gr.HTML(w)
+
+    # Checkbox for Audio Intelligence options
+    audio_intelligence_selector = gr.CheckboxGroup(
+        choices=list(audio_intelligence_headers.keys()),
+        value=list(audio_intelligence_headers.keys()),
+        label='Audio Intelligence Options'
+    )
+
+    # Language selector for manual language selection
+    language = gr.Dropdown(
+        choices=list(language_headers.keys()),
+        value="US English",
+        label="Language Specification",
+        visible=False,
+    )
+
+    # Button to submit audio for processing with selected options
+    submit = gr.Button('Submit')
+
+    # Button to submit audio for processing with selected options
+    example = gr.Button('Show Example Output')
+
+    # Results tab group
+    phl = 10
+    with gr.Tab('Transcript'):
+        trans_tab = gr.Textbox(placeholder="Your formatted transcript will appear here ...",
+                               lines=phl,
+                               max_lines=25,
+                               show_label=False)
+    with gr.Tab('Speaker Labels'):
+        diarization_tab = gr.Textbox(placeholder="Your diarized transcript will appear here ...",
+                                     lines=phl,
+                                     max_lines=25,
+                                     show_label=False)
+    with gr.Tab('Auto Highlights'):
+        highlights_tab = gr.HighlightedText()
+    with gr.Tab('Summary'):
+        summary_tab = gr.HTML("<br>" * phl)
+    with gr.Tab("Detected Topics"):
+        topics_tab = gr.HTML("<br>" * phl)
+    with gr.Tab("Sentiment Analysis"):
+        sentiment_tab = gr.HTML("<br>" * phl)
+    with gr.Tab("Entity Detection"):
+        entity_tab = gr.HTML("<br>" * phl)
+    with gr.Tab("Content Safety"):
+        content_tab = gr.Plot()
+
+    ####################################### Functionality ######################################################
+
+    # Changing audio source changes Audio input component
+    radio.change(fn=change_audio_source,
+                 inputs=[
+                     radio,
+                     plot,
+                     file_data,
+                     mic_data],
+                 outputs=[
+                     audio_file,
+                     mic_recording,
+                     audio_wave,
+                     plot])
+
+    # Inputting audio updates plot
+    audio_file.change(fn=plot_data,
+                      inputs=[audio_file, plot],
+                      outputs=[audio_wave, file_data, plot]
+                      )
+    mic_recording.change(fn=plot_data,
+                         inputs=[mic_recording, plot],
+                         outputs=[audio_wave, mic_data, plot])
+
+    # Deselecting Automatic Language Detection shows Language Selector
+    transcription_options.change(
+        fn=set_lang_vis,
+        inputs=transcription_options,
+        outputs=[language, auto_lang_detect_warning, auto_lang_detect_warning])
+
+    # Changing language deselects certain Tran / Audio Intelligence options
+    language.change(
+        fn=option_verif,
+        inputs=[language,
+                selected_tran_opts,
+                selected_audint_opts],
+        outputs=[transcription_options, audio_intelligence_selector, current_tran_opts, current_audint_opts]
+    )
+
+    # Selecting Tran options adds it to selected if language allows it
+    transcription_options.change(
+        fn=tran_selected,
+        inputs=[language, transcription_options],
+        outputs=[transcription_options, selected_tran_opts, ]
+    )
+
+    # Selecting audio intelligence options adds it to selected if language allows it
+    audio_intelligence_selector.change(
+        fn=audint_selected,
+        inputs=[language, audio_intelligence_selector],
+        outputs=[audio_intelligence_selector, selected_audint_opts]
+    )
+
+    # Clicking "submit" uploads selected audio to AssemblyAI, performs requested analyses, and displays results
+    submit.click(fn=submit_to_AAI,
+                 inputs=[api_key,
+                         transcription_options,
+                         audio_intelligence_selector,
+                         language,
+                         radio,
+                         audio_file,
+                         mic_recording],
+                 outputs=[language,
+                          trans_tab,
+                          diarization_tab,
+                          highlights_tab,
+                          summary_tab,
+                          topics_tab,
+                          sentiment_tab,
+                          entity_tab,
+                          content_tab])
+
+    # Clicking "Show Example Output" displays example results
+    example.click(fn=example_output,
+                  inputs=language,
+                  outputs=[language,
+                           trans_tab,
+                           diarization_tab,
+                           highlights_tab,
+                           summary_tab,
+                           topics_tab,
+                           sentiment_tab,
+                           entity_tab,
+                           content_tab])
+
+# Launch the application
+demo.launch()  # share=True

app/css_components/build_css.py

@@ -0,0 +1,16 @@
+# Strings together css files in this folder and exports to `../styles.css`
+
+import os
+
+css_filepaths = [f for f in os.listdir() if f.endswith(".css")]
+
+css_filepaths.remove('file.css')
+css_filepaths.insert(0, 'file.css')
+
+css = ""
+for filepath in css_filepaths:
+    with open(filepath, 'r') as file:
+        css += file.read()
+
+with open("../styles.css", 'w') as f:
+    f.write(css)

app/css_components/build_topic_detection.py

@@ -0,0 +1,25 @@
+# Programmatic way to generate `topic_detection.css`
+
+css = ".istopic {\n" \
+      "color: #6b2bd6;" \
+      "\n}" \
+      "\n\n"
+
+# Font size of highest level topic
+starting_fs = 30
+# Font size difference between topic and subtopic
+fs_diff = 5
+# Minimum font size of text
+fs_min = 15
+# Number of pixels to indent at each level
+ind = 18
+
+for i in range(10):
+    css += f".topic-L{i} {{\n" \
+           f"font-size: {max(starting_fs-i*fs_diff, fs_min)}px;\n" \
+           f"text-indent: {ind*i}px;\n" \
+           f"}}" \
+           f"\n\n"
+
+with open('topic_detection.css', 'w') as f:
+    f.write(css)

app/css_components/file.css

@@ -0,0 +1,81 @@
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica,
+    Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+}
+
+.logo {
+  width: 180px;
+}
+
+.title {
+  font-weight: 600;
+  text-align: left;
+  color: black;
+  font-size: 18px;
+}
+
+.alert,
+#component-2,
+#component-3 {
+  padding: 24px;
+  color: black;
+  background-color: #f4f8fb;
+  border: 1px solid #d6dce7;
+  border-radius: 8px;
+  box-shadow: 0px 6px 15px rgb(0 0 0 / 2%), 0px 2px 5px rgb(0 0 0 / 4%);
+}
+
+ol {
+  list-style: disc;
+}
+
+.alert__info {
+  background-color: #f4f8fb;
+  color: #323552;
+}
+
+.alert__warning {
+  background-color: #fffae5;
+  color: #917115;
+  border: 1px solid #e4cf2b;
+}
+
+#pw {
+  -webkit-text-security: disc;
+}
+
+/* unvisited link */
+a:link {
+  color: #6b2bd6;
+}
+
+/* visited link */
+a:visited {
+  color: #6b2bd6;
+}
+
+/* mouse over link */
+a:hover {
+  color: #6b2bd6;
+}
+
+/* selected link */
+a:active {
+  color: #6b2bd6;
+}
+
+li {
+  margin-left: 1em;
+}
+
+.apikey {
+}
+
+.entity-list {
+    color: #6b2bd6;
+    font-size: 16px
+}
+
+.entity-elt {
+    color: black
+}

app/css_components/topic_detection.css

@@ -0,0 +1,54 @@
+.istopic {
+color: #6b2bd6;
+}
+
+.topic-L0 {
+font-size: 30px;
+text-indent: 0px;
+}
+
+.topic-L1 {
+font-size: 25px;
+text-indent: 18px;
+}
+
+.topic-L2 {
+font-size: 20px;
+text-indent: 36px;
+}
+
+.topic-L3 {
+font-size: 15px;
+text-indent: 54px;
+}
+
+.topic-L4 {
+font-size: 15px;
+text-indent: 72px;
+}
+
+.topic-L5 {
+font-size: 15px;
+text-indent: 90px;
+}
+
+.topic-L6 {
+font-size: 15px;
+text-indent: 108px;
+}
+
+.topic-L7 {
+font-size: 15px;
+text-indent: 126px;
+}
+
+.topic-L8 {
+font-size: 15px;
+text-indent: 144px;
+}
+
+.topic-L9 {
+font-size: 15px;
+text-indent: 162px;
+}
+

app/helpers.py

@@ -0,0 +1,448 @@
+import re
+
+import requests
+import time
+from scipy.io.wavfile import write
+import io
+import plotly.express as px
+
+
+upload_endpoint = "https://api.assemblyai.com/v2/upload"
+transcript_endpoint = "https://api.assemblyai.com/v2/transcript"
+
+# Colors for sentiment analysis highlighting
+green = "background-color: #159609"
+red = "background-color: #cc0c0c"
+
+# Converts Gradio checkboxes to AssemlbyAI header arguments
+transcription_options_headers = {
+    'Automatic Language Detection': 'language_detection',
+    'Speaker Labels': 'speaker_labels',
+    'Filter Profanity': 'filter_profanity',
+}
+
+# Converts Gradio checkboxes to AssemblyAI header arguments
+audio_intelligence_headers = {
+    'Summarization': 'auto_chapters',
+    'Auto Highlights': 'auto_highlights',
+    'Topic Detection': 'iab_categories',
+    'Entity Detection': 'entity_detection',
+    'Sentiment Analysis': 'sentiment_analysis',
+    'PII Redaction': 'redact_pii',
+    'Content Moderation': 'content_safety',
+}
+
+# Converts selected language in Gradio to language code for AssemblyAI header argument
+language_headers = {
+    'Global English': 'en',
+    'US English': 'en_us',
+    'British English': 'en_uk',
+    'Australian English': 'en_au',
+    'Spanish': 'es',
+    'French': 'fr',
+    'German': 'de',
+    'Italian': 'it',
+    'Portuguese': 'pt',
+    'Dutch': 'nl',
+    'Hindi': 'hi',
+    'Japanese': 'jp',
+}
+
+
+def make_header(api_key):
+    return {
+        'authorization': api_key,
+        'content-type': 'application/json'
+    }
+
+
+def _read_file(filename, chunk_size=5242880):
+    """Helper for `upload_file()`"""
+    with open(filename, "rb") as f:
+        while True:
+            data = f.read(chunk_size)
+            if not data:
+                break
+            yield data
+
+
+def _read_array(audio, chunk_size=5242880):
+    """Like _read_file but for array - creates temporary unsaved "file" from sample rate and audio np.array"""
+    sr, aud = audio
+
+    # Create temporary "file" and write data to it
+    bytes_wav = bytes()
+    temp_file = io.BytesIO(bytes_wav)
+    write(temp_file, sr, aud)
+
+    while True:
+        data = temp_file.read(chunk_size)
+        if not data:
+            break
+        yield data
+
+
+def upload_file(audio_file, header, is_file=True):
+    """Uploads a file to AssemblyAI for analysis"""
+    upload_response = requests.post(
+        upload_endpoint,
+        headers=header,
+        data=_read_file(audio_file) if is_file else _read_array(audio_file)
+    )
+    if upload_response.status_code != 200:
+        upload_response.raise_for_status()
+    # Returns {'upload_url': <URL>}
+    return upload_response.json()
+
+
+def request_transcript(upload_url, header, **kwargs):
+    """Request a transcript/audio analysis from AssemblyAI"""
+
+    # If input is a dict returned from `upload_file` rather than a raw upload_url string
+    if type(upload_url) is dict:
+        upload_url = upload_url['upload_url']
+
+    # Create request
+    transcript_request = {
+        'audio_url': upload_url,
+        **kwargs
+    }
+
+    # POST request
+    transcript_response = requests.post(
+        transcript_endpoint,
+        json=transcript_request,
+        headers=header
+    )
+
+    return transcript_response.json()
+
+
+def make_polling_endpoint(transcript_id):
+    """Create a polling endpoint from a transcript ID to check on the status of the transcript"""
+    # If upload response is input rather than raw upload_url string
+    if type(transcript_id) is dict:
+        transcript_id = transcript_id['id']
+
+    polling_endpoint = "https://api.assemblyai.com/v2/transcript/" + transcript_id
+    return polling_endpoint
+
+
+def wait_for_completion(polling_endpoint, header):
+    """Given a polling endpoint, waits for the transcription/audio analysis to complete"""
+    while True:
+        polling_response = requests.get(polling_endpoint, headers=header)
+        polling_response = polling_response.json()
+
+        if polling_response['status'] == 'completed':
+            break
+        elif polling_response['status'] == 'error':
+            raise Exception(f"Error: {polling_response['error']}")
+
+        time.sleep(5)
+
+
+def make_true_dict(transcription_options, audio_intelligence_selector):
+    """Given transcription / audio intelligence Gradio options, create a dictionary to be used in AssemblyAI request"""
+    # Convert Gradio checkbox names to AssemblyAI API keys
+    aai_tran_keys = [transcription_options_headers[elt] for elt in transcription_options]
+    aai_audint_keys = [audio_intelligence_headers[elt] for elt in audio_intelligence_selector]
+
+    # For each checked box, set it to true in the JSON used POST request to AssemblyAI
+    aai_tran_dict = {key: 'true' for key in aai_tran_keys}
+    aai_audint_dict = {key: 'true' for key in aai_audint_keys}
+
+    return {**aai_tran_dict, **aai_audint_dict}
+
+
+def make_final_json(true_dict, language):
+    """Takes in output of `make_true_dict()` and adds all required other key-value pairs"""
+    # If automatic language detection selected but no language specified, default to US english
+    if 'language_detection' not in true_dict:
+        if language is None:
+            language = "US English"
+        true_dict = {**true_dict, 'language_code': language_headers[language]}
+    # If PII Redaction is enabled, add default redaction policies
+    if 'redact_pii' in true_dict:
+        true_dict = {**true_dict, 'redact_pii_policies': ['drug', 'injury', 'person_name', 'money_amount']}
+    return true_dict, language
+
+
+def _split_on_capital(string):
+    """Adds spaces between capitalized words of a string via regex. 'HereAreSomeWords' -> 'Here Are Some Words'"""
+    return ' '.join(re.findall("[A-Z][^A-Z]*", string))
+
+
+def _make_tree(c, ukey=''):
+    '''
+    Given a list whose elements are nested topic lists, generates a JSON-esque dictionary tree of topics and
+    subtopics
+
+    E.g. the input
+
+        [
+
+            ['Education', 'CollegeEducation', 'PostgraduateEducation'],
+
+            ['Education', 'CollegeEducation', 'UndergraduateEducation']
+
+        ]
+
+    Would output a dictionary corresponding to a tree with two leaves, 'UndergraduateEducation' and
+    'PostgraduateEducation', which fall under a node 'CollegeEducation' which in turn falls under the node 'Education'
+    
+    :param c: List of topics
+    :param ukey: "Upper key". For recursion - name of upper level key whose value (list) is being recursed on
+    :return: Dictionary that defines a tree structure
+    '''
+
+    # Create empty dict for current sublist
+    d = dict()
+
+    # If leaf, return None
+    if c is None and ukey is None:
+        return None
+    elif c is None:
+        return {None: None}
+    else:
+        # For each elt of the input (itself a list),
+        for n, i in enumerate(c):
+            # For topics with sublist e.g. if ['NewsAndPolitics' 'Politics'] and
+            # ['NewsAndPolitics' 'Politics', 'Elections'] are both in list - need way to signify politics itself
+            # included
+            if i is None:
+                d[None] = None
+            # If next subtopic not in dict, add it. If the remaining list empty, make value None
+            elif i[0] not in d.keys():
+                topic = i.pop(0)
+                d[topic] = None if i == [] else [i]
+            # If subtopic already in dict
+            else:
+                # If the value for this subtopic is only None (i.e. subject itself is a leaf), then append sublist
+                if d[i[0]] is None:
+                    d[i[0]] = [None, i[1:]]
+                # If value for this subtopic is a list itself, then append the remaining list
+                else:
+                    d[i[0]].append(i[1:])
+        # Recurse on remaining leaves
+        for key in d:
+            d[key] = _make_tree(d[key], key)
+    return d
+
+
+def _make_html_tree(dic, level=0, HTML=''):
+    """Generates an HTML tree from an output of _make_tree"""
+    HTML += "<ul>"
+    for key in dic:
+        # Add the topic to HTML, specifying the current level and whether it is a topic
+        if type(dic[key]) == dict:
+            HTML += "<li>"
+            if None in dic[key].keys():
+                del dic[key][None]
+                HTML += f'<p class="topic-L{level} istopic">{_split_on_capital(key)}</p>'
+            else:
+                HTML += f'<p class="topic-L{level}">{_split_on_capital(key)}</p>'
+            HTML += "</li>"
+
+            HTML = _make_html_tree(dic[key], level=level + 1, HTML=HTML)
+        else:
+            HTML += "<li>"
+            HTML += f'<p class="topic-L{level} istopic">{_split_on_capital(key)}</p>'
+            HTML += "</li>"
+    HTML += "</ul>"
+    return HTML
+
+
+def _make_html_body(dic):
+    """Makes an HTML body from an output of _make_tree"""
+    HTML = '<body>'
+    HTML += _make_html_tree(dic)
+    HTML += "</body>"
+    return HTML
+
+
+def _make_html(dic):
+    """Makes a full HTML document from an output of _make_tree using styles.css styling"""
+    HTML = '<!DOCTYPE html>' \
+           '<html>' \
+           '<head>' \
+           '<title>Another simple example</title>' \
+           '<link rel="stylesheet" type="text/css" href="styles.css"/>' \
+           '</head>'
+    HTML += _make_html_body(dic)
+    HTML += "</html>"
+    return HTML
+
+
+# make_html_from_topics(j['iab_categories_result']['summary'])
+def make_html_from_topics(dic, threshold=0.0):
+    """Given a topics dictionary from AAI Topic Detection API, generates appropriate corresponding structured HTML.
+    Input is `response.json()['iab_categories_result']['summary']` from GET request on AssemblyAI `v2/transcript`
+    endpoint."""
+    # Potentially filter some items out
+    cats = [k for k, v in dic.items() if float(v) >= threshold]
+
+    # Sort remaining topics
+    cats.sort()
+
+    # Split items into lists
+    cats = [i.split(">") for i in cats]
+
+    # Make topic tree
+    tree = _make_tree(cats)
+
+    # Return formatted HTML
+    return _make_html(tree)
+
+
+def make_paras_string(transc_id, header):
+    """ Makes a string by concatenating paragraphs newlines in between. Input is response.json()['paragraphs'] from
+    from AssemblyAI paragraphs endpoint """
+    endpoint = transcript_endpoint + "/" + transc_id + "/paragraphs"
+    paras = requests.get(endpoint, headers=header).json()['paragraphs']
+    paras = '\n\n'.join(i['text'] for i in paras)
+    return paras
+
+
+def create_highlighted_list(paragraphs_string, highlights_result, rank=0):
+    """Outputs auto highlights information in appropriate format for `gr.HighlightedText()`. `highlights_result` is
+    response.json()['auto_highlights_result]['results'] where response from GET request on AssemblyAI v2/transcript
+    endpoint"""
+    # Max and min opacities to highlight to
+    MAX_HIGHLIGHT = 1  # Max allowed = 1
+    MIN_HIGHLIGHT = 0.25  # Min allowed = 0
+
+    # Filter list for everything above the input rank
+    highlights_result = [i for i in highlights_result if i['rank'] >= rank]
+
+    # Get max/min ranks and find scale/shift we'll need so ranks are mapped to [MIN_HIGHLIGHT, MAX_HIGHLIGHT]
+    max_rank = max([i['rank'] for i in highlights_result])
+    min_rank = min([i['rank'] for i in highlights_result])
+    scale = (MAX_HIGHLIGHT - MIN_HIGHLIGHT) / (max_rank - min_rank)
+    shift = (MAX_HIGHLIGHT - max_rank * scale)
+
+    # Isolate only highlight text and rank
+    highlights_result = [(i['text'], i['rank']) for i in highlights_result]
+
+    entities = []
+    for highlight, rank in highlights_result:
+        # For each highlight, find all starting character instances
+        starts = [c.start() for c in re.finditer(highlight, paragraphs_string)]
+        # Create list of locations for this highlight with entity value (highlight opacity) scaled properly
+        e = [{"entity": rank * scale + shift,
+              "start": start,
+              "end": start + len(highlight)}
+             for start in starts]
+        entities += e
+
+    # Create dictionary
+    highlight_dict = {"text": paragraphs_string, "entities": entities}
+
+    # Sort entities by start char. A bug in Gradio requires this
+    highlight_dict['entities'] = sorted(highlight_dict['entities'], key=lambda x: x['start'])
+
+    return highlight_dict
+
+
+def make_summary(chapters):
+    """Makes HTML for "Summary" `gr.Tab()` tab. Input is `response.json()['chapters']` where response is from GET
+    request to AssemblyAI's v2/transcript endpoint"""
+    html = "<div>"
+    for chapter in chapters:
+        html += "<details>" \
+                f"<summary><b>{chapter['headline']}</b></summary>" \
+                f"{chapter['summary']}" \
+                "</details>"
+    html += "</div>"
+    return html
+
+
+def to_hex(num, max_opacity=128):
+    """Converts a confidence value in the range [0, 1] to a hex value"""
+    return hex(int(max_opacity * num))[2:]
+
+
+def make_sentiment_output(sentiment_analysis_results):
+    """Makes HTML output of sentiment analysis info for display with `gr.HTML()`. Input is
+    `response.json()['sentiment_analysis_results']` from GET request on AssemblyAI v2/transcript."""
+    p = '<p>'
+    for sentiment in sentiment_analysis_results:
+        if sentiment['sentiment'] == 'POSITIVE':
+            p += f'<mark style="{green + to_hex(sentiment["confidence"])}">' + sentiment['text'] + '</mark> '
+        elif sentiment['sentiment'] == "NEGATIVE":
+            p += f'<mark style="{red + to_hex(sentiment["confidence"])}">' + sentiment['text'] + '</mark> '
+        else:
+            p += sentiment['text'] + ' '
+    p += "</p>"
+    return p
+
+
+def make_entity_dict(entities, t, offset=40):
+    """Creates dictionary that will be used to generate HTML for Entity Detection `gr.Tab()` tab.
+    Inputs are response.json()['entities'] and response.json()['text'] for response of GET request
+    on AssemblyAI v2/transcript endpoint"""
+    len_text = len(t)
+
+    d = {}
+    for entity in entities:
+        # Find entity in the text
+        s = t.find(entity['text'])
+        if s == -1:
+            p = None
+        else:
+            len_entity = len(entity['text'])
+            # Get entity context (colloquial sense)
+            p = t[max(0, s - offset):min(s + len_entity + offset, len_text)]
+            # Make sure start and end with a full word
+            p = '... ' + ' '.join(p.split(' ')[1:-1]) + ' ...'
+        # Add to dict
+        label = ' '.join(entity['entity_type'].split('_')).title()
+        if label in d:
+            d[label] += [[p, entity['text']]]
+        else:
+            d[label] = [[p, entity['text']]]
+
+    return d
+
+
+def make_entity_html(d, highlight_color="#FFFF0080"):
+    """Input is output of `make_entity_dict`. Creates HTML for Entity Detection info"""
+    h = "<ul>"
+    for i in d:
+        h += f"""<li style="color: #6b2bd6; font-size: 20px;">{i}"""
+        h += "<ul>"
+        for sent, ent in d[i]:
+            if sent is None:
+                h += f"""<li style="color: black; font-size: 16px;">[REDACTED]</li>"""
+            else:
+                h += f"""<li style="color: black; font-size: 16px;">{sent.replace(ent, f'<mark style="background-color: {highlight_color}">{ent}</mark>')}</li>"""
+        h += '</ul>'
+        h += '</li>'
+    h += "</ul>"
+    return h
+
+
+def make_content_safety_fig(cont_safety_summary):
+    """Creates content safety figure from response.json()['content_safety_labels']['summary'] from GET request on
+    AssemblyAI v2/transcript endpoint"""
+    # Create dictionary as demanded by plotly
+    d = {'label': [], 'severity': [], 'color': []}
+
+    # For each sentitive topic, add the (formatted) name, severity, and plot color
+    for key in cont_safety_summary:
+        d['label'] += [' '.join(key.split('_')).title()]
+        d['severity'] += [cont_safety_summary[key]]
+        d['color'] += ['rgba(107, 43, 214, 1)']
+
+    # Create the figure (n.b. repetitive color info but was running into plotly bugs)
+    content_fig = px.bar(d, x='severity', y='label', color='color', color_discrete_map={
+        'Crime Violence': 'rgba(107, 43, 214, 0.1)',
+        'Alcohol': 'rgba(107, 43, 214, 0.1)',
+        'Accidents': 'rgba(107, 43, 214, 0.1)'})
+
+    # Update the content figure plot
+    content_fig.update_layout({'plot_bgcolor': 'rgba(107, 43, 214, 0.1)'})
+
+    # Scales axes appropriately
+    content_fig.update_xaxes(range=[0, 1])
+    return content_fig

app/styles.css

@@ -0,0 +1,134 @@
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica,
+    Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+}
+
+.logo {
+  width: 180px;
+}
+
+.title {
+  font-weight: 600;
+  text-align: left;
+  color: black;
+  font-size: 18px;
+}
+
+.alert,
+#component-2,
+#component-3 {
+  padding: 24px;
+  color: black;
+  background-color: #f4f8fb;
+  border: 1px solid #d6dce7;
+  border-radius: 8px;
+  box-shadow: 0px 6px 15px rgb(0 0 0 / 2%), 0px 2px 5px rgb(0 0 0 / 4%);
+}
+
+ol {
+  list-style: disc;
+}
+
+.alert__info {
+  background-color: #f4f8fb;
+  color: #323552;
+}
+
+.alert__warning {
+  background-color: #fffae5;
+  color: #917115;
+  border: 1px solid #e4cf2b;
+}
+
+#pw {
+  -webkit-text-security: disc;
+}
+
+/* unvisited link */
+a:link {
+  color: #6b2bd6;
+}
+
+/* visited link */
+a:visited {
+  color: #6b2bd6;
+}
+
+/* mouse over link */
+a:hover {
+  color: #6b2bd6;
+}
+
+/* selected link */
+a:active {
+  color: #6b2bd6;
+}
+
+li {
+  margin-left: 1em;
+}
+
+.apikey {
+}
+
+.entity-list {
+    color: #6b2bd6;
+    font-size: 16px
+}
+
+.entity-elt {
+    color: black
+}.istopic {
+color: #6b2bd6;
+}
+
+.topic-L0 {
+font-size: 30px;
+text-indent: 0px;
+}
+
+.topic-L1 {
+font-size: 25px;
+text-indent: 18px;
+}
+
+.topic-L2 {
+font-size: 20px;
+text-indent: 36px;
+}
+
+.topic-L3 {
+font-size: 15px;
+text-indent: 54px;
+}
+
+.topic-L4 {
+font-size: 15px;
+text-indent: 72px;
+}
+
+.topic-L5 {
+font-size: 15px;
+text-indent: 90px;
+}
+
+.topic-L6 {
+font-size: 15px;
+text-indent: 108px;
+}
+
+.topic-L7 {
+font-size: 15px;
+text-indent: 126px;
+}
+
+.topic-L8 {
+font-size: 15px;
+text-indent: 144px;
+}
+
+.topic-L9 {
+font-size: 15px;
+text-indent: 162px;
+}
+

example_data/paras.txt

@@ -0,0 +1,7 @@
+You will never believe what happened to me last week. My SUV broke down, so I had to send it to an auto shop to get a new gasket installed. Yesterday I was walking in South Boston to pick the car up and some guy got thrown through the window of a pub right in front of me. A few guys had been drinking and they got into an argument about the Red Sox, which resulted in a fight. When I went to break up the fight, one of the guys accidentally hit me with his elbow in the face, so I fell back and ##### ## #####.
+
+I went to the emergency room and had to get surgery, which sucks because I have to wear a cast for two weeks and it cost me almost $#,###. My wrist still feels like s***, and I've had to take ##### all week. Besides that, things are pretty good. I started my master's degree in Political Science, which I'm excited about. The school has a great program, and I've already met a lot of good professors.
+
+After the program, I'm going to go to law school, so it will help prepare me for that. The other good news is that I get to keep playing basketball while I'm in school. Usually people stop playing after undergrad, but I get to keep playing while I earn my degree, which is great. The program has a ton of good nutrition and physical therapy resources, too. I'm really excited to start playing on my new team.
+
+As for this weekend, I don't have much going on. I have to call the phone company to see if I can get a new phone. The battery on my phone is broken, so I want to get it replaced. What are you doing this weekend?

example_data/topic_dict_example.txt

@@ -0,0 +1,94 @@
+{
+  'Automotive': {
+    'AutoRecalls': {
+      None: None
+    },
+    'AutoSafety': {
+      None: None
+    },
+    'AutoTechnology': {
+      'AutoSafetyTechnologies': {
+        None: None
+      }
+    },
+    'AutoType': {
+      'DriverlessCars': {
+        None: None
+      }
+    }
+  },
+  'BusinessAndFinance': {
+    'Business': {
+      'BusinessAdministration': {
+        None: None
+      }
+    },
+    'Industries': {
+      'TelecommunicationsIndustry': {
+        None: None
+      }
+    }
+  },
+  'Education': {
+    'CollegeEducation': {
+      'PostgraduateEducation': {
+        None: None
+      },
+      'UndergraduateEducation': {
+        None: None
+      }
+    }
+  },
+  'HealthyLiving': {
+    'FitnessAndExercise': {
+      'ParticipantSports': {
+        None: None
+      }
+    }
+  },
+  'MedicalHealth': {
+    'CosmeticMedicalServices': {
+      None: None
+    },
+    'DiseasesAndConditions': {
+      'BoneAndJointConditions': {
+        None: None
+      },
+      'Ear,NoseAndThroatConditions': {
+        None: None
+      },
+      'Injuries': {
+        None: None
+      }
+    },
+    'Surgery': {
+      None: None
+    }
+  },
+  'NewsAndPolitics': {
+    'Politics': {
+      None: None
+    }
+  },
+  'Sports': {
+    'Basketball': {
+      None: None
+    },
+    'Boxing': {
+      None: None
+    },
+    'CollegeSports': {
+      None: None,
+      'CollegeBasketball': {
+        None: None
+      }
+    }
+  },
+  'Technology&Computing': {
+    'ConsumerElectronics': {
+      'Smartphones': {
+        None: None
+      }
+    }
+  }
+}

example_data/topic_list_example.txt

@@ -0,0 +1,20 @@
+['MedicalHealth>DiseasesAndConditions>Injuries',
+ 'Sports>CollegeSports>CollegeBasketball',
+ 'Sports>Basketball',
+ 'Technology&Computing>ConsumerElectronics>Smartphones',
+ 'Automotive>AutoSafety',
+ 'MedicalHealth>DiseasesAndConditions>BoneAndJointConditions',
+ 'Education>CollegeEducation>PostgraduateEducation',
+ 'Automotive>AutoTechnology>AutoSafetyTechnologies',
+ 'Automotive>AutoRecalls',
+ 'Education>CollegeEducation>UndergraduateEducation',
+ 'Sports>CollegeSports',
+ 'Sports>Boxing',
+ 'BusinessAndFinance>Business>BusinessAdministration',
+ 'MedicalHealth>Surgery',
+ 'Automotive>AutoType>DriverlessCars',
+ 'MedicalHealth>DiseasesAndConditions>Ear,NoseAndThroatConditions',
+ 'MedicalHealth>CosmeticMedicalServices',
+ 'NewsAndPolitics>Politics',
+ 'HealthyLiving>FitnessAndExercise>ParticipantSports',
+ 'BusinessAndFinance>Industries>TelecommunicationsIndustry']

requirements.txt

@@ -0,0 +1,5 @@
+gradio==3.2
+numpy==1.23.2
+plotly==5.10.0
+requests==2.28.1
+scipy==1.9.1