Upload 7 files

LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2024, justin
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -1,12 +1,102 @@
 ---
 title: AnkiGen
-emoji: 🐨
-colorFrom: gray
-colorTo: indigo
-sdk: gradio
-sdk_version: 4.44.1
+emoji: 📚
 app_file: app.py
-pinned: false
+requirements: requirements.txt
+python: 3.12
+sdk: gradio
+sdk_version: 4.44.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AnkiGen - Anki Card Generator
+
+AnkiGen is a Gradio-based web application that generates Anki-compatible CSV files using Large Language Models (LLMs) based on user-specified subjects and preferences.
+
+## Features
+
+- Generate Anki cards for various subjects
+- Customizable number of topics and cards per topic
+- User-friendly interface powered by Gradio
+- Exports to CSV format compatible with Anki import
+- Utilizes LLMs for high-quality content generation
+
+## TODO
+
+- [ ] model dropdown - uses gpt4o-mini by default
+- [ ] cloze (checkbox?)
+
+## Screenshot
+
+![AnkiGen Screenshot](example.png)
+
+
+## Installation for Local Use
+
+1. Clone this repository:
+
+```
+git clone https://github.com/brickfrog/ankigen.git
+cd ankigen
+```
+
+
+2. Install the required dependencies:
+
+```
+pip install -r requirements.txt
+```
+
+3. Set up your OpenAI API key (required for LLM functionality).
+
+## Usage
+
+1. Run the application:
+
+```
+gradio app.py --demo-name ankigen
+```
+
+2. Open your web browser and navigate to the provided local URL (typically `http://127.0.0.1:7860`).
+
+3. In the application interface:
+- Enter your OpenAI API key
+- Specify the subject you want to create cards for
+- Adjust the number of topics and cards per topic
+- (Optional) Add any preference prompts
+- Click "Generate Cards"
+
+4. Review the generated cards in the interface.
+
+5. Click "Export to CSV" to download the Anki-compatible file.
+
+## CSV Format
+
+The generated CSV file includes the following fields:
+- Index
+- Topic
+- Question
+- Answer
+- Explanation
+- Example
+
+You can create a new note type in Anki with these fields to handle importing.
+
+## Development
+
+This project is built with:
+- Python 3.12
+- Gradio 4.44.0
+
+To contribute or modify:
+1. Make your changes in `app.py`
+2. Update `requirements.txt` if you add new dependencies
+3. Test thoroughly before submitting pull requests
+
+## License
+
+BSD 2.0
+
+## Acknowledgments
+
+- This project uses the Gradio library (https://gradio.app/) for the web interface
+- Card generation is powered by OpenAI's language models

app.py

@@ -0,0 +1,270 @@
+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
+            # Get the total number of cards in this list to determine padding
+            total_cards = len(card_list.cards)
+            # Calculate the number of digits needed for padding
+            padding = len(str(total_cards))
+
+            for card_index, card in enumerate(card_list.cards, start=1):
+                # Format the index with zero-padding
+                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.") #noqa
+
+    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""", #noqa
+            )
+            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")

pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ankigen"
+version = "0.1.0"
+description = ""
+authors = [
+    {name = "Justin", email = "9146678+brickfrog@users.noreply.github.com"}
+]
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "openai>=1.35.10",
+    "gradio>=4.44.1",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ipykernel>=6.29.5",
+]
+
+[tool.setuptools]
+py-modules = ["app"]

requirements.txt

@@ -0,0 +1,2 @@
+gradio
+openai