Upload 11 files

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+chatgskd.png filter=lfs diff=lfs merge=lfs -text
+generate.png filter=lfs diff=lfs merge=lfs -text
+google.png filter=lfs diff=lfs merge=lfs -text
+news.png filter=lfs diff=lfs merge=lfs -text
+wikipedia.png filter=lfs diff=lfs merge=lfs -text
+youtube.png filter=lfs diff=lfs merge=lfs -text

chatgskd.py

@@ -0,0 +1,61 @@
+import streamlit as st
+import requests
+import os
+
+# Load API Key from Hugging Face Secrets
+HF_API_KEY = os.getenv("KEY")
+
+# API URL
+HF_MISTRAL_URL = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.3"
+
+# Function to call Hugging Face API
+def chat_with_mistral_hf(prompt):
+    if not HF_API_KEY:
+        return "Error: API key not found. Please set it in Hugging Face Secrets."
+    
+    headers = {"Authorization": f"Bearer {HF_API_KEY}"}
+    payload = {"inputs": prompt, "parameters": {"max_length": 200, "temperature": 0.7}}
+    
+    response = requests.post(HF_MISTRAL_URL, json=payload, headers=headers)
+    
+    if response.status_code == 200:
+        return response.json()[0]["generated_text"]
+    else:
+        return f"Error: {response.json()}"
+
+# Streamlit UI
+st.set_page_config(page_title="ChatGSKD", layout="wide")
+
+# Sidebar: Chat title rename option
+st.sidebar.header("Chat Settings")
+chat_title = st.sidebar.text_input("Rename Chat:", "Temporary Chat")
+
+# Initialize chat history if not present
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+
+# Display Chat Title
+st.title(chat_title)
+
+# Show chat history
+for chat in st.session_state.chat_history:
+    with st.chat_message(chat["role"]):
+        st.write(chat["content"])
+
+# Input box at the bottom
+user_input = st.text_area("Ask AI:", height=100, key="query", label_visibility="collapsed")
+
+# Generate response when user submits a prompt
+if st.button("Generate Response"):
+    if user_input.strip():
+        with st.spinner("Generating response..."):
+            response = chat_with_mistral_hf(user_input)
+            
+            # Store user query & response in chat history
+            st.session_state.chat_history.append({"role": "user", "content": user_input})
+            st.session_state.chat_history.append({"role": "assistant", "content": response})
+
+            # Refresh the page to show new messages
+            st.rerun()
+    else:
+        st.warning("Please enter a prompt before clicking Generate Response.")

google.py

@@ -0,0 +1,136 @@
+import streamlit as st
+import requests
+import json
+import os
+import speech_recognition as sr
+import pandas as pd
+import altair as alt
+from PIL import Image
+from io import BytesIO
+
+# Function to perform Google Search
+def google_search(api_key, cse_id, query, num_results=10):
+    url = "https://www.googleapis.com/customsearch/v1"
+    params = {'key': api_key, 'cx': cse_id, 'q': query, 'num': num_results}
+    response = requests.get(url, params=params)
+    return response.json()
+
+# Initialize search history and data storage for analytics
+if 'search_history' not in st.session_state:
+    st.session_state.search_history = []
+if 'search_data' not in st.session_state:
+    st.session_state.search_data = pd.DataFrame(columns=["Query", "Source", "Timestamp"])
+
+def main():
+    st.title("Enhanced Google Search Application")
+
+    # User inputs for API key, CSE ID, and search query
+    api_key = "AIzaSyBvnTpjwspsYBMlHN4nMEvybEmZL8mwAQ4"
+    cse_id = "464947c4e602c4ee8"
+    query = st.text_input("Enter your search query", "", key='query_input')
+
+    # Voice search feature
+    if st.button("Use Voice Search"):
+        recognizer = sr.Recognizer()
+        with sr.Microphone() as source:
+            st.write("Listening...")
+            audio = recognizer.listen(source)
+            try:
+                query = recognizer.recognize_google(audio)
+                st.write(f"You said: {query}")
+                if api_key and cse_id and query:
+                    results = google_search(api_key, cse_id, query)
+                    update_search_history(query, "Voice")
+                    display_results(results)
+            except sr.UnknownValueError:
+                st.error("Could not understand audio.")
+            except sr.RequestError:
+                st.error("Could not request results from Google.")
+
+    # Trigger search on Enter or when search button is clicked
+    if st.button("Search") or st.session_state.get('query_input'):
+        if api_key and cse_id and query:
+            results = google_search(api_key, cse_id, query)
+            update_search_history(query, "Text")
+            display_results(results)
+        else:
+            st.error("Please enter API Key, CSE ID, and a search query.")
+    
+    # Button to show search history
+    if st.button("Show Search History"):
+        if st.session_state.search_history:
+            st.write("Search History:")
+            for h in st.session_state.search_history:
+                st.write(h)
+        else:
+            st.write("No search history found.")
+
+    # Button to clear search history
+    if st.button("Clear Search History"):
+        st.session_state.search_history.clear()
+        st.session_state.search_data = pd.DataFrame(columns=["Query", "Source", "Timestamp"])
+        st.success("Search history cleared.")
+
+    # Interactive Analytics Dashboard
+    st.subheader("Search Analytics")
+    if not st.session_state.search_data.empty:
+        # Chart of search counts over time
+        search_trends = alt.Chart(st.session_state.search_data).mark_line().encode(
+            x='Timestamp:T',
+            y='count():Q',
+            color='Source:N',
+            tooltip=['Query:N', 'count():Q', 'Source:N']
+        ).properties(width=600, height=300)
+        st.altair_chart(search_trends, use_container_width=True)
+
+        # Most popular queries
+        st.write("**Top Search Queries**")
+        top_queries = (
+            st.session_state.search_data['Query']
+            .value_counts()
+            .head(5)
+            .reset_index()
+            .rename(columns={'index': 'Query', 'Query': 'Count'})
+        )
+        st.write(top_queries)
+
+def display_results(results):
+    if results and 'items' in results:
+        st.session_state.results = results
+        for i, item in enumerate(results['items']):
+            st.write(f"**{i + 1}. {item['title']}**")
+            st.write(f"[Link]({item['link']})")
+            st.write(f"{item['snippet']}\n")
+            
+            # Check if 'pagemap' and 'cse_image' exist and if 'src' is in 'cse_image'
+            if 'pagemap' in item and 'cse_image' in item['pagemap']:
+                image_data = item['pagemap']['cse_image'][0]
+                image_url = image_data.get('src')  # Use .get() to avoid KeyError
+                
+                # Try to load and display the image if 'src' exists
+                if image_url:
+                    try:
+                        response = requests.get(image_url)
+                        img = Image.open(BytesIO(response.content))
+                        st.image(img, width=100)
+                    except Exception as e:
+                        st.write("**Image could not be loaded.**")
+                else:
+                    st.write("**Image source not available.**")
+            else:
+                st.write("No image available for this result.")
+    else:
+        st.write("No results found.")
+
+def update_search_history(query, source):
+    # Update search history and analytics data
+    st.session_state.search_history.append(query)
+    new_data = pd.DataFrame({
+        "Query": [query],
+        "Source": [source],
+        "Timestamp": [pd.Timestamp.now()]
+    })
+    st.session_state.search_data = pd.concat([st.session_state.search_data, new_data], ignore_index=True)
+
+if __name__ == "__main__":
+    main()

news.py

@@ -0,0 +1,224 @@
+import streamlit as st
+import requests
+import pandas as pd
+import matplotlib.pyplot as plt
+from datetime import datetime, timedelta
+
+# Set page configuration
+st.set_page_config(page_title="News Fetcher", layout="wide")
+
+# CSS styling for Canva theme
+st.markdown(
+    """
+    <style>
+    /* General styling */
+    body {
+        font-family: 'Helvetica Neue', Arial, sans-serif;
+        background-color: #f8f9fa;  /* Light gray background */
+        color: #333;  /* Dark gray font color */
+    }
+    
+    /* Title styling */
+    h1 {
+        color: #00bcd4;  /* Canva teal */
+        font-size: 2.5em;
+        margin-bottom: 0.5em;
+    }
+
+    /* Sidebar styling */
+    .css-18e3th9 {
+        background-color: #ffffff;  /* White background for sidebar */
+        color: #333;  /* Dark text color */
+        border-right: 1px solid #e0e0e0;  /* Light gray border */
+        padding: 20px;
+    }
+
+    /* Sidebar header */
+    .css-hxt7ib {
+        color: #00bcd4;  /* Canva teal */
+        font-weight: bold;
+    }
+
+    /* Button styling */
+    button {
+        background-color: #00bcd4 !important;  /* Canva teal button */
+        color: white !important;
+        border: none !important;
+        font-weight: bold !important;
+        padding: 10px 20px;
+        border-radius: 5px;
+    }
+
+    /* Dropdown and input styling */
+    .stTextInput, .stDateInput, .stSelectbox {
+        border: 1px solid #e0e0e0 !important;  /* Light gray border */
+        border-radius: 5px !important;
+        padding: 10px !important;
+        font-size: 1em !important;
+    }
+
+    /* News articles styling */
+    .stMarkdown, .stSubheader {
+        font-family: 'Helvetica Neue', Arial, sans-serif;
+        background-color: #ffffff;  /* White background for articles */
+        color: #212529;  /* Darker gray for articles text */
+        padding: 15px;
+        border-radius: 8px;
+        box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+    }
+
+    /* Footer styling */
+    footer {
+        font-size: 0.85em;
+        color: #6c757d;  /* Gray footer text */
+        text-align: center;
+        margin-top: 50px;
+        padding: 10px;
+        border-top: 1px solid #e0e0e0;
+    }
+
+    /* Link styling */
+    a {
+        color: #00bcd4; /* Canva teal */
+    }
+
+    a:hover {
+        color: #0097a7; /* Darker teal on hover */
+    }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+# Define countries dictionary
+countries = {
+    'us': 'United States',
+    'in': 'India',
+    'gb': 'United Kingdom',
+    'ca': 'Canada',
+    'au': 'Australia',
+    'de': 'Germany',
+    'fr': 'France',
+    'it': 'Italy',
+    'jp': 'Japan',
+    'cn': 'China',
+    'br': 'Brazil',
+    'za': 'South Africa',
+    'ru': 'Russia',
+}
+
+def get_news(api_key, query=None, country='us', language='en', from_date=None, to_date=None):
+    url = 'https://newsapi.org/v2/everything'
+    params = {
+        'apiKey': api_key,
+        'q': query,
+        'from': from_date,
+        'to': to_date,
+        'language': language,
+        'pageSize': 20
+    }
+
+    try:
+        response = requests.get(url, params=params)
+        response.raise_for_status()
+        news_data = response.json()
+        if news_data['status'] == 'ok':
+            return news_data['articles']
+        else:
+            st.error("Error fetching news: {}".format(news_data['message']))
+            return []
+
+    except requests.exceptions.RequestException as e:
+        st.error("HTTP Request failed: {}".format(e))
+        return []
+
+# Important queries
+important_queries = [
+    "COVID-19", "Technology", "Politics", "Economy", "Health", 
+    "Environment", "Sports", "Entertainment", "Science", 
+    "Education", "Travel"
+]
+
+# Streamlit UI setup
+st.title("News Fetcher")
+
+# Store and display the last seen timestamp
+if 'last_seen' not in st.session_state:
+    st.session_state['last_seen'] = datetime.now()
+else:
+    st.session_state['last_seen'] = datetime.now()
+last_seen = st.session_state['last_seen']
+
+# Sidebar layout
+st.sidebar.title("Settings")
+st.sidebar.write(f"Last accessed on: {last_seen.strftime('%Y-%m-%d %H:%M:%S')}")
+
+# Language selection
+language = st.selectbox("Select your preferred language:", 
+    options=[
+        ('en', 'English'), ('es', 'Spanish'), ('fr', 'French'), 
+        ('de', 'German'), ('it', 'Italian'), ('pt', 'Portuguese'), 
+        ('ar', 'Arabic'), ('zh', 'Chinese'), ('hi', 'Hindi'), 
+        ('te', 'Telugu')
+    ])
+
+# Country selection in the sidebar
+country = st.sidebar.selectbox("Select your country:", options=list(countries.keys()), format_func=lambda x: countries[x])
+
+# Sidebar for important queries
+st.sidebar.header("Important Queries")
+for query in important_queries:
+    if st.sidebar.button(query):
+        st.session_state.query = query
+
+# Input field for user queries
+if 'query' in st.session_state:
+    query = st.session_state.query
+else:
+    query = st.text_input("Enter a search query:", placeholder="Type something...")
+
+# Date pickers for filtering news articles
+st.write("Select the date range for previous news articles:")
+from_date = st.date_input("From", value=datetime.now() - timedelta(days=30))
+to_date = st.date_input("To", value=datetime.now())
+
+# Button to fetch news
+if st.button("Fetch News"):
+    API_KEY = '43283de608cc43b7a49ad17ceda39636'   # Replace with your actual News API key
+    news_articles = get_news(API_KEY, query=query, country=country, language=language, from_date=from_date, to_date=to_date)
+
+    if news_articles:
+        for i, article in enumerate(news_articles):
+            st.subheader(article['title'])
+            st.markdown(f"**Source**: {article['source']['name']} | **Published At**: {article['publishedAt']}")
+            st.write(article['description'] or "No description available")
+            st.markdown(f"[Read more]({article['url']})")
+            st.markdown("---")
+
+        # Visualization of trends in news topics
+        dates = [article['publishedAt'][:10] for article in news_articles]
+        date_counts = pd.Series(dates).value_counts().sort_index()
+
+        st.subheader("Trends in News Topics Over Time")
+        plt.figure(figsize=(10, 5))
+        plt.plot(date_counts.index, date_counts.values, marker='o')
+        plt.xticks(rotation=45)
+        plt.xlabel('Date')
+        plt.ylabel('Number of Articles')
+        plt.title('Frequency of Articles Over Time')
+        st.pyplot(plt)
+
+    else:
+        st.write("No articles found.")
+
+# Footer
+st.markdown("---")
+st.markdown(
+    """
+    <footer>
+        Developed by SriKrishna | © 2024 | All rights reserved.<br>
+        Last accessed on: {}
+    </footer>
+    """.format(last_seen.strftime('%Y-%m-%d %H:%M:%S')),
+    unsafe_allow_html=True
+)

wikipedia.py

@@ -0,0 +1,137 @@
+import streamlit as st
+import wikipediaapi
+import datetime
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+import tempfile
+from gtts import gTTS
+import speech_recognition as sr
+
+# Wikipedia summary function with character limit and summary levels
+def get_wikipedia_summary(query, lang_code, char_limit, summary_level):
+    user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)"
+    wiki = wikipediaapi.Wikipedia(language=lang_code, extract_format=wikipediaapi.ExtractFormat.WIKI, user_agent=user_agent)
+    page = wiki.page(query)
+    if not page.exists():
+        return "Page not found."
+    if summary_level == "Brief":
+        return page.summary[:char_limit]
+    elif summary_level == "Detailed":
+        return page.summary  # Full summary
+    elif summary_level == "Bullet Points":
+        points = page.summary.split('. ')
+        return '\n'.join(f"- {p.strip()}" for p in points if p)[:char_limit]
+
+# Save chat history as PDF with a user-defined filename
+def save_chat_history_as_pdf(chat_history, file_name):
+    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp_file:
+        pdf = canvas.Canvas(tmp_file.name, pagesize=letter)
+        pdf.setTitle(file_name)
+        pdf.drawString(30, 750, f"{file_name} - Saved on {timestamp}")
+        y_position = 720
+        for query, response in chat_history:
+            pdf.drawString(30, y_position, f"User: {query}")
+            y_position -= 20
+            pdf.drawString(30, y_position, f"Bot: {response}")
+            y_position -= 40
+            if y_position < 40:
+                pdf.showPage()
+                y_position = 750
+        pdf.save()
+    return tmp_file.name
+
+# Text-to-speech using gTTS
+def text_to_speech(text, filename, lang="en"):
+    tts = gTTS(text=text, lang=lang)
+    tts.save(filename)
+    return filename
+
+# Voice search function
+def voice_search(lang_code):
+    recognizer = sr.Recognizer()
+    with sr.Microphone() as source:
+        st.write("Listening...")
+        audio = recognizer.listen(source)
+        try:
+            # Recognize the speech based on the specified language
+            query = recognizer.recognize_google(audio, language=lang_code)
+            st.success(f"You said: {query}")
+            return query
+        except sr.UnknownValueError:
+            st.error("Sorry, I could not understand the audio.")
+            return None
+        except sr.RequestError as e:
+            st.error(f"Could not request results from Google Speech Recognition service; {e}")
+            return None
+
+# Initialize the Streamlit app
+def main():
+    st.set_page_config(page_title="Wikipedia Summary & Text-to-Speech", layout="wide")
+
+    # Sidebar options
+    st.sidebar.title("Options")
+    lang_map = {
+        "English": "en",
+        "Spanish": "es",
+        "Chinese": "zh",
+        "Hindi": "hi",
+        "Telugu": "te"
+    }
+    selected_lang = st.sidebar.selectbox("Wikipedia Language", list(lang_map.keys()), key="language_selector")
+    summary_levels = ["Brief", "Detailed", "Bullet Points"]
+    summary_level = st.sidebar.selectbox("Summarization Level", summary_levels)
+    char_limit = st.sidebar.slider("Character Limit", min_value=100, max_value=2000, value=500, step=100)
+
+    # Chat history and favorites in session state
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = []
+    if "favorites" not in st.session_state:
+        st.session_state.favorites = []
+
+    st.title("Wikipedia Summary & Text-to-Speech")
+    
+    # Text input for manual search
+    query = st.text_input("Enter a topic to search on Wikipedia:")
+
+    # Button for voice search
+    if st.button("Voice Search"):
+        lang_code = lang_map[selected_lang]  # Get the language code for the selected language
+        voice_query = voice_search(lang_code)  # Pass the language code to the voice search
+        if voice_query:
+            query = voice_query  # Use the voice query if recognized
+
+    # Display summary based on query and language selection
+    if query:
+        lang_code = lang_map[selected_lang]
+        summary = get_wikipedia_summary(query, lang_code, char_limit, summary_level)
+        st.markdown(f"### Summary for: {query}")
+        st.write(summary)
+        st.session_state.chat_history.append((query, summary))
+
+        # Save to favorites
+        if st.button("Add to Favorites"):
+            st.session_state.favorites.append((query, summary))
+            st.success("Added to favorites!")
+
+        # Text-to-speech
+        tts_filename = f"{query}_speech.mp3"
+        if st.button("Play Text-to-Speech"):
+            text_to_speech(summary, tts_filename, lang=lang_code)
+            st.audio(tts_filename, format="audio/mp3")
+
+    # Save chat history as PDF
+    file_name = st.sidebar.text_input("File Name to Save Chat", value="chat_history")
+    if st.sidebar.button("Save Chat as PDF"):
+        pdf_path = save_chat_history_as_pdf(st.session_state.chat_history, file_name)
+        with open(pdf_path, "rb") as pdf_file:
+            st.sidebar.download_button("Download PDF", pdf_file, file_name=f"{file_name}.pdf", mime="application/pdf")
+
+    # Display favorites
+    st.sidebar.write("### Favorites")
+    for i, (fav_query, fav_summary) in enumerate(st.session_state.favorites, 1):
+        st.sidebar.write(f"**{i}. {fav_query}**")
+        st.sidebar.write(fav_summary[:100] + "...")
+
+if __name__ == "__main__":
+    main()

youtube.py

@@ -0,0 +1,87 @@
+import os
+import streamlit as st
+from googleapiclient.discovery import build
+import speech_recognition as sr
+from datetime import datetime
+
+# Set up YouTube API
+API_KEY = "AIzaSyA20DXMC3HeqHs9sOMQUQ041wEkgsoFXb4"  # Replace with your YouTube Data API v3 key
+youtube = build('youtube', 'v3', developerKey=API_KEY)
+
+# Function to search YouTube videos
+def search_youtube(query, max_results=5):
+    try:
+        request = youtube.search().list(
+            q=query,
+            part='id,snippet',
+            maxResults=max_results,
+            type='video'
+        )
+        response = request.execute()
+        
+        videos = []
+        for item in response['items']:
+            video_id = item['id']['videoId']
+            title = item['snippet']['title']
+            thumbnail = item['snippet']['thumbnails']['default']['url']
+            url = f'https://www.youtube.com/watch?v={video_id}'
+            videos.append({'title': title, 'url': url, 'video_id': video_id, 'thumbnail': thumbnail})
+        return videos
+    except Exception as e:
+        st.write(f"Error fetching videos: {e}")
+        return []
+
+# Function for voice recognition
+def voice_search():
+    recognizer = sr.Recognizer()
+    with sr.Microphone() as source:
+        st.write("Listening...")
+        audio = recognizer.listen(source)
+        try:
+            query = recognizer.recognize_google(audio)
+            st.success(f"You said: {query}")
+            return query
+        except sr.UnknownValueError:
+            st.error("Could not understand audio")
+            return ""
+        except sr.RequestError as e:
+            st.error(f"Could not request results from Google Speech Recognition service; {e}")
+            return ""
+
+# Streamlit UI
+st.title("YouTube Video Search")
+st.write("Search for YouTube videos using text or voice.")
+
+# Button for voice search
+if st.button("Search by Voice"):
+    search_query = voice_search()
+else:
+    # User search input
+    search_query = st.text_input("Enter search query", value="Python programming")
+
+if search_query:
+    st.write(f"Results for '{search_query}':")
+    videos = search_youtube(search_query)
+
+    # Display videos one by one
+    for video in videos:
+        st.image(video['thumbnail'])
+        st.write(f"**Title:** {video['title']}")
+        st.write(f"[Watch on YouTube]({video['url']})")
+        
+        # Add a button to play the video
+        st.video(video['url'])  # This embeds the YouTube video player
+        
+        st.write("---")
+
+# Display last seen date and time
+st.sidebar.write("### Last Seen")
+last_seen_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+st.sidebar.write(f"Last seen on: {last_seen_time}")
+
+# Footer section at the bottom of the page
+st.write("---")
+st.write("### Footer")
+st.write("This application is built for educational purposes.")
+st.write("YouTube Data API is used for video searching.")
+st.write("Developed by SriKrishna")