Upload folder using huggingface_hub

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.12'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -0,0 +1,168 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# VSCode / Misc
+.vscode
+.ruff_cache
+flagged
+*.csv

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: red
-colorTo: purple
-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
+
+## FORK features
+
+- instead of Openai, Openrouter is added as an free alternative :)
+
+
+## Screenshot
+
+![AnkiGen Screenshot](example.png)
+
+
+## Installation for Local Use
+
+1. Clone this repository:
+
+```
+git clone https://github.com/Banishedone/ankigen.git
+cd ankigen
+```
+
+
+2. Install the required dependencies:
+
+```
+pip install -r requirements.txt
+```
+
+3. Set up your Openrouter 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,269 @@
+from openai import OpenAI
+from pydantic import BaseModel
+from typing import List, Optional
+import gradio as gr
+import json
+
+
+
+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, system_prompt, user_prompt
+):
+    try:
+        completion = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": system_prompt.strip()},
+                {"role": "user", "content": user_prompt.strip()},
+            ],
+        )
+        
+        print("Raw API response:", completion)
+        
+        response_content = completion.choices[0].message.content
+        
+        try:
+            parsed_response = json.loads(response_content)
+            return parsed_response
+        except json.JSONDecodeError:
+            print("Invalid JSON response:", response_content)
+            return None
+
+    except Exception as e:
+        print(f"An error occurred during the API call: {e}")
+        return None
+
+def generate_cards(
+    api_key_input,
+    model_name,
+    subject,
+    topic_number=1,
+    cards_per_topic=2,
+    preference_prompt="assume I'm a beginner",
+):
+    gr.Info("Starting process")
+
+    if not api_key_input:
+        return gr.Error("Error: OpenRouter API key is required.")
+
+    client = OpenAI(
+        base_url="https://openrouter.ai/api/v1",
+        api_key=api_key_input,
+    )
+    model = model_name
+
+
+    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}.
+    Please provide your responses in valid JSON format.
+    """
+
+    topic_prompt = f"""
+    Generate the top {topic_number} important subjects to know on {subject} in 
+    order of ascending difficulty. Return the result as a JSON array of objects, 
+    each containing 'subject' and 'difficulty' keys.
+    """
+    try:
+        topics_response = structured_output_completion(
+            client, model, system_prompt, topic_prompt
+        )
+        if topics_response is None:
+            raise gr.Error("Failed to generate topics. Please try again.")
+        
+        topic_list = [item["subject"] for item in topics_response[:topic_number]]
+
+    except Exception as e:
+        raise gr.Error(f"An error occurred: {str(e)}. Please try again or check your API key.")
+
+    for topic in topic_list:
+        card_prompt = f"""
+        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.).
+
+        Return the result as a JSON object with the following structure:
+        {{
+            "topic": "string",
+            "cards": [
+                {{
+                    "front": {{ "question": "string" }},
+                    "back": {{
+                        "answer": "string",
+                        "explanation": "string",
+                        "example": "string"
+                    }}
+                }}
+            ]
+        }}
+        """
+
+        try:
+            cards = structured_output_completion(
+                client, model, system_prompt, card_prompt
+            )
+            if cards is None:
+                print(f"Failed to generate cards for topic '{topic}'.")
+                continue
+            if not isinstance(cards, dict) or 'topic' not in cards or 'cards' not in 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.")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Configuration")
+
+            api_key_input = gr.Textbox(
+                label="OpenRouter API Key",
+                type="password",
+                placeholder="Enter your OpenRouter API key",
+            )
+            model_input = gr.Textbox(
+                label="Model Name",
+                placeholder="Enter the model name (e.g., nousresearch/hermes-3-llama-3.1-405b:free)",
+                value="nousresearch/hermes-3-llama-3.1-405b:free"
+            )
+            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,
+            model_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