Apps isolation

app-memora.py

@@ -0,0 +1,171 @@
+from pathlib import Path
+
+import streamlit as st
+from googlesearch import search
+import pandas as pd
+import os
+from rag_sec.document_search_system import DocumentSearchSystem
+from chainguard.blockchain_logger import BlockchainLogger
+from PIL import Image
+from itertools import cycle
+
+# Blockchain Logger
+blockchain_logger = BlockchainLogger()
+
+# Directory for storing uploaded files
+UPLOAD_DIR = "uploaded_files"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+# Initialize DocumentSearchSystem
+@st.cache_resource
+def initialize_system():
+    """Initialize the DocumentSearchSystem and load documents."""
+    system = DocumentSearchSystem(
+        neo4j_uri="neo4j+s://0ca71b10.databases.neo4j.io",
+        neo4j_user="neo4j",
+        neo4j_password="HwGDOxyGS1-79nLeTiX5bx5ohoFSpvHCmTv8IRgt-lY"
+    )
+    system.retriever.load_documents()
+    return system
+
+# Initialize the system
+system = initialize_system()
+
+st.title("Memora: Secure File Upload and Search with Blockchain & Neo4j")
+st.subheader("Personalized news and global updates at your fingertips")
+# File Upload Section
+uploaded_files = st.file_uploader("Upload your files", accept_multiple_files=True, type=['jpg', 'jpeg', 'png', 'mp4', 'avi'])
+
+if uploaded_files:
+    for uploaded_file in uploaded_files:
+        # Save file locally
+        file_path = os.path.join(UPLOAD_DIR, uploaded_file.name)
+        with open(file_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+        st.success(f"File saved locally: {file_path}")
+
+        # Display uploaded file details
+        if uploaded_file.type.startswith('image'):
+            image = Image.open(uploaded_file)
+            st.image(image, caption=uploaded_file.name, use_column_width=True)
+
+        # Metadata Input
+        album = st.text_input(f"Album for {uploaded_file.name}", "Default Album")
+        tags = st.text_input(f"Tags for {uploaded_file.name} (comma-separated)", "")
+
+        # Log Metadata and Transaction
+        if st.button(f"Log Metadata for {uploaded_file.name}"):
+            metadata = {"file_name": uploaded_file.name, "tags": tags.split(','), "album": album}
+            blockchain_details = blockchain_logger.log_data(metadata)
+            blockchain_hash = blockchain_details.get("block_hash", "N/A")
+
+            # Use Neo4jHandler from DocumentSearchSystem to log the transaction
+            system.neo4j_handler.log_relationships(uploaded_file.name, tags, blockchain_hash, [album])
+            st.write(f"Metadata logged successfully! Blockchain Details: {blockchain_details}")
+
+# Blockchain Integrity Validation
+if st.button("Validate Blockchain Integrity"):
+    is_valid = blockchain_logger.is_blockchain_valid()
+    st.write("Blockchain Integrity:", "Valid ✅" if is_valid else "Invalid ❌")
+
+# Document Search Section
+st.subheader("Search Documents")
+
+# Google Search: User-Specific News
+st.subheader("1. Latest News About You")
+user_name = st.text_input("Enter your name or handle to search for recent news", value="Talex Maxim")
+
+if st.button("Search News About Me"):
+    if user_name:
+        st.write(f"Searching Google for news about **{user_name}**...")
+        try:
+            results = list(search(user_name, num_results=5))
+            if results:
+                st.success(f"Top {len(results)} results for '{user_name}':")
+                user_news_data = {"URL": results}
+                df_user_news = pd.DataFrame(user_news_data)
+                st.dataframe(df_user_news)
+            else:
+                st.warning("No recent news found about you.")
+        except Exception as e:
+            st.error(f"An error occurred during the search: {str(e)}")
+    else:
+        st.warning("Please enter your name or handle to search.")
+
+# Google Search: Global News Categories
+categories = ["Technology", "Sports", "Politics", "Entertainment", "Science"]
+
+st.title("Global News Insights")
+
+# News Results Dictionary
+news_results = {}
+
+try:
+    # Fetch News for Each Category
+    for category in categories:
+        try:
+            news_results[category] = list(search(f"latest {category} news", num_results=3))
+        except Exception as e:
+            news_results[category] = [f"Error fetching news: {str(e)}"]
+
+    # Display Results with Styled Buttons
+    for category, articles in news_results.items():
+        st.subheader(f"{category} News")
+        cols = st.columns(3)  # Create 3 columns for the layout
+
+        if articles and "Error fetching news" not in articles[0]:
+            for idx, article in enumerate(articles):
+                with cols[idx % 3]:  # Cycle through columns
+                    st.markdown(
+                        f"""
+                        <div style="padding: 10px; border: 1px solid #ccc; border-radius: 5px; margin: 10px; text-align: center;">
+                            <a href="{article}" target="_blank" style="text-decoration: none;">
+                                <button style="background-color: #c4ccc8; color: white; border: none; padding: 10px 20px; text-align: center; display: inline-block; font-size: 16px; border-radius: 5px;">
+                                    {category}-{idx + 1}
+                                </button>
+                            </a>
+                        </div>
+                        """,
+                        unsafe_allow_html=True,
+                    )
+        else:
+            st.warning(f"Could not fetch news for **{category}**.")
+except Exception as e:
+    st.error(f"An unexpected error occurred: {str(e)}")
+
+
+    #     # Display results
+    #     for category, articles in news_results.items():
+    #         st.write(f"### Top News in {category}:")
+    #         for idx, article in enumerate(articles, start=1):
+    #             st.write(f"{idx}. [Read here]({article})")
+    # except Exception as e:
+    #     st.error(f"An error occurred while fetching global news: {str(e)}")
+
+# Document Search
+st.subheader("3. Search Documents")
+query = st.text_input("Enter your query (e.g., 'sports news', 'machine learning')")
+
+if st.button("Search Documents"):
+    if query:
+        result = system.process_query(query)
+        if result["status"] == "success":
+            st.success(f"Query processed successfully!")
+            st.write("### Query Response:")
+            st.write(result["response"])
+            st.write("### Retrieved Documents:")
+            for idx, doc in enumerate(result["retrieved_documents"], start=1):
+                st.write(f"**Document {idx}:**")
+                st.write(doc[:500])  # Display the first 500 characters
+            st.write("### Blockchain Details:")
+            st.json(result["blockchain_details"])
+        elif result["status"] == "no_results":
+            st.warning("No relevant documents found for your query.")
+        elif result["status"] == "rejected":
+            st.error(result["message"])
+    else:
+        st.warning("Please enter a query to search.")
+
+# Debugging Section
+if st.checkbox("Show Debug Information"):
+    st.write(f"Total documents loaded: {len(system.retriever.documents)}")

app-news-content.py

@@ -0,0 +1,105 @@
+import streamlit as st
+import requests
+from transformers import T5Tokenizer, T5ForConditionalGeneration
+from collections import OrderedDict
+
+# Load Models
+@st.cache_resource
+def load_models():
+    tokenizer = T5Tokenizer.from_pretrained("t5-small")
+    model = T5ForConditionalGeneration.from_pretrained("t5-small")
+    return tokenizer, model
+
+t5_tokenizer, t5_model = load_models()
+
+# API Key for NewsAPI
+NEWS_API_KEY = "66db8e116ae24c49beef53e8b879600a"
+
+# Fetch news articles based on the user query
+@st.cache_data
+def fetch_news(user_query):
+    NEWS_API_URL = "https://newsapi.org/v2/everything"
+    params = {
+        'q': user_query,
+        'apiKey': NEWS_API_KEY,
+        'language': 'en',
+        'pageSize': 10,  # Fetch 10 articles
+        'sortBy': 'relevance',
+    }
+    response = requests.get(NEWS_API_URL, params=params)
+    if response.status_code == 200:
+        articles = response.json().get('articles', [])
+        return [
+            {
+                'title': article.get('title', 'No Title'),
+                'description': article.get('description', 'No Description')
+            }
+            for article in articles if article.get('description')
+        ]
+    return []
+
+# Summarize articles
+def summarize_articles(articles):
+    summaries = []
+    for article in articles:
+        input_text = f"summarize: Title: {article['title']}. Description: {article['description']}"
+        inputs = t5_tokenizer.encode(input_text, return_tensors="pt", max_length=512, truncation=True)
+        outputs = t5_model.generate(inputs, max_length=100, min_length=50, length_penalty=2.0, num_beams=4, early_stopping=True)
+        summary = t5_tokenizer.decode(outputs[0], skip_special_tokens=True)
+        summaries.append(remove_redundancy(summary))
+    return summaries
+
+# Remove redundancy in summaries
+def remove_redundancy(summary):
+    sentences = summary.split('. ')
+    seen = OrderedDict()
+    return '. '.join([seen.setdefault(s, s) for s in sentences if s not in seen])
+
+# Generate catchy content based on all 10 summaries
+def generate_catchy_content(summarized_content):
+    combined_prompt = f"""
+    Write a blog post based on these insights:
+    {', '.join(summarized_content)}
+    """
+    inputs = t5_tokenizer.encode(combined_prompt, return_tensors="pt", max_length=512, truncation=True)
+    outputs = t5_model.generate(inputs, max_length=300, length_penalty=2.0, num_beams=4, early_stopping=True)
+    return t5_tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+# Main App
+st.title("Hackathon-Ready News Summarizer & Blog Generator")
+st.subheader("Enter a topic to fetch news, summarize and generate engaging content!")
+
+# Query Input
+user_query = st.text_input("Enter a query (e.g., 'AI trends', 'Climate change impact'):")
+
+if st.button("Fetch, Summarize and Generate"):
+    if user_query:
+        st.info(f"Fetching articles related to: {user_query}")
+        with st.spinner("Fetching news articles..."):
+            articles = fetch_news(user_query)
+            if articles:
+                st.success(f"Fetched {len(articles)} articles!")
+                
+                # Display only the first 4 articles
+                st.subheader("Fetched Articles")
+                for i, article in enumerate(articles[:4], 1):
+                    st.write(f"**Article {i}:** {article['title']}")
+                    st.write(f"*Description:* {article['description']}")
+
+                # Summarize All Articles
+                st.info("Summarizing articles...")
+                summaries = summarize_articles(articles)  # Summarize all 10 articles
+                st.subheader("Summarized Articles")
+                for i, summary in enumerate(summaries[:4], 1):  # Display summaries for first 4 articles
+                    st.write(f"**Summary {i}:** {summary}")
+
+                # Generate Blog Post
+                st.info("Generating blog post...")
+                generated_content = generate_catchy_content(summaries)  # Use all 10 summaries
+                st.subheader("Generated Blog Post")
+                st.write(generated_content)
+
+            else:
+                st.warning("No articles found. Try a different query.")
+    else:
+        st.error("Please enter a query to proceed!")