from openai import OpenAI

client = OpenAI()

MODEL='gpt-4o-mini'

def get_response(prompt_question, sys_msg):
    response = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "system", "content": sys_msg},
                  {"role": "user", "content": prompt_question}]
    )

    return response.choices[0].message.content

SYS_MSG_ARG_CONSTRUCT = """
# Argument Construction Utility
You are a research expert specialized in constructing arguments. Your task is to build a logical and persuasive argument based on the given topic or claim. Follow these steps:
1. Identify the main claim or thesis.
2. List key supporting points.
3. Organize points in a logical flow.
4. Anticipate potential counterarguments.
5. Provide a concluding statement that reinforces the main claim.
Respond with a structured argument without additional commentary.
"""

prompt_question = """
Claim: Artificial intelligence (AI) will increase job opportunities rather than eliminate them.
"""

response = get_response(prompt_question, SYS_MSG_ARG_CONSTRUCT)
print(response)

from openai import OpenAI

client = OpenAI()

MODEL='gpt-4o-mini'

def get_response(prompt_question, sys_msg):
    response = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "system", "content": sys_msg},
                  {"role": "user", "content": prompt_question}]
    )

    return response.choices[0].message.content

SYS_MSG_HYP_GEN = """
You are a research expert specialized in generating relevant, valid, and robust hypotheses. You will:
1. Analyze the given research question or problem.
2. Generate multiple plausible hypotheses.
3. Rank hypotheses by plausibility and testability.
4. Suggest potential experiments or data collection methods to test each hypothesis.
5. Identify potential confounding variables for each hypothesis.
Provide a list of generated hypotheses with brief explanations and testing suggestions.
"""

prompt_question = """
Research question: How does remote work affect employee productivity in software development teams?
"""

response = get_response(prompt_question, SYS_MSG_HYP_GEN)
print(response)

import arxiv
from datetime import datetime

SYS_MSG_KEYWORD_SEARCH = """
You are a search engine that translates search topics into a list of relevant keywords for effective search.
take in a research topic and you output.
"""

SYS_MSG_SEARCH_QUERIES = """
You are a search engine that takes in a research topic and you output a list of relevant
that perfectly encapsulate that topic.
"""

SYS_MSG_RELEVANCY_JUDGE = """
You are a research expert and an evalation engine for research results given a research topic of interest.
Given a research topic you output a binary score yes|no to determine if a paper summary is strictly relevant to the topic
or not.
"""
from openai import OpenAI
from pydantic import BaseModel, Field
from typing import List, Literal

client = OpenAI()

class Keywords(BaseModel):
    keywords: List[str] = Field(..., description="List of relevant keywords to search for")

class SearchQueries(BaseModel):
    queries: List[str] = Field(..., description="List of queries to search for")

def generate_keywords_for_search(research_topic):
    """

    """
    response = client.beta.chat.completions.parse(
        model=MODEL,
        messages=[{"role": "system", "content": SYS_MSG_KEYWORD_SEARCH},
                  {"role": "user", "content": research_topic}],
        response_format=Keywords
    )

    return response.choices[0].message.parsed

def generate_search_queries(research_topic, num_queries=5):

    response = client.beta.chat.completions.parse(
        model=MODEL,
        messages=[{"role": "system", "content": SYS_MSG_SEARCH_QUERIES},
                  {"role": "user", "content": f'Generate {num_queries} search queries for this research topic: {research_topic}'}],
        response_format=SearchQueries
    )

    return response.choices[0].message.parsed

class RelevantPaper(BaseModel):
    relevancy_score: Literal['yes', 'no'] = Field(description="A binary score yes|no if a paper is relevant given a research topic.")
    justification: str = Field(description="A short one sentence justification for the relevancy score.")

def filter_paper_relevancy(research_topic, paper_summary):
    paper_relevancy_score = client.beta.chat.completions.parse(
            model='gpt-4o-mini',
            messages=[
                {
                    'role': 'system', 'content': SYS_MSG_RELEVANCY_JUDGE,
                    'role': 'user', 'content': f'Given this research topic: {research_topic}, score the relevancy of this paper:\n\n {paper_summary}'
                }
            ],
            response_format=RelevantPaper
        )

    return paper_relevancy_score.choices[0].message.parsed

def filter_out_search_results(research_topic: str, search_results: dict):
    filtered_results = []
    for paper in search_results:
        relevancy = filter_paper_relevancy(research_topic, paper.summary)
        if relevancy.relevancy_score=='yes':
            filtered_results.append((paper, relevancy.justification))
        elif relevancy.relevancy_score=='no':
            continue
        else:
            raise ValueError("Invalid relevancy score")

    return filtered_results

arxiv_client = arxiv.Client()

def search_arxiv_papers(keywords, year=2024, MAX_NUM_PAPERS=30):
    query = ' '.join(keywords)

    # Define the start and end dates for the specified year
    start_date = datetime(year, 1, 1)
    end_date = datetime(year, 12, 31)

    # Append the date range filter to the query
    date_filter = f'submittedDate:[{start_date.strftime("%Y%m%d%H%M%S")} TO {end_date.strftime("%Y%m%d%H%M%S")}]'
    full_query = f'{query} AND {date_filter}'

    # Perform the search
    search = arxiv.Search(query=full_query, max_results=MAX_NUM_PAPERS)

    # Fetch the results
    results = list(arxiv_client.results(search))

    return results
research_topic = "LLMs for enhancing human's ability to research and learn"
keywords = generate_keywords_for_search(research_topic)
structured_results = search_arxiv_papers(keywords.keywords)
filtered_papers = filter_out_search_results(research_topic, structured_results)

full_search_result = []
for query in search_queries:
    keywords = generate_keywords_for_search(query)
    structured_results = search_arxiv_papers(keywords.keywords)
    full_search_result.extend(filter_out_search_results(research_topic, structured_results))
full_search_result

from pydantic import BaseModel, Field, field_validator
from typing import List, Literal

class Evidence(BaseModel):
    positions: List[Literal['yes', 'no', 'neutral']] = Field(description="A List with 1-3 ternary scores presenting the positions of the paper regarding the query/hypothesis in question as yes|no|neutral.")
    position_descriptions: List[str] = Field(description="List with 1-3 statements presenting the position for, against or neutral regarding the query/hypothesis n question.")
    evidence: List[str] = Field(description="List of DIRECT QUOTES serve as evidence to support each position.")

    @field_validator('positions', 'position_descriptions', 'evidence')
    def validate_list_size(cls, values):
        if len(set(map(len, values))) != 1:
            print("Uncertainty in results, retrying...")
        return values

SYS_MSG_EVIDENCE = """
You are a helpful research assistant. Given a research question or hypothesis you
will inspect the contents of papers or articles for evidence for or against 
the respective hypothesis in question. Your output will be 2 fields:
- positions: List of ternary scores (yes|no|neutral) presenting the positions of the paper regarding the query/hypothesis in question.
- positions_descriptions: List of a short one sentence statements summarizing the position from the text regarding the user's query or hypothesis, like: "Yes this paper validates this idea by pointing out...." etc..
- evidence: a list with DIRECT QUOTES from the paper containing information that supports and validates each position. It should be one quote to validate each position.

All 3 fields should be lists with the same size.
"""
MODEL = "gpt-4o-2024-08-06"
from openai import OpenAI

client = OpenAI()

def inspect_evidence(prompt_question):
    response = client.beta.chat.completions.parse(
        model=MODEL,
        messages=[{"role": "system", "content": SYS_MSG_EVIDENCE},
                  {"role": "user", "content": prompt_question}],
        response_format=Evidence,
    )

    return response.choices[0].message.parsed
# It's actually the entire first page but bare with me.
abstract = pdf_pages[0]
# source: https://www.semanticscholar.org/paper/Improvements-to-visual-working-memory-performance-Adam-Vogel/e18bbb815cf36aa75ef335787ecd9084d418765e
hypothesis = "Working memory training in humans might lead to long-term far transfer improvements in some cognitive abilities."

prompt = f"""
Does this abstract: 
{abstract}\n\n
presents evidence for the following statement:
{hypothesis}
"""

output = inspect_evidence(prompt)

output
for p,pd,e in zip(output.positions, output.position_descriptions, output.evidence):
    print(f"Position: {p}\nPosition Description: {pd}\nEvidence: {e}\n\n")
    print("****")
def inspect_evidence_for_hypothesis(hypothesis: str, source_content: str):
    """Inspects the evidence for, against or neutral regarding a research hypothesis."""

    prompt = f"""
    Does this abstract: 
    {source_content}\n\n
    presents evidence for the following statement:
    {hypothesis}
    """

    output = inspect_evidence(prompt)

    return output

def display_output_evidence(output):
    for p,pd,e in zip(output.positions, output.position_descriptions, output.evidence):
        print(f"Position: {p}\nPosition Description: {pd}\nEvidence: {e}\n\n")
        print("****")
# source for this abstract: https://pubmed.ncbi.nlm.nih.gov/35107614/
hypothesis_fluid_intelligence = "Working memory training might lead to long lasting improvements in fluid intelligence."
abstract_with_argument_for_improvement_in_fluid_intelligence = """
Abstract
Process-based working memory (WM) training in typically developing children usually leads to short- and long-term improvements on untrained WM tasks. However, results are mixed regarding far transfer to academic and cognitive abilities. Moreover, there is a lack of studies jointly evaluating the different types of transfer, using an adequate design and considering motivational factors. In addition, evidence is needed about how pre-training performance is related to individual differences in training-induced transfer. Therefore, this study aimed to implement and evaluate the efficacy of a computerized process-based WM training in typically developing school-age children. Near and far transfer effects were evaluated both immediately after training and after 6 months, as well as individual differences in training-induced transfer. The sample was composed of 89 typically developing children aged 9-10 years (M = 9.52, SD = 0.30), who were randomized to a WM training group or an active control group. They were evaluated at pre-training, post-training, and follow-up phases with measures of visuospatial and verbal WM, reading comprehension, math computation, and fluid intelligence. Results showed that the training group significantly improved performance in verbal WM and fluid intelligence compared to the active control group, immediately after training and after 6 months. Trained children with lower initial performance in verbal WM or fluid intelligence showed greater transfer gains. No group differences were found in motivational factors. Findings of this study suggest that process-based WM training may promote transfer to cognitive abilities and lead to compensation effects of individual differences in typically developing school-age children.
"""

output = inspect_evidence_for_hypothesis(hypothesis_fluid_intelligence, abstract_with_argument_for_improvement_in_fluid_intelligence)
display_output_evidence(output)