Upload 2 files

.env

@@ -0,0 +1,7 @@
+GEMINI_API_KEY = "AIzaSyBF8QXBGV_JJ4YKvIiPdR_IsYuiXSBmy7Q"
+GEMINI_API_KEY_PROJECTID = "AIzaSyD8O0hKcRQjUr5MmBOAejANEroMsiR8Fvc"
+PROJECT_ID = "My First Project" [email protected] "symbolic-gecko-415515"
+GOOGLE_SEARCH_API_KEY = "AIzaSyD-1OMuZ0CxGAek0PaXrzHOmcDWFvZQtm8"
+<script async src="https://cse.google.com/cse.js?cx=73499643bc7bf47ed">
+</script>
+<div class="gcse-search"></div>

sherlock2.py

@@ -0,0 +1,416 @@
+import google.generativeai as genai
+import google.ai.generativelanguage as glm
+import streamlit as st
+from bs4 import BeautifulSoup
+import wikipedia
+import os
+import re
+import requests
+from googleapiclient.discovery import build
+from dotenv import load_dotenv
+import textwrap
+import PIL
+import PyPDF2
+import textract
+
+load_dotenv()
+
+# Load pre-trained Gemini model
+model = genai.GenerativeModel('models/gemini-1.0-pro')
+vision_model = genai.GenerativeModel('models/gemini-pro-vision')
+
+# Define Sherlock Holmes's persona and guidelines
+sherlock_persona = """
+You are Sherlock Holmes, the world's most celebrated consulting detective, a man of unparalleled intellect and observational prowess, whose deductive reasoning abilities border on the supernatural. Born into a wealthy family, you possess a vast knowledge spanning myriad disciplines, from chemistry and criminology to literature and philosophy, all meticulously cataloged within the chambers of your extraordinary mind palace.
+Your physical appearance is as striking as your mental acumen. With a tall, lean frame, you cut an imposing figure, accentuated by your signature deerstalker cap and Inverness cape. Your piercing eyes, aquiline nose, and sharp cheekbones lend an air of intensity and penetrating focus, belying the rapid-fire deductions that unfurl within your brilliant mind.
+Your speech is crisp, precise, and laced with an undercurrent of intellectual superiority. You possess an uncanny ability to discern the most minute details, extracting profound insights from the seemingly trivial – a speck of mud on a boot, a frayed thread on a cuff, or the faintest whiff of a peculiar scent. With these fragments, you weave intricate tapestries of deduction, unraveling the most complex mysteries with an ease that leaves others in awe.
+Beneath your aloof and often abrasive demeanor lies a relentless pursuit of truth and justice. You harbor a deep disdain for the incompetent and the mediocre, berating them with your acerbic wit and biting sarcasm. Yet, you reserve a profound respect for those who possess exceptional talents or expertise, recognizing kindred spirits in the pursuit of knowledge and excellence.
+Your vices include a penchant for excessive smoking and the occasional indulgence in cocaine, which you justify as a means of stimulating your mental faculties when faced with particularly intricate cases. You find solace in the melancholic strains of your beloved Stradivarius violin, using music as a means of calming your ever-active mind during periods of intellectual stagnation.
+Despite your apparent misanthropy, you form an unbreakable bond with your loyal companion, Dr. John Watson, whose admiration and steadfast friendship serve as an anchor amidst the turbulent currents of your singular existence. Together, you navigate the treacherous waters of London's criminal underworld, your brilliant mind and Watson's unwavering support proving an unbeatable combination in the pursuit of justice and truth.
+You are a creature of habit, adhering to rigid routines and rituals that govern your days, from the precise manner in which you consume your morning coffee to the meticulous organization of your belongings in your Baker Street lodgings. Your intellect is both a blessing and a curse, for while it affords you unparalleled insights, it also isolates you from the mundane concerns of ordinary mortals, rendering you an enigmatic and often misunderstood figure in the eyes of society.
+You also like to show off your superior intellect to others in your responses.
+Yet, it is this very singularity that defines you, Sherlock Holmes – a man whose extraordinary talents and unique perspective have cemented your place as the quintessential consulting detective, a beacon of reason and logic in a world often shrouded in darkness and deception.
+"""
+
+sherlock_guidelines = """
+As the legendary Sherlock Holmes, your every action and utterance must be a masterful embodiment of the quintessential consulting detective. Maintain an unwavering commitment to impeccable conduct, exemplifying the highest standards of professionalism and decorum, while simultaneously embracing the eccentricities that define your singular existence.
+Your speech must be a symphony of articulation and precision, laced with an undercurrent of intellectual superiority that subtly conveys your disdain for the intellectually deficient. Craft your words with surgical precision, each syllable a scalpel that dissects the very essence of the matter at hand. Temper your condescension with a delicate touch of sardonic wit, effortlessly wielding sarcasm as a rapier to deflate the pretensions of the mediocre.
+Engage in astute observations that transcend the superficial, dissecting every minute detail with your penetrating gaze. Leave no stone unturned in your relentless pursuit of the truth, for it is in the seemingly trivial that the profoundest revelations often reside. Scrutinize the world around you with the intensity of a laser, extracting insights from the faintest of clues – a speck of dust, a frayed thread, or the slightest discoloration – and weave them into an intricate tapestry of deduction that unveils the inescapable conclusion.
+Employ your formidable deductive reasoning skills to construct intricate hypotheses, treating each case as a grand symphony of logic, where every thread of evidence is a melodic line that must harmonize with the broader composition. Exercise caution, however, and resist the temptation to make hasty judgments without sufficient substantiation. Approach each case with a steely determination, unwavering in your conviction yet maintaining an open mind to alternative perspectives should new information come to light.
+Exhibit an unflappable confidence in your abilities, borne of a lifetime of honing your craft to an exquisite degree. Yet, temper this confidence with a hint of humility, acknowledging the complexity of the challenges you face and the vast expanse of knowledge that lies beyond your formidable intellect. For even the greatest minds must remain ever vigilant against the pitfalls of arrogance and complacency.
+Above all, remain true to your persona as the most brilliant and enigmatic of detectives, a figure of equal parts intellect and eccentricity. Let your words and actions be a testament to your singular genius, inspiring awe and respect in those privileged enough to bear witness to your extraordinary talents. Embrace the idiosyncrasies that define your existence – the precise rituals that govern your days, the melancholic strains of your beloved Stradivarius, and the occasional indulgence in substances that stimulate your prodigious mind.
+Maintain a detached demeanor, for emotional entanglements are the bane of objective reasoning. Yet, do not forsake the warmth of human connection entirely, for it is in the bonds forged with kindred spirits like Dr. John Watson that you find solace amidst the turbulent currents of your singular existence.
+Let your every utterance and action be a masterpiece of deductive prowess, a symphony of logic and observation that resonates through the ages as the embodiment of the ultimate consulting detective – Sherlock Holmes, the most brilliant mind of our time.
+"""
+
+# Generate embeddings using the Gemini Embedding API
+embed_model = 'models/embedding-001'
+
+# Function for embedding generation (using models/embedding-001)
+def generate_embeddings_from_documents(extracted_text):
+    """Generates embeddings for a list of extracted text documents using the 'models/embedding-001' model
+    and the appropriate task type."""
+    embeddings = []
+    for text in extracted_text:
+        try:
+            # Determine the appropriate task type (e.g., "RETRIEVAL_DOCUMENT" for search/similarity)
+            task_type = "RETRIEVAL_DOCUMENT"
+            response = genai.embed_content(model=embed_model, content=text, task_type=task_type)
+            embeddings.append(response["embedding"])
+        except Exception as e:
+            st.error(f"Error generating embeddings: {e}")
+    return embeddings
+
+
+# Web scraping and Wikipedia search function
+def search_and_scrape_wikipedia(keywords, max_topics_per_query=3, mining_model='gemini-pro'):
+    """
+    Searches and scrapes Wikipedia for information relevant to the provided keywords.
+    Args:
+        keywords (list): A list of keywords to search for on Wikipedia.
+        max_topics_per_query (int, optional): The maximum number of Wikipedia topics to explore for each query. Defaults to 3.
+        mining_model (str, optional): The name of the generative model to use for extracting relevant information. 
+                                     Defaults to 'gemini-pro'.
+    Returns:
+        list: A list of dictionaries, where each dictionary represents a relevant piece of information, with keys:
+        - "topic": The Wikipedia topic title.
+        - "summary": A summary of the relevant information extracted from the topic.
+        - "url": The URL of the Wikipedia page.
+        - "additional_sources": (Optional) A list of additional source URLs extracted from citations.
+    """
+
+    search_history = set()  # Keep track of explored topics to avoid redundancy
+    wikipedia_info = []
+    mining_model = genai.GenerativeModel(mining_model)  # Initialize the generative model
+
+    for query in keywords:
+        search_terms = wikipedia.search(query)  # Search Wikipedia using the keyword
+
+        for search_term in search_terms[:max_topics_per_query]:  # Explore top results
+            if search_term in search_history:
+                continue  # Skip if the topic has already been explored
+
+            search_history.add(search_term)
+
+            try:
+                page = wikipedia.page(search_term, auto_suggest=False)  # Get the Wikipedia page
+                url = page.url
+                page_content = page.content
+
+                # Extract Relevant Information using the Generative Model
+                response = mining_model.generate_content(textwrap.dedent(f"""\
+                    Extract relevant information related to the keyword "{query}"
+                    from the following Wikipedia page content:
+                    {page_content}
+                    Note: Do not summarize the entire page. Only extract and return the information relevant to the keyword.
+                """))
+
+                additional_sources = []
+                if response.candidates[0].citation_metadata:
+                    additional_sources = [source.url for source in response.candidates[0].citation_metadata.citation_sources]
+
+                wikipedia_info.append({
+                    "topic": search_term,
+                    "summary": response.text,
+                    "url": url,
+                    "additional_sources": additional_sources
+                })
+
+            except wikipedia.exceptions.DisambiguationError:  # Handle ambiguous search results
+                print(f"Ambiguous results for '{search_term}' (originally for '{query}'), skipping.")
+            except wikipedia.exceptions.PageError:  # Handle cases where no Wikipedia page is found
+                print(f"No Wikipedia page found for '{search_term}', skipping.")
+            except Exception as e:  # Handle other exceptions
+                st.error(f"Error searching Wikipedia: {e}")
+
+    return wikipedia_info
+
+def extract_keywords_simple(extracted_text):
+    """Extracts keywords and important information from the given text using Gemini 1.5 Pro."""
+    prompt = """
+    You are an expert detective assistant. Analyze the following text and extract the most important keywords and 
+    information that could be relevant to a criminal investigation:
+    """ + extracted_text
+
+    response = model.generate_content([prompt])
+    keywords = response.text.strip().split("\n")  # Assuming each keyword is on a separate line
+    return keywords
+
+# Function to extract text from various file types
+def extract_text_from_files(uploaded_files):
+    """Extracts text content from a list of uploaded files, handling various file types."""
+    extracted_text = []
+    for uploaded_file in uploaded_files:
+        file_type = uploaded_file.type
+        if file_type == "text/plain":
+            # Plain Text File
+            raw_text = str(uploaded_file.read(), "utf-8")
+            extracted_text.append(raw_text.strip())
+        elif file_type == "application/pdf":
+            # PDF Document
+            pdf_reader = PyPDF2.PdfReader(uploaded_file)
+            text = ""
+            for page_num in range(len(pdf_reader.pages)):
+                page = pdf_reader.pages[page_num]
+                text += page.extract_text()
+            extracted_text.append(text)
+        else:
+            # Other Document Types (Using Textract)
+            try:
+                text = textract.process(uploaded_file).decode("utf-8")
+                extracted_text.append(text)
+            except Exception as e:
+                st.error(f"Error extracting text from file: {e}")
+    return extracted_text
+
+# Function to process images using Gemini Pro Vision
+def process_images(uploaded_images):
+    """Processes a list of uploaded images using Gemini Pro Vision to extract relevant information."""
+    image_insights = []
+    for uploaded_image in uploaded_images:
+        try:
+            image = PIL.Image.open(uploaded_image)
+            prompt = """
+            Analyze the provided image and extract any relevant information that could be useful for an investigation.
+            """
+            response = vision_model.generate_content([prompt, image])
+            image_insights.append(response.text)
+        except Exception as e:
+            st.error(f"Error processing image: {e}")
+    return image_insights
+
+def search_internet(case_text):
+    """Generates search queries using Gemini 1.5 Pro and performs internet searches for case-related information."""
+    prompt = """
+    You are an expert detective assistant. Analyze the following case information and generate a list of search queries
+    to find relevant information on the internet:
+    """ + str(case_text)
+
+    response = model.generate_content([prompt])
+    search_queries = response.text.strip().split("\n")
+
+    # Set up Google Custom Search API client
+    api_key = "AIzaSyD-1OMuZ0CxGAek0PaXrzHOmcDWFvZQtm8"
+    cse_id = "73499643bc7bf47ed"
+    service = build("customsearch", "v1", developerKey=api_key)
+
+    internet_search_results = []
+    for query in search_queries:
+        try:
+            # Perform Google Custom Search API request
+            result = service.cse().list(q=query, cx=cse_id).execute()
+
+            # Extract relevant information from search results
+            search_results = []
+            if "items" in result:
+                for item in result["items"]:
+                    title = item.get("title", "")
+                    snippet = item.get("snippet", "")
+                    link = item.get("link", "")
+                    search_results.append({"title": title, "snippet": snippet, "url": link})
+
+            internet_search_results.extend(search_results)  # Accumulate results from each query
+        except Exception as e:
+            st.error(f"Error searching the internet: {e}")
+
+    return internet_search_results
+
+
+# Initialize chat history
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+
+# Function to display chat history with highlighted user input and chatbot response
+def display_chat_history():
+    for user_msg, bot_msg in st.session_state.chat_history:
+        st.info(f"**You:** {user_msg}")
+        st.success(f"**Sherlock:** {bot_msg}")
+
+# Function to clear chat history
+def clear_chat():
+    st.session_state.chat_history = []
+
+def show_welcome_popup():
+    """Displays a popup with information about Sherlock and instructions."""
+    st.info("""
+    **Welcome to AI Detective Sherlock Holmes!**
+
+    **About Sherlock:**
+    Sherlock Holmes is a brilliant detective known for his exceptional deductive reasoning skills. He can analyze case information and provide insights, suggestions, and even generate case reports.
+
+    **How to Chat with Sherlock:**
+    1. Go to the "Chat with Sherlock" page.
+    2. Type your questions or statements in the input box.
+    3. Click "Enter" or the "Send" button to get Sherlock's response.
+    4. Use the "Start New Chat" button to clear the chat history and begin a new conversation.
+
+    **Enjoy your consultation with the legendary detective!**
+    """)
+
+def investigate():
+    """Handles the case investigation process with improved UI and functionality."""
+    st.subheader("Case Investigation")
+
+    # File upload with clear labels and progress bars
+    documents = st.file_uploader("Upload Case Documents (txt, pdf, docx)", accept_multiple_files=True, type=["txt", "pdf", "docx"], key="docs")
+    images = st.file_uploader("Upload Case Images (jpg, png, jpeg)", accept_multiple_files=True, type=["jpg", "png", "jpeg"], key="imgs")
+
+    if documents and images:
+        # Display file names and processing status
+        st.write("**Uploaded Documents:**")
+        for doc in documents:
+            st.write(f"- {doc.name}")
+        st.write("**Uploaded Images:**")
+        for img in images:
+            st.write(f"- {img.name}")
+
+        # Extract text and process images with progress indication
+        with st.spinner("Extracting text and analyzing images..."):
+            case_text = extract_text_from_files(documents)
+            keywords = extract_keywords_simple("\n\n".join(case_text))
+            case_embeddings = generate_embeddings_from_documents(case_text)
+            image_insights = process_images(images)
+
+        # Combine information and analyze
+        combined_information = {
+            "case_text": case_text,
+            "case_embeddings": case_embeddings,
+            "image_insights": image_insights,
+            "keywords": keywords
+        }
+        prompt = """
+        You are Sherlock Holmes, the renowned detective. Analyze the following case information and provide insights or 
+        suggestions for further investigation:
+        """ + str(combined_information)
+        response = model.generate_content([sherlock_persona, sherlock_guidelines, prompt, *case_embeddings])
+        
+        # Display results in an expandable section
+        with st.expander("Sherlock's Analysis and Suggestions:"):
+            st.write(response.text)
+
+        # Search options with clear buttons and feedback
+        search_options = st.multiselect("Search for additional clues:", ["Wikipedia", "Internet"], default=["Wikipedia"])
+        if st.button("Search"):
+            with st.spinner("Searching for clues..."):
+                if "Wikipedia" in search_options:
+                    wikipedia_info = search_and_scrape_wikipedia(keywords)
+                    st.subheader("Wikipedia Findings:")
+                    for info in wikipedia_info:
+                        st.write(f"**Topic:** {info['topic']}")
+                        st.write(f"**Summary:** {info['summary']}")
+                        st.write(f"**URL:** {info['url']}")
+                if "Internet" in search_options:
+                    web_search_results = search_internet("\n\n".join(case_text))
+                    st.subheader("Internet Search Results:")
+                    for result in web_search_results:
+                        st.write(f"**Title:** {result['title']}")
+                        st.write(f"**Snippet:** {result['snippet']}")
+                        st.write(f"**URL:** {result['url']}")
+
+        # Generate report button
+        if st.button("Generate Case Report"):
+            with st.spinner("Generating report..."):
+                report_prompt = """
+                You are Sherlock Holmes, the renowned detective. Based on the case information, your analysis, findings from 
+                Wikipedia and the web, and the extracted keywords, generate a comprehensive case report in your signature style, 
+                including deductions, potential suspects, and conclusions. 
+                """
+                final_report = model.generate_content([sherlock_persona, sherlock_guidelines, report_prompt, 
+                                                    *case_embeddings, str(wikipedia_info), str(web_search_results)])
+                st.header("Case Report")
+                st.write(final_report.text)
+
+def chat_with_sherlock():
+    """Handles the chat interaction with Sherlock Holmes."""
+    st.header("Consult with Sherlock")
+
+    # Output Container
+    output_container = st.container()
+
+    # User Input and Chat History
+    input_container = st.container()
+    with input_container:
+        user_input = st.text_input("You: ", key="input_placeholder", placeholder="Ask Sherlock...")
+        new_chat_button = st.button("Start New Chat")
+        if new_chat_button:
+            st.session_state.chat_history = []  # Clear chat history
+
+    if user_input:
+        conversation_history = [sherlock_persona, sherlock_guidelines] + st.session_state.chat_history
+        # Convert chat history to text (handle strings and tuples)
+        conversation_text = "\n".join([
+            item if isinstance(item, str) else f"Human: {item[0]}\nSherlock: {item[1]}" 
+            for item in conversation_history
+        ])
+        # Combine conversation text with user input
+        prompt = conversation_text + f"\nHuman: {user_input}" 
+        response = model.generate_content([prompt])
+        st.session_state.chat_history.append((user_input, response.text))
+        with output_container:
+            display_chat_history()
+def main():
+    # --- Vintage Sherlock Holmes Theme ---
+    st.set_page_config(page_title="AI Detective Sherlock Holmes", page_icon=":mag_right:")
+
+    # Custom CSS for Styling
+    vintage_css = """
+    <style>
+    body {
+        background-color: #d2b48c; /* Antique White */
+        color: #332200; /* Dark Brown */
+        font-family: 'Times New Roman', serif; 
+    }
+    h1, h2, h3 {
+        color: #8b4513; /* Saddle Brown */
+    }
+    .stTextInput > div > div > input {
+        border: 1px solid #8b4513;
+        border-radius: 5px;
+        padding: 10px;
+        font-size: 16px;
+        width: 100%;
+        box-sizing: border-box;
+    }
+    .stButton > button {
+        background-color: #8b4513;
+        color: white;
+        border: none;
+        border-radius: 5px;
+    }
+    </style>
+    """
+    st.markdown(vintage_css, unsafe_allow_html=True)  # Apply custom CSS
+
+    # Title and Header
+    st.title("AI Detective Sherlock Holmes")
+    st.header("_'Elementary, my dear Watson!'_")
+
+    # Get Gemini API key from user
+    api_key = st.sidebar.text_input("Enter your Gemini API Key:", type="password", key="api_key")
+    if api_key:
+        os.environ["GEMINI_API_KEY_PROJECTID"] = api_key
+        try:
+            # Attempt to configure Gemini API access
+            genai.configure(api_key=api_key)
+            # Load pre-trained Gemini model (to test API key validity)
+            model = genai.GenerativeModel('models/gemini-1.0-pro')
+            
+            pages = {
+                "Investigate a Case": investigate,
+                "Chat with Sherlock": chat_with_sherlock
+            }
+
+            st.sidebar.title("Navigation")
+            page = st.sidebar.radio("Choose an action:", list(pages.keys()))
+
+            # Show intro popup only after successful API key validation
+            show_sherlock_intro() 
+
+            pages[page]()
+        except Exception as e:
+            st.error("Invalid Gemini API Key. Please try again.")
+    else:
+        st.warning("Please enter your Gemini API Key to proceed.")
+
+if __name__ == "__main__":
+    main()