File size: 4,436 Bytes
0d2ecfb |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 |
import streamlit as st
import google.generativeai as genai
import ast
import time
import re
import os
from typing import List, Tuple, Optional
def extract_python_code(text: str) -> Optional[str]:
pattern = r"```python\n(.*?)```"
match = re.search(pattern, text, re.DOTALL)
return match.group(1).strip() if match else None
def configure_genai():
secret_key = os.getenv("SECRET_KEY")
if not secret_key:
st.error("API key not found. Please set the SECRET_KEY environment variable.")
st.stop()
genai.configure(api_key=secret_key)
def parse_gemini_response(response_text: str) -> Tuple[str, str]:
try:
# First, try to parse as a single list
parsed = ast.literal_eval(response_text)
if isinstance(parsed, list) and len(parsed) == 2:
return parsed[0], parsed[1]
# If that fails, look for multiple lists
matches = re.findall(r'\[.*?\]', response_text)
if len(matches) >= 2:
first_list = ast.literal_eval(matches[0])
second_list = ast.literal_eval(matches[1])
return first_list[0], second_list[0]
# If no valid format is found, raise an exception
raise ValueError("Unexpected response format")
except Exception as e:
return "Error", f"Failed to parse response: {str(e)}"
def get_gemini_response(input_text: str) -> Tuple[str, str]:
prompt = """You are a fact checker. Given a text, respond with:
1. 'true', 'false', or 'unsure' (if you are unsure or knowledge cutoff)
2. Evidence in support or 'knowledge cutoff'
Respond in this exact format: ['true/false/unsure', 'evidence or knowledge cutoff']
Example input: 'Google was founded in 1998'
Example output: ['true', 'Google was indeed founded in September 1998 by Larry Page and Sergey Brin']
Now give a response in the exact described format for the following text:
"""
model = genai.GenerativeModel('gemini-1.5-pro')
try:
response = model.generate_content(prompt + input_text)
result, evidence = parse_gemini_response(response.text)
return result, evidence
except Exception as e:
return "Error", f"Failed to get or parse the model's response: {str(e)}"
def break_down_text(text: str) -> List[str]:
prompt = """Break down the following text into a list of individual factual statements that can be independently verified. Return only a Python list of strings.
Example input: "The Eiffel Tower, built in 1889, is 324 meters tall and located in Paris, France."
Example output: ["The Eiffel Tower was built in 1889", "The Eiffel Tower is 324 meters tall", "The Eiffel Tower is located in Paris, France"]
Now break down the following text:
"""
model = genai.GenerativeModel('gemini-1.5-pro')
response = model.generate_content(prompt + text)
code = extract_python_code(response.text)
try:
return ast.literal_eval(code) if code else []
except (ValueError, SyntaxError):
st.error(f"Failed to parse the breakdown response: {response.text}")
return []
def main():
st.title("Fact Checker")
configure_genai()
text = st.text_area('Paste the text to fact check (preferably about facts before 2021)', height=150)
if st.button("Check Facts"):
if not text:
st.warning("Please enter some text to fact-check.")
return
statements = break_down_text(text)
if not statements:
st.error("Failed to break down the text into checkable statements. Please try rephrasing your input.")
return
st.subheader("Fact Checking Results:")
for statement in statements:
with st.expander(statement):
with st.spinner('Checking...'):
result, evidence = get_gemini_response(statement)
if result.lower() == "true":
st.success(f"Likely True: {evidence}")
elif result.lower() == "false":
st.error(f"Likely False: {evidence}")
elif result.lower() == "unsure":
st.warning(f"Uncertain: {evidence}")
else:
st.error(f"Error in fact-checking: {evidence}")
time.sleep(3) # Delay to avoid rate limiting
if __name__ == "__main__":
main()
|