Status: True

Assertion

The gig economy is good for workers.

Results

The gig economy provides various benefits such as flexibility, autonomy, entrepreneurial opportunities, diverse income streams, low barrier of entry for newcomers to the workforce, and enhanced accessibility. However, it’s essential to note that these advantages might not be equally distributed among all individuals working in this sector due to factors like fluctuating demand, lack of benefits and protections typically provided by traditional employment, and potential income instability. Nevertheless, for many people, the gig economy can offer valuable opportunities and experiences that contribute positively to their professional lives.

However, it’s also crucial to consider some challenges faced in the gig economy like job security, benefits (such as health insurance), and legal protections. Therefore, while the statement is true from an overall perspective of the potential positive aspects of the gig economy, individual experiences may vary depending on their circumstances and specific working arrangements within this sector.

Debatable: The classification of the statement can be debated since it focuses primarily on the benefits of the gig economy, but does not address its drawbacks or challenges that some workers face in terms of job security and lack of traditional employment protections

Assumptions

**False (B) Arguments:**

1. Job Security: The gig economy often lacks job security, as work can be sporadic and unpredictable. Workers may struggle with income stability due to fluctuations in demand for their services.

2. Benefits: Gig workers typically do not receive the same benefits (such as health insurance, retirement contributions, or paid time off) that are available to employees of traditional companies.

3. Worker Rights: The gig economy can blur the lines between independent contractors and employees, leading to challenges in ensuring fair labor practices and protections for workers.

4. Investment in Skills: Gig work may not provide ample opportunities for workers to invest in their skills or receive training that could help them advance their careers in the long term.

5. Work-Life Balance: While gig work offers flexibility, it can also result in longer working hours and more pressure to take on additional jobs to make ends meet, potentially impacting an individual’s personal life.

Given these arguments, whether the gig economy is good for workers depends on various factors unique to each worker’s

Fact Checker Output

<|assistant|> **True (A) Arguments:**

1. Flexibility and Autonomy: The gig economy offers high flexibility and autonomy as individuals can choose when, where, and how much they want to work, which can be beneficial for those who value a non-traditional work schedule or seek opportunities outside of typical 9-to-5 jobs.

2. Entrepreneurial Spirit: Gig economy provides an opportunity for workers to develop entrepreneurial skills and gain experience in managing their own businesses, which can be advantageous if they decide to pursue self-employment or start their own ventures later on.

3. Diverse Income Streams: By working with multiple platforms or clients, gig workers have the potential to earn from various sources simultaneously, increasing their overall income and financial resilience against economic downtrances in one particular sector.

4. Low Barrier of Entry: The gig economy can serve as an entry point for those who are new to the workforce, providing them with valuable experience and a way to build their professional network before transitioning into traditional employment or entrepreneurship.

5. Accessibility: Gig

Model Used

microsoft/Phi-3-mini-4k-instruct-gguf

Script Name

fact_checker_mongodb.py

Script Code

import os
import sys
import requests
from langchain_openai.llms import OpenAI
from langchain.prompts import PromptTemplate
from dotenv import load_dotenv
from statements import get_random_statement
from mongodb_helper import insert_record  # Import MongoDB helper functions
import html

# Load environment variables from .env file
load_dotenv()

# Define category IDs
CATEGORY_IDS = {
    "True": 2,
    "False": 3,
    "Debatable": 4,
    "Unknown": 6
}

def create_wordpress_post(title, content, category):
    data = {
        "title": title,
        "content": content,
        "status": "publish",
        "categories": [CATEGORY_IDS[category]]
    }

    response = requests.post(
        os.getenv("WORDPRESS_POSTS_URL"),
        json=data,
        auth=(os.getenv("WORDPRESS_USERNAME"), os.getenv("WORDPRESS_PASSWORD"))
    )

    if response.status_code == 201:
        print("Blog post created successfully.")
    else:
        print(f"Failed to create blog post: {response.status_code} - {response.text}")

def fact_check(assertion):
    llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))

    # Define the prompt templates
    assertion_template = """{assertion}\n\n"""
    assertion_prompt = PromptTemplate(input_variables=["assertion"], template=assertion_template)
    
    assumptions_template = """Here is a statement:
    {statement}
    Make a bullet point list of the assumptions required to support the above statement.\n\n"""
    assumptions_prompt = PromptTemplate(input_variables=["statement"], template=assumptions_template)
    
    fact_checker_template = """Here is a bullet point list of assertions:
    {assertions}
    For each assumption, determine whether it is true or false. Explain your reasoning.\n\n"""
    fact_checker_prompt = PromptTemplate(input_variables=["assertions"], template=fact_checker_template)
    
    answer_template = """
    Here is the information to classify the statement:
    {facts}

    Based on the above information, how would you classify the statement? Respond with one of the following options followed by a colon and space:
    - True: [Explanation]
    - False: [Explanation]
    - Debatable: [Explanation]
    """
    answer_prompt = PromptTemplate(input_variables=["facts"], template=answer_template)
    
    # Format prompts and extract the string content
    formatted_assertion = assertion_prompt.format_prompt(assertion=assertion).text
    assertion_output = llm.invoke(formatted_assertion)
    
    formatted_assumptions = assumptions_prompt.format_prompt(statement=assertion_output).text
    assumptions_output = llm.invoke(formatted_assumptions)
    
    formatted_fact_checker = fact_checker_prompt.format_prompt(assertions=assumptions_output).text
    fact_checker_output = llm.invoke(formatted_fact_checker)
    
    formatted_answer = answer_prompt.format_prompt(facts=fact_checker_output).text
    final_output = llm.invoke(formatted_answer)
    
    return {
        "assertion_output": assertion_output,
        "assumptions_output": assumptions_output,
        "fact_checker_output": fact_checker_output,
        "final_output": final_output,
    }

def extract_status_and_reasoning(final_output):
    final_output = final_output.strip()
    if "True:" in final_output:
        status_start = final_output.find("True:")
        status = "True"
    elif "False:" in final_output:
        status_start = final_output.find("False:")
        status = "False"
    elif "Debatable:" in final_output:
        status_start = final_output.find("Debatable:")
        status = "Debatable"
    else:
        return "Unknown", final_output

    reasoning = final_output[status_start + len(status) + 1:].strip()
    return status, reasoning

if __name__ == "__main__":
    if len(sys.argv) > 1:
        assertion = sys.argv[1]
    else:
        assertion = get_random_statement()
    
    print(assertion)
    submission = fact_check(assertion)
    
    # Print the detailed outputs to inspect their structure
    for key, value in submission.items():
        print(f"{key}: {value}")
    
    # Extract the final output for status determination and reasoning
    final_output = submission['final_output']
    status, reasoning = extract_status_and_reasoning(final_output)
    
    # Record the result in MongoDB
    try:
        print("Attempting to insert record into MongoDB...")
        insert_record(
            script_name="fact_checker_mongodb.py",
            script_code=html.escape(open(__file__).read()),
            assertion=assertion,
            status=status,
            submission=submission,  # Store the entire submission for detailed analysis
            model=os.getenv("MODEL_NAME")
        )
        print("Record inserted into MongoDB successfully.")
    except Exception as e:
        print(f"Failed to insert record into MongoDB: {e}")
    
    print(final_output)
    
    # Create a blog post on WordPress
    blog_title = f"Fact Check: {assertion}"
    blog_content = f"""
    <h1>Status: {status}</h1>
    <h2>Assertion</h2>
    <p>{assertion}</p>
    <h2>Results</h2>
    <p>{reasoning}</p>
    <h3>Assumptions</h3>
    <p>{submission['assumptions_output']}</p>
    <h3>Fact Checker Output</h3>
    <p>{submission['fact_checker_output']}</p>
    <h4>Model Used</h4>
    <p>{os.getenv("MODEL_NAME")}</p>
    <h4>Script Name</h4>
    <p>fact_checker_mongodb.py</p>
    <h4>Script Code</h4>
    <pre>{html.escape(open(__file__).read())}</pre>
    """
    create_wordpress_post(blog_title, blog_content, status)