app.py

import streamlit as st
from transformers import T5ForConditionalGeneration, T5Tokenizer, pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
import nltk
from youtube_transcript_api import YouTubeTranscriptApi
import torch
from textblob import TextBlob
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize

# Download NLTK data
nltk.download('punkt')
nltk.download('averaged_perceptron_tagger')
nltk.download('stopwords')

# Load models and tokenizers
summary_model_name = 'utrobinmv/t5_summary_en_ru_zh_base_2048'
summary_model = T5ForConditionalGeneration.from_pretrained(summary_model_name)
summary_tokenizer = T5Tokenizer.from_pretrained(summary_model_name)

tag_tokenizer = AutoTokenizer.from_pretrained("fabiochiu/t5-base-tag-generation")
tag_model = AutoModelForSeq2SeqLM.from_pretrained("fabiochiu/t5-base-tag-generation")

captioner = pipeline("image-to-text", model="Salesforce/blip-image-captioning-base")

# Function to summarize text
def summarize_text(text, prefix):
    src_text = prefix + text
    input_ids = summary_tokenizer(src_text, return_tensors="pt")
    generated_tokens = summary_model.generate(**input_ids)
    result = summary_tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
    return result[0]

# Function to generate tags
def generate_tags(text):
    with torch.no_grad():
        inputs = tag_tokenizer(text, max_length=256, truncation=True, return_tensors="pt")
        output = tag_model.generate(**inputs, num_beams=8, do_sample=True, min_length=10, max_length=64, num_return_sequences=1)
        decoded_output = tag_tokenizer.batch_decode(output, skip_special_tokens=True)[0]
        tags = list(set(decoded_output.strip().split(", ")))
    return tags

# Function to fetch YouTube transcript
def fetch_transcript(url):
    video_id = url.split('watch?v=')[-1]
    try:
        transcript = YouTubeTranscriptApi.get_transcript(video_id)
        transcript_text = ' '.join([entry['text'] for entry in transcript])
        return transcript_text
    except Exception as e:
        return str(e)

# Function to extract keywords and generate hashtags
def extract_keywords(content):
    text = content.lower()
    sentences = nltk.sent_tokenize(text)
    keywords = []
    for sentence in sentences:
        words = nltk.word_tokenize(sentence)
        tags = nltk.pos_tag(words)
        for word, tag in tags:
            if tag.startswith('NN'):
                keywords.append(word)
    return keywords

def generate_hashtags(content, max_hashtags=10):
    keywords = extract_keywords(content)
    hashtags = []
    for keyword in keywords:
        hashtag = "#" + keyword
        if len(hashtag) <= 20:
            hashtags.append(hashtag)
    return hashtags[:max_hashtags]

# Function to extract point of view
def extract_point_of_view(text):
    stop_words = set(stopwords.words('english'))
    words = word_tokenize(str(text))
    filtered_words = [word for word in words if word.casefold() not in stop_words]
    text = ' '.join(filtered_words)

    blob = TextBlob(text)
    polarity = blob.sentiment.polarity
    subjectivity = blob.sentiment.subjectivity

    if polarity > 0.5:
        point_of_view = "Positive"
    elif polarity < -0.5:
        point_of_view = "Negative"
    else:
        point_of_view = "Neutral"

    return point_of_view

# Streamlit app title
st.title("Multi-purpose AI App: WAVE_AI")

# Create tabs for different functionalities
tab1, tab2, tab3, tab4, tab5 = st.tabs(["Text Summarization", "Text Tag Generation", "Image Captioning", "YouTube Transcript", "LinkedIn Post Analysis"])

# Text Summarization Tab
with tab1:
    st.header("Summarize Title Maker")

    input_text = st.text_area("Enter the text to summarize:", height=300)

    if st.button("Generate the Title"):
        if input_text:
            title1 = summarize_text(input_text, 'summary: ')
            title2 = summarize_text(input_text, 'summary brief: ')
            st.write("### Title 1")
            st.write(title1)
            st.write("### Title 2")
            st.write(title2)
        else:
            st.warning("Please enter some text to summarize.")

# Text Tag Generation Tab
with tab2:
    st.header("Tag Generation from Text")
    
    text = st.text_area("Enter the text for tag extraction:", height=200)
    
    if st.button("Generate Tags"):
        if text:
            try:
                tags = generate_tags(text)
                st.write("**Generated Tags:**")
                st.write(tags)
            except Exception as e:
                st.error(f"An error occurred: {e}")
        else:
            st.warning("Please enter some text to generate tags.")

# Image Captioning Tab
with tab3:
    st.header("Image Captioning Extractor")
    
    image_url = st.text_input("Enter the URL of the image:")
    
    if st.button("Analysis Image"):
        if image_url:
            try:
                st.image(image_url, caption="Provided Image", use_column_width=True)
                caption = captioner(image_url)
                st.write("**Generated Caption:**")
                st.write(caption[0]['generated_text'])
            except Exception as e:
                st.error(f"An error occurred: {e}")
        else:
            st.warning("Please give a image url.")

# YouTube Transcript Tab
with tab4:
    st.header("YouTube Video Transcript Extractor")
    
    youtube_url = st.text_input("Enter YouTube URL:")
    
    if st.button("Get Transcript"):
        if youtube_url:
            transcript = fetch_transcript(youtube_url)
            if "error" not in transcript.lower():
                st.success("Transcript successfully fetched!")
                st.text_area("Transcript", transcript, height=300)
            else:
                st.error(f"An error occurred: {transcript}")
        else:
            st.warning("Please enter a URL.")

# LinkedIn Post Analysis Tab
with tab5:
    st.header("LinkedIn Post Analysis AI")

    text = st.text_area("Enter the LinkedIn Post:")

    if st.button("Analyze:"):
        if text:
            # Generate tags
            tags = generate_tags(text)
            st.subheader("The Most Tracked KeyWords:")
            st.write(tags)

            # Generate summaries
            summary1 = summarize_text(text, 'summary: ')
            summary2 = summarize_text(text, 'summary brief: ')
            st.subheader("Summary Title 1:")
            st.write(summary1)
            st.subheader("Summary Title 2:")
            st.write(summary2)

            # Generate hashtags
            hashtags = generate_hashtags(text)
            st.subheader("Generated Hashtags for the Post")
            st.write(hashtags)

            # Extract point of view
            point_of_view = extract_point_of_view(text)
            st.subheader("Tone of the Post:")
            st.write(point_of_view)
        else:
            st.warning("Please enter text to analyze.")