new app file

src/streamlit_app.py

@@ -1,40 +1,137 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+# app.py
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = "-1" 
+os.environ['HUGGINGFACE_HUB_CACHE'] = '/data/.cache/huggingface'
+# 2. For Streamlit's own cache/config directory
+# This tells Streamlit to put its internal cache and config files here.
+os.environ['STREAMLIT_SERVER_BROWSER_CACHE_PATH'] = '/tmp/.streamlit_cache' 
+# You might also consider setting these if the above is not enough:
+# os.environ['STREAMLIT_SERVER_LIB_CACHE_PATH'] = '/tmp/.streamlit_lib_cache'
+# os.environ['STREAMLIT_SERVER_STATIC_CACHE_PATH'] = '/tmp/.streamlit_static_cache'
+
+# 3. For Matplotlib configuration/cache
+# This tells Matplotlib to put its config and cache in a writable /tmp subfolder.
+os.environ['MPLCONFIGDIR'] = '/data/.config/matplotlib'
+
+# 4. Optional: To silence the TensorFlow oneDNN warnings if you don't need them
+# This doesn't fix a core error, but cleans up logs.
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+
 import streamlit as st
+from googleapiclient.discovery import build
+from transformers import pipeline
+import pandas as pd
+
+st.set_page_config(page_title="YouTube Comment Sentiment Analyzer", layout="wide")
+
+# --- Configuration ---
+# Get API Key from Hugging Face Space Secrets
+YOUTUBE_API_KEY = os.environ.get("YOUTUBE_API_KEY")
+
+if not YOUTUBE_API_KEY:
+    st.error("YouTube API Key not found. Please set it as a secret in your Hugging Face Space settings.")
+    st.stop()
+
+# Initialize YouTube Data API client
+youtube = build('youtube', 'v3', developerKey=YOUTUBE_API_KEY)
+
+# Initialize sentiment analysis pipeline
+# You can choose other models, e.g., "cardiffnlp/twitter-roberta-base-sentiment-latest"
+@st.cache_resource
+def load_sentiment_model():
+    return pipeline("sentiment-analysis", model="sshleifer/tiny-distilbert-base-uncased-finetuned-sst-2-english")
+    truncation=True
+
+sentiment_analyzer = load_sentiment_model()
+
+def get_video_id(youtube_url):
+    """Extracts video ID from a YouTube URL."""
+    # ... your implementation ...
+    if "youtube.com/watch?v=" in youtube_url:
+        return youtube_url.split("v=")[1].split("&")[0]
+    elif "youtu.be/" in youtube_url:
+        return youtube_url.split("youtu.be/")[1].split("?")[0]
+    return None
+
+
+def get_comments(video_id, max_results=100):
+    """Fetches comments for a given video ID."""
+    comments = []
+    # ... your implementation ...
+    try:
+        request = youtube.commentThreads().list(
+            part="snippet",
+            videoId=video_id,
+            textFormat="plainText",
+            maxResults=min(100, max_results)
+        )
+        response = request.execute()
+        for item in response['items']:
+            comment = item['snippet']['topLevelComment']['snippet']['textDisplay']
+            comments.append(comment)
+        # Add pagination logic if needed for > 100 comments
+    except Exception as e:
+        st.error(f"Error fetching comments: {e}")
+        return []
+    return comments
+
+# --- Streamlit UI (Uncomment/Reintroduce these) ---
+
+st.title("📹 YouTube Comment Sentiment Analyzer")
+st.markdown("Enter a YouTube video link to analyze the sentiment of its comments.")
+
+youtube_link = st.text_input("YouTube Video Link:", placeholder="e.g., https://www.youtube.com/watch?v=dQw4w9WgXcQ")
+
+if st.button("Analyze Comments"):
+    if not youtube_link:
+        st.warning("Please enter a YouTube video link.")
+    else:
+        video_id = get_video_id(youtube_link)
+        if not video_id:
+            st.error("Invalid YouTube link. Please ensure it's a valid video URL.")
+        else:
+            with st.spinner("Fetching comments and analyzing sentiment..."):
+                try:
+                    # Fetch up to 200 comments, adjust as needed
+                    comments = get_comments(video_id, max_results=200) 
+                    if not comments:
+                        st.info("No comments found for this video, or comments are disabled.")
+                    else:
+                        st.subheader(f"Analyzing {len(comments)} comments:")
+                        sentiments = []
+                        for i, comment in enumerate(comments):
+                            result = sentiment_analyzer(comment)[0]
+                            label = result['label']
+                            score = result['score']
+                            sentiments.append({"Comment": comment, "Sentiment": label, "Score": f"{score:.2f}"})
+
+                        df = pd.DataFrame(sentiments)
+                        st.dataframe(df, height=300)
+
+                        st.write("Unique Sentiment Labels found:")
+                        st.write(df['Sentiment'].unique())
+                        st.write("First 5 rows of sentiments DataFrame:")
+                        st.dataframe(df.head())
+
+                        pos_count = df[df['Sentiment'] == 'LABEL_1'].shape[0] 
+                        neg_count = df[df['Sentiment'] == 'LABEL_0'].shape[0] 
+
+                        total_analyzed = len(comments)
+                        if total_analyzed > 0:
+                            st.subheader("Overall Sentiment Breakdown:")
+                            col1, col2, col3 = st.columns(3)
+                            with col1:
+                                st.metric("Positive Comments", f"{pos_count} ({pos_count/total_analyzed:.1%})")
+                            with col2:
+                                st.metric("Negative Comments", f"{neg_count} ({neg_count/total_analyzed:.1%})")
+                            with col3:
+                                st.metric("Total Comments Analyzed", total_analyzed)
+
+                        st.success("Analysis complete!")
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+                except Exception as e:
+                    st.error(f"An error occurred during analysis: {e}. Please check the video link or your API key.")
+                    if "disabled comments" in str(e).lower():
+                         st.info("Comments might be disabled for this video.")
+                    elif "quota" in str(e).lower():
+                         st.info("You might have hit your YouTube Data API daily quota.")