|
from openai import OpenAI |
|
from pydantic import BaseModel |
|
from typing import List, Optional |
|
import gradio as gr |
|
|
|
|
|
class Step(BaseModel): |
|
explanation: str |
|
output: str |
|
|
|
|
|
class Subtopics(BaseModel): |
|
steps: List[Step] |
|
result: List[str] |
|
|
|
|
|
class Topics(BaseModel): |
|
result: List[Subtopics] |
|
|
|
|
|
class CardFront(BaseModel): |
|
question: Optional[str] = None |
|
|
|
|
|
class CardBack(BaseModel): |
|
answer: Optional[str] = None |
|
explanation: str |
|
example: str |
|
|
|
|
|
class Card(BaseModel): |
|
front: CardFront |
|
back: CardBack |
|
|
|
|
|
class CardList(BaseModel): |
|
topic: str |
|
cards: List[Card] |
|
|
|
|
|
def structured_output_completion( |
|
client, model, response_format, system_prompt, user_prompt |
|
): |
|
try: |
|
completion = client.beta.chat.completions.parse( |
|
model=model, |
|
messages=[ |
|
{"role": "system", "content": system_prompt.strip()}, |
|
{"role": "user", "content": user_prompt.strip()}, |
|
], |
|
response_format=response_format, |
|
) |
|
|
|
except Exception as e: |
|
print(f"An error occurred during the API call: {e}") |
|
return None |
|
|
|
try: |
|
if not hasattr(completion, "choices") or not completion.choices: |
|
print("No choices returned in the completion.") |
|
return None |
|
|
|
first_choice = completion.choices[0] |
|
if not hasattr(first_choice, "message"): |
|
print("No message found in the first choice.") |
|
return None |
|
|
|
if not hasattr(first_choice.message, "parsed"): |
|
print("Parsed message not available in the first choice.") |
|
return None |
|
|
|
return first_choice.message.parsed |
|
|
|
except Exception as e: |
|
print(f"An error occurred while processing the completion: {e}") |
|
raise gr.Error(f"Processing error: {e}") |
|
|
|
|
|
def generate_cards( |
|
api_key_input, |
|
subject, |
|
topic_number=1, |
|
cards_per_topic=2, |
|
preference_prompt="assume I'm a beginner", |
|
): |
|
""" |
|
Generates flashcards for a given subject. |
|
|
|
Parameters: |
|
- subject (str): The subject to generate cards for. |
|
- topic_number (int): Number of topics to generate. |
|
- cards_per_topic (int): Number of cards per topic. |
|
- preference_prompt (str): User preferences to consider. |
|
|
|
Returns: |
|
- List[List[str]]: A list of rows containing |
|
[topic, question, answer, explanation, example]. |
|
""" |
|
|
|
gr.Info("Starting process") |
|
|
|
if not api_key_input: |
|
return gr.Error("Error: OpenAI API key is required.") |
|
|
|
client = OpenAI(api_key=api_key_input) |
|
model = "gpt-4o-mini" |
|
|
|
all_card_lists = [] |
|
|
|
system_prompt = f""" |
|
You are an expert in {subject}, assisting the user to master the topic while |
|
keeping in mind the user's preferences: {preference_prompt}. |
|
""" |
|
|
|
topic_prompt = f""" |
|
Generate the top {topic_number} important subjects to know on {subject} in |
|
order of ascending difficulty. |
|
""" |
|
|
|
try: |
|
topics_response = structured_output_completion( |
|
client, model, Topics, system_prompt, topic_prompt |
|
) |
|
if topics_response is None: |
|
print("Failed to generate topics.") |
|
return [] |
|
if not hasattr(topics_response, "result") or not topics_response.result: |
|
print("Invalid topics response format.") |
|
return [] |
|
topic_list = [ |
|
item for subtopic in topics_response.result for item in subtopic.result |
|
][:topic_number] |
|
except Exception as e: |
|
raise gr.Error(f"Topic generation failed due to {e}") |
|
|
|
for topic in topic_list: |
|
card_prompt = f""" |
|
You are to generate {cards_per_topic} cards on {subject}: "{topic}" |
|
keeping in mind the user's preferences: {preference_prompt}. |
|
|
|
Questions should cover both sample problems and concepts. |
|
|
|
Use the explanation field to help the user understand the reason behind things |
|
and maximize learning. Additionally, offer tips (performance, gotchas, etc.). |
|
""" |
|
|
|
try: |
|
cards = structured_output_completion( |
|
client, model, CardList, system_prompt, card_prompt |
|
) |
|
if cards is None: |
|
print(f"Failed to generate cards for topic '{topic}'.") |
|
continue |
|
if not hasattr(cards, "topic") or not hasattr(cards, "cards"): |
|
print(f"Invalid card response format for topic '{topic}'.") |
|
continue |
|
all_card_lists.append(cards) |
|
except Exception as e: |
|
print(f"An error occurred while generating cards for topic '{topic}': {e}") |
|
continue |
|
|
|
flattened_data = [] |
|
|
|
for card_list_index, card_list in enumerate(all_card_lists, start=1): |
|
try: |
|
topic = card_list.topic |
|
|
|
total_cards = len(card_list.cards) |
|
|
|
padding = len(str(total_cards)) |
|
|
|
for card_index, card in enumerate(card_list.cards, start=1): |
|
|
|
index = f"{card_list_index}.{card_index:0{padding}}" |
|
question = card.front.question |
|
answer = card.back.answer |
|
explanation = card.back.explanation |
|
example = card.back.example |
|
row = [index, topic, question, answer, explanation, example] |
|
flattened_data.append(row) |
|
except Exception as e: |
|
print(f"An error occurred while processing card {index}: {e}") |
|
continue |
|
|
|
return flattened_data |
|
|
|
|
|
def export_csv(d): |
|
MIN_ROWS = 2 |
|
|
|
if len(d) < MIN_ROWS: |
|
gr.Warning(f"The dataframe has fewer than {MIN_ROWS} rows. Nothing to export.") |
|
return None |
|
|
|
gr.Info("Exporting...") |
|
d.to_csv("anki_deck.csv", index=False) |
|
return gr.File(value="anki_deck.csv", visible=True) |
|
|
|
|
|
with gr.Blocks( |
|
gr.themes.Soft(), title="AnkiGen", css="footer{display:none !important}" |
|
) as ankigen: |
|
gr.Markdown("# 📚 AnkiGen - Anki Card Generator") |
|
gr.Markdown("#### Generate an LLM generated Anki comptible csv based on your subject and preferences.") |
|
|
|
with gr.Row(): |
|
with gr.Column(scale=1): |
|
gr.Markdown("### Configuration") |
|
|
|
api_key_input = gr.Textbox( |
|
label="OpenAI API Key", |
|
type="password", |
|
placeholder="Enter your OpenAI API key", |
|
) |
|
subject = gr.Textbox( |
|
label="Subject", |
|
placeholder="Enter the subject, e.g., 'Basic SQL Concepts'", |
|
) |
|
topic_number = gr.Slider( |
|
label="Number of Topics", minimum=2, maximum=20, step=1, value=2 |
|
) |
|
cards_per_topic = gr.Slider( |
|
label="Cards per Topic", minimum=2, maximum=30, step=1, value=3 |
|
) |
|
preference_prompt = gr.Textbox( |
|
label="Preference Prompt", |
|
placeholder= |
|
"""Any preferences? For example: Learning level, e.g., "Assume I'm a beginner" or "Target an advanced audience" Content scope, e.g., "Only cover up until subqueries in SQL" or "Focus on organic chemistry basics""", |
|
) |
|
generate_button = gr.Button("Generate Cards") |
|
with gr.Column(scale=2): |
|
gr.Markdown("### Generated Cards") |
|
gr.Markdown( |
|
""" |
|
Subject to change: currently exports a .csv with the following fields, you can |
|
create a new note type with these fields to handle importing.: |
|
<b>Index, Topic, Question, Answer, Explanation, Example</b> |
|
""" |
|
) |
|
output = gr.Dataframe( |
|
headers=[ |
|
"Index", |
|
"Topic", |
|
"Question", |
|
"Answer", |
|
"Explanation", |
|
"Example", |
|
], |
|
interactive=False, |
|
height=800, |
|
) |
|
export_button = gr.Button("Export to CSV") |
|
download_link = gr.File(interactive=False, visible=False) |
|
|
|
generate_button.click( |
|
fn=generate_cards, |
|
inputs=[ |
|
api_key_input, |
|
subject, |
|
topic_number, |
|
cards_per_topic, |
|
preference_prompt, |
|
], |
|
outputs=output, |
|
) |
|
|
|
export_button.click(fn=export_csv, inputs=output, outputs=download_link) |
|
|
|
if __name__ == "__main__": |
|
ankigen.launch(share=False, favicon_path="./favicon.ico") |
|
|
