Spaces:

reflection777
/

summarizer-for-learning

Sleeping

App Files Files Community

summarizer-for-learning / app.py

reflection777

Update app.py

eee295d verified about 2 months ago

raw history blame contribute delete

No virus

29.8 kB

	# 0- libraries
	import transformers
	import gradio as gr

	from youtube_transcript_api import YouTubeTranscriptApi
	from huggingface_hub import InferenceClient
	from pytube import YouTube
	import pytube
	import torch

	# 1 - abstractive_summary
	# 1.1 - initialize
	import os
	save_dir = os.path.join(os.getcwd(), "docs")
	if not os.path.exists(save_dir):
	os.mkdir(save_dir)
	transcription_model_id = "openai/whisper-large"
	llm_model_id = "tiiuae/falcon-7b-instruct"
	HF_TOKEN = os.environ.get("HF_TOKEN", None)

	# 1.2 - transcription
	def get_yt_transcript(url):
	text = ""
	vid_id = pytube.extract.video_id(url)
	temp = YouTubeTranscriptApi.get_transcript(vid_id)
	for t in temp:
	text += t["text"] + " "
	return text

	# 1.2.1 - locally_transcribe
	def transcribe_yt_vid(url):
	# download YouTube video's audio
	yt = YouTube(str(url))
	audio = yt.streams.filter(only_audio=True).first()
	out_file = audio.download(filename="audio.mp3", output_path=save_dir)

	# defining an automatic-speech-recognition pipeline
	asr = transformers.pipeline(
	"automatic-speech-recognition",
	model=transcription_model_id,
	device_map="auto",
	)

	# setting model config parameters
	asr.model.config.forced_decoder_ids = asr.tokenizer.get_decoder_prompt_ids(
	language="en", task="transcribe"
	)

	# invoking the Whisper model
	temp = asr(out_file, chunk_length_s=20)
	text = temp["text"]

	# we can do this at the end to release GPU memory
	del asr
	torch.cuda.empty_cache()

	return text

	# 1.2.1 - api_transcribe
	def transcribe_yt_vid_api(url, api_token):
	# download YouTube video's audio
	yt = YouTube(str(url))
	audio = yt.streams.filter(only_audio=True).first()
	out_file = audio.download(filename="audio.wav", output_path=save_dir)

	# Initialize client for the Whisper model
	client = InferenceClient(model=transcription_model_id, token=api_token)

	import librosa
	import soundfile as sf

	text = ""
	t = 25 # audio chunk length in seconds
	x, sr = librosa.load(out_file, sr=None)
	# This gives x as audio file in numpy array and sr as original sampling rate
	# The audio needs to be split in 20 second chunks since the API call truncates the response
	for _, i in enumerate(range(0, (len(x) // (t * sr)) + 1)):
	y = x[t * sr * i : t * sr * (i + 1)]
	split_path = os.path.join(save_dir, "audio_split.wav")
	sf.write(split_path, y, sr)
	text += client.automatic_speech_recognition(split_path)

	return text


	# 1.2.3 - transcribe locally or api
	def transcribe_youtube_video(url, force_transcribe=False, use_api=False, api_token=None):

	yt = YouTube(str(url))
	text = ""
	# get the transcript from YouTube if available
	try:
	text = get_yt_transcript(url)
	except:
	pass

	# transcribes the video if YouTube did not provide a transcription
	# or if you want to force_transcribe anyway
	if text == "" or force_transcribe:
	if use_api:
	text = transcribe_yt_vid_api(url, api_token=api_token)
	transcript_source = "The transcript was generated using {} via the Hugging Face Hub API.".format(
	transcription_model_id
	)
	else:
	text = transcribe_yt_vid(url)
	transcript_source = (
	"The transcript was generated using {} hosted locally.".format(
	transcription_model_id
	)
	)
	else:
	transcript_source = "The transcript was downloaded from YouTube."

	return yt.title, text, transcript_source


	# 1.3 - turn to paragraph or points
	def turn_to_paragraph(text):
	# REMOVE HTML TAGS
	from bs4 import BeautifulSoup

	# Parse the HTML text
	soup = BeautifulSoup(text, "html.parser")
	# Get the text without HTML tags
	text = soup.get_text() # print(text_without_tags)

	# Remove leading and trailing whitespaces
	text = text.strip()
	# Check if the string ends with "User" and remove it
	if text.endswith("User"):
	text = text[: -len("User")]
	# Replace dashes and extra whitespaces with spaces
	text = (
	text.replace(" -", "")
	.replace(" ", "")
	.replace("\n", " ")
	.replace("- ", "")
	.replace("`", "")
	)
	# text = text.replace(" ", "\n\n") # to keep second paragraph if it exists # sometime it's good to turn this on. but let's keep it off
	text = text.replace(" ", " ") # off this if ^ is on

	return text


	# 1.3.1
	def turn_to_points(text): # input must be from `turn_to_paragraph()`
	# text = text.replace(". ", ".\n-") # to keep second paragraph if it exists
	text_with_dashes = ".\n".join("- " + line.strip() for line in text.split(". "))
	text_with_dashes = text_with_dashes.replace("\n\n", "\n\n- ") # for first sentence of new paragraph
	return text_with_dashes

	# 1.3.2 - combined funtions above for paragraph_or_points
	def paragraph_or_points(text, pa_or_po):
	if pa_or_po == "Points":
	return turn_to_points(turn_to_paragraph(text))
	else: # default is Paragraph
	return turn_to_paragraph(text)

	# 1.4 - summarization
	def summarize_text(title, text, temperature, words, use_api=False, api_token=None, do_sample=False, length="Short", pa_or_po="Paragraph",):

	from langchain.chains.llm import LLMChain
	from langchain.prompts import PromptTemplate
	from langchain.chains import ReduceDocumentsChain, MapReduceDocumentsChain
	from langchain.chains.combine_documents.stuff import StuffDocumentsChain
	import torch
	import transformers
	from transformers import BitsAndBytesConfig
	from transformers import AutoTokenizer, AutoModelForCausalLM

	from langchain import HuggingFacePipeline
	import torch

	model_kwargs1 = {
	"temperature": temperature,
	"do_sample": do_sample,
	"min_new_tokens": 200 - 25,
	"max_new_tokens": 200 + 25,
	"repetition_penalty": 20.0,
	}
	model_kwargs2 = {
	"temperature": temperature,
	"do_sample": do_sample,
	"min_new_tokens": words,
	"max_new_tokens": words + 100,
	"repetition_penalty": 20.0,
	}
	if not do_sample:
	del model_kwargs1["temperature"]
	del model_kwargs2["temperature"]

	if use_api:

	from langchain import HuggingFaceHub

	# os.environ["HUGGINGFACEHUB_API_TOKEN"] = api_token
	llm = HuggingFaceHub(
	repo_id=llm_model_id,
	model_kwargs=model_kwargs1,
	huggingfacehub_api_token=api_token,
	)
	llm2 = HuggingFaceHub(
	repo_id=llm_model_id,
	model_kwargs=model_kwargs2,
	huggingfacehub_api_token=api_token,
	)
	summary_source = (
	"The summary was generated using {} via Hugging Face API.".format(
	llm_model_id
	)
	)

	else:
	quantization_config = BitsAndBytesConfig(
	load_in_4bit=True,
	bnb_4bit_compute_dtype=torch.float16,
	bnb_4bit_quant_type="nf4",
	bnb_4bit_use_double_quant=True,
	)

	tokenizer = AutoTokenizer.from_pretrained(llm_model_id)
	model = AutoModelForCausalLM.from_pretrained(
	llm_model_id,
	# quantization_config=quantization_config
	)
	model.to_bettertransformer()

	pipeline = transformers.pipeline(
	"text-generation",
	model=model,
	tokenizer=tokenizer,
	torch_dtype=torch.bfloat16,
	device_map="auto",
	pad_token_id=tokenizer.eos_token_id,
	**model_kwargs1,
	)
	pipeline2 = transformers.pipeline(
	"text-generation",
	model=model,
	tokenizer=tokenizer,
	torch_dtype=torch.bfloat16,
	device_map="auto",
	pad_token_id=tokenizer.eos_token_id,
	**model_kwargs2,
	)
	llm = HuggingFacePipeline(pipeline=pipeline)
	llm2 = HuggingFacePipeline(pipeline=pipeline2)

	summary_source = "The summary was generated using {} hosted locally.".format(
	llm_model_id
	)

	# Map
	map_template = """
	Summarize the following video in a clear way:\n
	----------------------- \n
	TITLE: `{title}`\n
	TEXT:\n
	`{docs}`\n
	----------------------- \n
	SUMMARY:\n
	"""
	map_prompt = PromptTemplate(
	template=map_template, input_variables=["title", "docs"]
	)
	map_chain = LLMChain(llm=llm, prompt=map_prompt)

	# Reduce - Collapse
	collapse_template = """
	TITLE: `{title}`\n
	TEXT:\n
	`{doc_summaries}`\n
	----------------------- \n
	Turn the text of a video above into a long essay:\n
	"""

	collapse_prompt = PromptTemplate(
	template=collapse_template, input_variables=["title", "doc_summaries"]
	)
	collapse_chain = LLMChain(llm=llm, prompt=collapse_prompt) # LLM 1 <-- LLM

	# Takes a list of documents, combines them into a single string, and passes this to an LLMChain
	collapse_documents_chain = StuffDocumentsChain(
	llm_chain=collapse_chain, document_variable_name="doc_summaries"
	)

	# Final Reduce - Combine
	combine_template_short = """\n
	TITLE: `{title}`\n
	TEXT:\n
	`{doc_summaries}`\n
	----------------------- \n
	Turn the text of a video above into a 3-sentence summary:\n
	"""
	combine_template_medium = """\n
	TITLE: `{title}`\n
	TEXT:\n
	`{doc_summaries}`\n
	----------------------- \n
	Turn the text of a video above into a long summary:\n
	"""
	combine_template_long = """\n
	TITLE: `{title}`\n
	TEXT:\n
	`{doc_summaries}`\n
	----------------------- \n
	Turn the text of a video above into a long essay:\n
	"""
	# Turn the text of a video above into a 3-sentence summary:\n
	# Turn the text of a video above into a long summary:\n
	# Turn the text of a video above into a long essay:\n
	if length == "Medium":
	combine_prompt = PromptTemplate(
	template=combine_template_medium,
	input_variables=["title", "doc_summaries", "words"],
	)
	elif length == "Long":
	combine_prompt = PromptTemplate(
	template=combine_template_long,
	input_variables=["title", "doc_summaries", "words"],
	)
	else: # default is short
	combine_prompt = PromptTemplate(
	template=combine_template_short,
	input_variables=["title", "doc_summaries", "words"],
	)
	combine_chain = LLMChain(llm=llm2, prompt=combine_prompt) # LLM 2 <-- LLM2

	# Takes a list of documents, combines them into a single string, and passes this to an LLMChain
	combine_documents_chain = StuffDocumentsChain(
	llm_chain=combine_chain, document_variable_name="doc_summaries"
	)

	# Combines and iteratively reduces the mapped documents
	reduce_documents_chain = ReduceDocumentsChain(
	# This is final chain that is called.
	combine_documents_chain=combine_documents_chain,
	# If documents exceed context for `StuffDocumentsChain`
	collapse_documents_chain=collapse_documents_chain,
	# The maximum number of tokens to group documents into.
	token_max=800,
	)

	# Combining documents by mapping a chain over them, then combining results
	map_reduce_chain = MapReduceDocumentsChain(
	# Map chain
	llm_chain=map_chain,
	# Reduce chain
	reduce_documents_chain=reduce_documents_chain,
	# The variable name in the llm_chain to put the documents in
	document_variable_name="docs",
	# Return the results of the map steps in the output
	return_intermediate_steps=False,
	)

	from langchain.document_loaders import TextLoader
	from langchain.text_splitter import TokenTextSplitter

	with open(save_dir + "/transcript.txt", "w") as f:
	f.write(text)
	loader = TextLoader(save_dir + "/transcript.txt")
	doc = loader.load()
	text_splitter = TokenTextSplitter(chunk_size=800, chunk_overlap=100)
	docs = text_splitter.split_documents(doc)

	summary = map_reduce_chain.run(
	{"input_documents": docs, "title": title, "words": words}
	)

	try:
	del (map_reduce_chain, reduce_documents_chain,
	combine_chain, collapse_documents_chain,
	map_chain, collapse_chain,
	llm, llm2,
	pipeline, pipeline2,
	model, tokenizer)
	except:
	pass
	torch.cuda.empty_cache()

	summary = paragraph_or_points(summary, pa_or_po)

	return summary, summary_source


	# 1.5 - complete function [DELETED]

	# 2 - extractive/low-abstractive summary for Key Sentence Highlight
	# 2.1 - chunking + hosted inference, summary [DELETED]

	# 2.2 - add spaces between punctuations
	import re
	def add_space_before_punctuation(text):
	# Define a regular expression pattern to match punctuation
	punctuation_pattern = r"([.,!?;:])"

	# Use re.sub to add a space before each punctuation
	modified_text = re.sub(punctuation_pattern, r" \1", text)

	bracket_pattern = r'([()])'
	modified_text = re.sub(bracket_pattern, r" \1 ", modified_text)

	return modified_text


	# 2.3 - highlight same words (yellow)
	from difflib import ndiff
	def highlight_text_with_diff(text1, text2):
	diff = list(ndiff(text1.split(), text2.split()))

	highlighted_diff = []
	for item in diff:
	if item.startswith(" "):
	highlighted_diff.append(
	'<span style="background-color: rgba(255, 255, 0, 0.25);">'
	+ item
	+ " </span>"
	) # Unchanged words
	elif item.startswith("+"):
	highlighted_diff.append(item[2:] + " ")

	return "".join(highlighted_diff) # output in string HTML format

	# 2.4 - combined - `highlight_key_sentences`
	# extractive/low-abstractive summarizer with facebook/bart-large-cnn
	# highlight feature
	def highlight_key_sentences(original_text, api_key):

	import requests

	API_TOKEN = api_key
	headers = {"Authorization": f"Bearer {API_TOKEN}"}
	API_URL = "https://api-inference.huggingface.co/models/facebook/bart-large-cnn"

	def query(payload):
	response = requests.post(API_URL, headers=headers, json=payload)
	return response.json()

	def chunk_text(text, chunk_size=1024):
	# Split the text into chunks
	chunks = [text[i : i + chunk_size] for i in range(0, len(text), chunk_size)]
	return chunks

	def summarize_long_text(long_text):
	# Split the long text into chunks
	text_chunks = chunk_text(long_text)

	# Summarize each chunk
	summaries = []
	for chunk in text_chunks:
	data = query(
	{
	"inputs": f"{chunk}",
	"parameters": {"do_sample": False},
	}
	) # what if do_sample=True?
	summaries.append(data[0]["summary_text"])

	# Combine the summaries of all chunks
	full_summary = " ".join(summaries)
	return full_summary

	summarized_text = summarize_long_text(original_text)

	original_text = add_space_before_punctuation(original_text)
	summarized_text = add_space_before_punctuation(summarized_text)

	return highlight_text_with_diff(summarized_text, original_text) # output in string HTML format


	# 3 - extract_keywords
	# 3.1 - initialize & load pipeline
	from transformers import (
	TokenClassificationPipeline,
	AutoModelForTokenClassification,
	AutoTokenizer,
	)
	from transformers.pipelines import AggregationStrategy
	import numpy as np

	# Define keyphrase extraction pipeline
	class KeyphraseExtractionPipeline(TokenClassificationPipeline):
	def __init__(self, model, args, *kwargs):
	super().__init__(
	model=AutoModelForTokenClassification.from_pretrained(model),
	tokenizer=AutoTokenizer.from_pretrained(model),
	*args,
	**kwargs,
	)

	def postprocess(self, all_outputs):
	results = super().postprocess(
	all_outputs=all_outputs,
	aggregation_strategy=AggregationStrategy.SIMPLE,
	)
	return np.unique([result.get("word").strip() for result in results])


	# Load pipeline
	model_name = "ml6team/keyphrase-extraction-kbir-inspec"
	extractor = KeyphraseExtractionPipeline(model=model_name)

	# 3.2 - re-arrange keywords order
	import re
	def rearrange_keywords(text, keywords): # text:str, keywords:List
	# Find the positions of each keyword in the text
	keyword_positions = {word: text.lower().index(word.lower()) for word in keywords}

	# Sort the keywords based on their positions in the text
	sorted_keywords = sorted(keywords, key=lambda x: keyword_positions[x])

	return sorted_keywords

	# 3.3 - `keywords_extractor` function
	def keywords_extractor_list(summary): # List : Flashcards
	keyphrases = extractor(summary) # extractor() from above \| text.replace("\n", " ")
	list_keyphrases = keyphrases.tolist()

	# rearrange first
	list_keyphrases = rearrange_keywords(summary, list_keyphrases)

	return list_keyphrases # returns List

	def keywords_extractor_str(summary): # str : Keywords Highlight & Fill in the Blank
	keyphrases = extractor(summary) # extractor() from above \| text.replace("\n", " ")
	list_keyphrases = keyphrases.tolist()

	# rearrange first
	list_keyphrases = rearrange_keywords(summary, list_keyphrases)

	# join List elements to one string
	all_keyphrases = " ".join(list_keyphrases)

	return all_keyphrases # returns one string

	# 3.4 - keywords highlight
	# 3.4.1 - highlight same words (green)
	def highlight_green(text1, text2): # keywords(str), text
	diff = list(ndiff(text1.split(), text2.split()))

	highlighted_diff = []
	for item in diff:
	if item.startswith(" "):
	highlighted_diff.append(
	'<span style="background-color: rgba(0, 255, 0, 0.25);">'
	+ item
	+ " </span>"
	) # Unchanged words
	elif item.startswith("+"):
	highlighted_diff.append(item[2:] + " ")

	return "".join(highlighted_diff) # output in string HTML format


	# 3.4.2 - combined - keywords highlight
	def keywords_highlight(text):
	keywords = keywords_extractor_str(text) # keywords; one string
	text = add_space_before_punctuation(text)
	return highlight_green(keywords, text) # output in string HTML format


	# 3.5 - flashcards
	# 3.5.1 - pair_keywords_sentences
	def pair_keywords_sentences(text, search_words): # text:str, search_words:List

	result_html = "<span style='text-align: center;'>"

	# Split the text into sentences
	sentences = re.split(r"(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.\|\?)\s", text)

	# Create a dictionary to store sentences for each keyword
	keyword_sentences = {word: [] for word in search_words}

	# Iterate through sentences and search for keywords
	for sentence in sentences:
	for word in search_words:
	if re.search(
	r"\b{}\b".format(re.escape(word)), sentence, flags=re.IGNORECASE
	):
	keyword_sentences[word].append(sentence)

	# Print the results
	for word, sentences in keyword_sentences.items():
	result_html += "<h2>" + word + "</h2> \n"

	for sentence in sentences:
	result_html += "<p>" + sentence + "</p> \n"

	result_html += "\n"

	result_html += "</span>"

	return result_html

	# 3.5.2 combined - flashcards
	def flashcards(text):
	keywords = keywords_extractor_list(text) # keywords; a List
	text = add_space_before_punctuation(text)
	return pair_keywords_sentences(text, keywords) # output in string HTML format


	# 3.6 - fill in the blank
	# 3.6.1 - underline same words
	def underline_keywords(text1, text2): # keywords(str), text
	diff = list(ndiff(text1.split(), text2.split()))

	highlighted_diff = []
	for item in diff:
	if item.startswith(" "):
	highlighted_diff.append(
	"_______"
	) # Unchanged words. make length independent of word length?
	elif item.startswith("+"):
	highlighted_diff.append(item[2:] + " ")

	return "".join(highlighted_diff) # output in string HTML format


	# 3.6.2 - combined - underline
	def fill_in_blanks(text):
	keywords = keywords_extractor_str(text) # keywords; one string
	text = add_space_before_punctuation(text)
	return underline_keywords(keywords, text) # output in string HTML format


	# 4 - misc
	emptyTabHTML = "<br>\n<p style='color: gray; text-align: center'>Please generate a summary first.</p>\n<br>\n<br>\n<br>\n<br>\n<br>\n<br>\n<br>\n<br>\n<br>\n<br>\n<br>\n<br>\n<br>\n"


	def empty_tab():
	return emptyTabHTML


	# 5 - the app
	import gradio as gr

	with gr.Blocks() as demo:
	gr.Markdown("<br>")

	with gr.Row():
	with gr.Column():
	gr.Markdown("# ✍️ Summarizer for Learning")
	with gr.Column():
	gr.HTML("<div style='color: red; text-align: right'>Please use your <a href='#HFAPI' style='color: red'>Hugging Face Access Token.</a></div>")

	with gr.Row():
	with gr.Column():
	with gr.Tab("YouTube"):
	yt_link = gr.Textbox(show_label=False, placeholder="Insert YouTube link here ... (video needs to have caption)")
	yt_transcript = gr.Textbox(show_label=False, placeholder="Transcript will be shown here ...", lines=12)
	with gr.Tab("Article"):
	gr.Textbox(show_label=False, placeholder="WORK IN PROGRESS", interactive=False)
	gr.Textbox(show_label=False, placeholder="", lines=12, interactive=False)
	with gr.Tab("Text"):
	gr.Dropdown(["WORK IN PROGRESS", "Example 2"], show_label=False, value="WORK IN PROGRESS", interactive=False)
	gr.Textbox(show_label=False, placeholder="", lines=12, interactive=False)
	with gr.Row():
	clrButton = gr.ClearButton([yt_link, yt_transcript])
	subButton = gr.Button(variant="primary", value="Summarize")

	with gr.Accordion("Settings", open=False):
	length = gr.Radio(["Short", "Medium", "Long"], label="Length", value="Short", interactive=True)
	pa_or_po = gr.Radio(["Paragraphs", "Points"], label="Summarize to", value="Paragraphs", interactive=True)
	gr.Checkbox(label="Add headings", interactive=False)
	gr.Radio(["One section", "Few sections"], label="Summarize into", interactive=False) # info="Only for 'Medium' or 'Long'"
	with gr.Row():
	clrButtonSt1 = gr.ClearButton([length, pa_or_po], interactive=True)
	subButtonSt1 = gr.Button(value="Set Current as Default", interactive=False)
	subButtonSt1 = gr.Button(value="Show Default", interactive=False)

	with gr.Accordion("Advanced Settings", open=False):
	with gr.Group(visible=False):
	gr.HTML("<p style='text-align: center;'>  YouTube transcription</p>")
	force_transcribe_with_app = gr.Checkbox(
	label="Always transcribe with app",
	info="The app first checks if caption on YouTube is available. If ticked, the app will transcribe the video for you but slower.",
	)
	with gr.Group():
	gr.HTML("<p style='text-align: center;'>  Summarization</p>")
	gr.Radio(["High Abstractive", "Low Abstractive", "Extractive"], label="Type of summarization", value="High Abstractive", interactive=False)
	gr.Dropdown(
	[
	"tiiuae/falcon-7b-instruct",
	"GPT2 (work in progress)",
	"OpenChat 3.5 (work in progress)",
	],
	label="Model",
	value="tiiuae/falcon-7b-instruct",
	interactive=False,
	)
	temperature = gr.Slider(0.10, 0.30, step=0.05, label="Temperature", value=0.15,
	info="Temperature is limited to 0.1 ~ 0.3 window, as it is shown to produce best result.",
	interactive=True,
	)
	do_sample = gr.Checkbox(label="do_sample", value=True,
	info="If ticked, do_sample produces more creative and diverse text, otherwise the app will use greedy decoding that generate more consistent and predictable summary.",
	)

	with gr.Group():
	gr.HTML("<p style='text-align: center;'>  Highlight</p>")
	check_key_sen = gr.Checkbox(label="Highlight key sentences", info="In original text", value=True, interactive=False)
	gr.Checkbox(label="Highlight keywords", info="In summary", value=True, interactive=False)
	gr.Checkbox(label="Turn text to paragraphs", interactive=False)

	with gr.Group():
	gr.HTML("<p style='text-align: center;'>  Quiz mode</p>")
	gr.Checkbox(label="Fill in the blanks", value=True, interactive=False)
	gr.Checkbox(label="Flashcards", value=True, interactive=False)
	gr.Checkbox(label="Re-write summary", interactive=False) # info="Only for 'Short'"

	with gr.Row():
	clrButtonSt2 = gr.ClearButton(interactive=True)
	subButtonSt2 = gr.Button(value="Set Current as Default", interactive=False)
	subButtonSt2 = gr.Button(value="Show Default", interactive=False)

	with gr.Column():
	with gr.Tab("Summary"): # Output
	title = gr.Textbox(show_label=False, placeholder="Title")
	summary = gr.Textbox(lines=11, show_copy_button=True, label="", placeholder="Summarized output ...")
	with gr.Tab("Key sentences", render=True):
	key_sentences = gr.HTML(emptyTabHTML)
	showButtonKeySen = gr.Button(value="Generate")
	with gr.Tab("Keywords", render=True):
	keywords = gr.HTML(emptyTabHTML)
	showButtonKeyWor = gr.Button(value="Generate")
	with gr.Tab("Fill in the blank", render=True):
	blanks = gr.HTML(emptyTabHTML)
	showButtonFilBla = gr.Button(value="Generate")
	with gr.Tab("Flashcards", render=True):
	flashCrd = gr.HTML(emptyTabHTML)
	showButtonFlash = gr.Button(value="Generate")
	gr.Markdown("<span style='color: gray'>The app is a work in progress. Output may be odd and some features are disabled. [Learn more](https://huggingface.co/spaces/reflection777/summarizer-for-learning/blob/main/README.md).</span>")
	with gr.Group():
	gr.HTML("<p id='HFAPI' style='text-align: center;'>  🤗 Hugging Face Access Token [<a href='https://huggingface.co/settings/tokens'>more</a>]</p>")
	hf_access_token = gr.Textbox(
	show_label=False,
	placeholder="example: hf_******************************",
	type="password",
	info="The app does not store the token.",
	)
	with gr.Accordion("Info", open=False, visible=False):
	transcript_source = gr.Textbox(show_label=False, placeholder="transcript_source")
	summary_source = gr.Textbox(show_label=False, placeholder="summary_source")
	words = gr.Slider(minimum=100, maximum=500, value=250, label="Length of the summary")
	# words: what should be the constant value?
	use_api = gr.Checkbox(label="use_api", value=True)

	subButton.click(
	fn=transcribe_youtube_video,
	inputs=[yt_link, force_transcribe_with_app, use_api, hf_access_token],
	outputs=[title, yt_transcript, transcript_source],
	queue=True,
	).then(
	fn=summarize_text,
	inputs=[title, yt_transcript, temperature, words, use_api, hf_access_token, do_sample, length, pa_or_po],
	outputs=[summary, summary_source],
	api_name="summarize_text",
	queue=True,
	)

	subButton.click(fn=empty_tab, outputs=[key_sentences])
	subButton.click(fn=empty_tab, outputs=[keywords])
	subButton.click(fn=empty_tab, outputs=[flashCrd])
	subButton.click(fn=empty_tab, outputs=[blanks])

	showButtonKeySen.click(
	fn=highlight_key_sentences,
	inputs=[yt_transcript, hf_access_token],
	outputs=[key_sentences],
	queue=True,
	)

	# Keywords
	showButtonKeyWor.click(fn=keywords_highlight, inputs=[summary], outputs=[keywords], queue=True)

	# Flashcards
	showButtonFlash.click(fn=flashcards, inputs=[summary], outputs=[flashCrd], queue=True)

	# Fill in the blanks
	showButtonFilBla.click(fn=fill_in_blanks, inputs=[summary], outputs=[blanks], queue=True)

	gr.Examples(
	examples=["https://www.youtube.com/watch?v=P6FORpg0KVo", "https://www.youtube.com/watch?v=bwEIqjU2qgk"],
	inputs=[yt_link]
	)

	if __name__ == "__main__":
	demo.launch(show_api=False)
	# demo.launch(show_api=False, debug=True)
	# demo.launch(show_api=False, share=True)