Upload folder using huggingface_hub

.gitignore

@@ -167,7 +167,6 @@ cython_debug/
 flagged
 *.csv
 
-
-uv.lock
 *.apkg
-*.csv
+*.csv
+.history

app.py

@@ -7,7 +7,12 @@ import logging
 from logging.handlers import RotatingFileHandler
 import sys
 from functools import lru_cache
-from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_exponential,
+    retry_if_exception_type,
+)
 import hashlib
 import genanki
 import random
@@ -45,6 +50,7 @@ class Card(BaseModel):
     front: CardFront
     back: CardBack
     metadata: Optional[dict] = None
+    card_type: str = "basic"  # Add card_type, default to basic
 
 
 class CardList(BaseModel):
@@ -77,22 +83,20 @@ class LearningSequence(BaseModel):
 
 def setup_logging():
     """Configure logging to both file and console"""
-    logger = logging.getLogger('ankigen')
+    logger = logging.getLogger("ankigen")
     logger.setLevel(logging.DEBUG)
 
     # Create formatters
     detailed_formatter = logging.Formatter(
-        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
-    simple_formatter = logging.Formatter(
-        '%(levelname)s: %(message)s'
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
     )
+    simple_formatter = logging.Formatter("%(levelname)s: %(message)s")
 
     # File handler (detailed logging)
     file_handler = RotatingFileHandler(
-        'ankigen.log',
-        maxBytes=1024*1024,  # 1MB
-        backupCount=5
+        "ankigen.log",
+        maxBytes=1024 * 1024,  # 1MB
+        backupCount=5,
     )
     file_handler.setLevel(logging.DEBUG)
     file_handler.setFormatter(detailed_formatter)
@@ -116,15 +120,18 @@ logger = setup_logging()
 # Replace the caching implementation with a proper cache dictionary
 _response_cache = {}  # Global cache dictionary
 
+
 @lru_cache(maxsize=100)
 def get_cached_response(cache_key: str):
     """Get response from cache"""
     return _response_cache.get(cache_key)
 
+
 def set_cached_response(cache_key: str, response):
     """Set response in cache"""
     _response_cache[cache_key] = response
 
+
 def create_cache_key(prompt: str, model: str) -> str:
     """Create a unique cache key for the API request"""
     return hashlib.md5(f"{model}:{prompt}".encode()).hexdigest()
@@ -137,7 +144,7 @@ def create_cache_key(prompt: str, model: str) -> str:
     retry=retry_if_exception_type(Exception),
     before_sleep=lambda retry_state: logger.warning(
         f"Retrying API call (attempt {retry_state.attempt_number})"
-    )
+    ),
 )
 def structured_output_completion(
     client, model, response_format, system_prompt, user_prompt
@@ -145,17 +152,17 @@ def structured_output_completion(
     """Make API call with retry logic and caching"""
     cache_key = create_cache_key(f"{system_prompt}:{user_prompt}", model)
     cached_response = get_cached_response(cache_key)
-    
+
     if cached_response is not None:
         logger.info("Using cached response")
         return cached_response
 
     try:
         logger.debug(f"Making API call with model {model}")
-        
+
         # Add JSON instruction to system prompt
         system_prompt = f"{system_prompt}\nProvide your response as a JSON object matching the specified schema."
-        
+
         completion = client.chat.completions.create(
             model=model,
             messages=[
@@ -163,7 +170,7 @@ def structured_output_completion(
                 {"role": "user", "content": user_prompt.strip()},
             ],
             response_format={"type": "json_object"},
-            temperature=0.7
+            temperature=0.7,
         )
 
         if not hasattr(completion, "choices") or not completion.choices:
@@ -177,7 +184,7 @@ def structured_output_completion(
 
         # Parse the JSON response
         result = json.loads(first_choice.message.content)
-        
+
         # Cache the successful response
         set_cached_response(cache_key, result)
         return result
@@ -188,25 +195,33 @@ def structured_output_completion(
 
 
 def generate_cards_batch(
-    client,
-    model,
-    topic,
-    num_cards,
-    system_prompt,
-    batch_size=3
+    client, model, topic, num_cards, system_prompt, generate_cloze=False, batch_size=3
 ):
-    """Generate a batch of cards for a topic"""
+    """Generate a batch of cards for a topic, potentially including cloze deletions"""
+
+    cloze_instruction = ""
+    if generate_cloze:
+        cloze_instruction = """
+        Where appropriate, generate Cloze deletion cards.
+        - For Cloze cards, set "card_type" to "cloze".
+        - Format the question field using Anki's cloze syntax (e.g., "The capital of France is {{c1::Paris}}.").
+        - The "answer" field should contain the full, non-cloze text or specific context for the cloze.
+        - For standard question/answer cards, set "card_type" to "basic".
+        """
+
     cards_prompt = f"""
     Generate {num_cards} flashcards for the topic: {topic}
+    {cloze_instruction}
     Return your response as a JSON object with the following structure:
     {{
         "cards": [
             {{
+                "card_type": "basic or cloze",
                 "front": {{
-                    "question": "question text"
+                    "question": "question text (potentially with {{c1::cloze syntax}})"
                 }},
                 "back": {{
-                    "answer": "concise answer",
+                    "answer": "concise answer or full text for cloze",
                     "explanation": "detailed explanation",
                     "example": "practical example"
                 }},
@@ -217,18 +232,17 @@ def generate_cards_batch(
                     "difficulty": "beginner/intermediate/advanced"
                 }}
             }}
+            // ... more cards
         ]
     }}
     """
 
     try:
-        logger.info(f"Generated learning sequence for {topic}")
+        logger.info(
+            f"Generating card batch for {topic}, Cloze enabled: {generate_cloze}"
+        )
         response = structured_output_completion(
-            client,
-            model,
-            {"type": "json_object"},
-            system_prompt,
-            cards_prompt
+            client, model, {"type": "json_object"}, system_prompt, cards_prompt
         )
 
         if not response or "cards" not in response:
@@ -238,62 +252,83 @@ def generate_cards_batch(
         # Convert the JSON response into Card objects
         cards = []
         for card_data in response["cards"]:
+            # Ensure required fields are present before creating Card object
+            if "front" not in card_data or "back" not in card_data:
+                logger.warning(
+                    f"Skipping card due to missing front/back data: {card_data}"
+                )
+                continue
+            if "question" not in card_data["front"]:
+                logger.warning(f"Skipping card due to missing question: {card_data}")
+                continue
+            if (
+                "answer" not in card_data["back"]
+                or "explanation" not in card_data["back"]
+                or "example" not in card_data["back"]
+            ):
+                logger.warning(
+                    f"Skipping card due to missing answer/explanation/example: {card_data}"
+                )
+                continue
+
             card = Card(
+                card_type=card_data.get("card_type", "basic"),
                 front=CardFront(**card_data["front"]),
                 back=CardBack(**card_data["back"]),
-                metadata=card_data.get("metadata", {})
+                metadata=card_data.get("metadata", {}),
             )
             cards.append(card)
 
         return cards
 
     except Exception as e:
-        logger.error(f"Failed to generate cards batch: {str(e)}")
+        logger.error(
+            f"Failed to generate cards batch for {topic}: {str(e)}", exc_info=True
+        )
         raise
 
 
 # Add near the top with other constants
 AVAILABLE_MODELS = [
     {
-        "value": "gpt-4o-mini",  # Default model
-        "label": "gpt-4o Mini (Fastest)",
-        "description": "Balanced speed and quality"
+        "value": "gpt-4.1-mini",  # Default model
+        "label": "gpt-4.1 Mini (Fastest)",
+        "description": "Balanced speed and quality",
     },
     {
-        "value": "gpt-4o",
-        "label": "gpt-4o (Better Quality)",
-        "description": "Higher quality, slower generation"
+        "value": "gpt-4.1",
+        "label": "gpt-4.1 (Better Quality)",
+        "description": "Higher quality, slower generation",
     },
-    {
-        "value": "o1",
-        "label": "o1 (Best Quality)",
-        "description": "Highest quality, longest generation time"
-    }
 ]
 
 GENERATION_MODES = [
     {
         "value": "subject",
         "label": "Single Subject",
-        "description": "Generate cards for a specific topic"
+        "description": "Generate cards for a specific topic",
     },
     {
         "value": "path",
         "label": "Learning Path",
-        "description": "Break down a job description or learning goal into subjects"
-    }
+        "description": "Break down a job description or learning goal into subjects",
+    },
 ]
 
+
 def generate_cards(
     api_key_input,
     subject,
-    model_name="gpt-4o-mini",
+    model_name="gpt-4.1-mini",
     topic_number=1,
     cards_per_topic=2,
     preference_prompt="assume I'm a beginner",
+    generate_cloze=False,
 ):
     logger.info(f"Starting card generation for subject: {subject}")
-    logger.debug(f"Parameters: topics={topic_number}, cards_per_topic={cards_per_topic}")
+    logger.debug(
+        f"Parameters: topics={topic_number}, cards_per_topic={cards_per_topic}, cloze={generate_cloze}"
+    )
 
     # Input validation
     if not api_key_input:
@@ -305,9 +340,9 @@ def generate_cards(
     if not subject.strip():
         logger.warning("No subject provided")
         raise gr.Error("Subject is required")
-    
+
     gr.Info("🚀 Starting card generation...")
-    
+
     try:
         logger.debug("Initializing OpenAI client")
         client = OpenAI(api_key=api_key_input)
@@ -318,9 +353,9 @@ def generate_cards(
     model = model_name
     flattened_data = []
     total = 0
-    
+
     progress_tracker = gr.Progress(track_tqdm=True)
-    
+
     system_prompt = f"""
     You are an expert educator in {subject}, creating an optimized learning sequence.
     Your goal is to:
@@ -357,30 +392,21 @@ def generate_cards(
     try:
         logger.info("Generating topics...")
         topics_response = structured_output_completion(
-            client,
-            model,
-            {"type": "json_object"},
-            system_prompt,
-            topic_prompt
+            client, model, {"type": "json_object"}, system_prompt, topic_prompt
         )
-        
+
         if not topics_response or "topics" not in topics_response:
             logger.error("Invalid topics response format")
             raise gr.Error("Failed to generate topics. Please try again.")
 
         topics = topics_response["topics"]
-        
+
         gr.Info(f"✨ Generated {len(topics)} topics successfully!")
-        
+
         # Generate cards for each topic
-        for i, topic in enumerate(progress_tracker.tqdm(topics, desc="Generating cards")):
-            progress_html = f"""
-            <div style="text-align: center">
-                <p>Generating cards for topic {i+1}/{len(topics)}: {topic["name"]}</p>
-                <p>Cards generated so far: {total}</p>
-            </div>
-            """
-            
+        for i, topic in enumerate(
+            progress_tracker.tqdm(topics, desc="Generating cards")
+        ):
             try:
                 cards = generate_cards_batch(
                     client,
@@ -388,17 +414,19 @@ def generate_cards(
                     topic["name"],
                     cards_per_topic,
                     system_prompt,
-                    batch_size=3
+                    generate_cloze=generate_cloze,
+                    batch_size=3,
                 )
-                
+
                 if cards:
                     for card_index, card in enumerate(cards, start=1):
-                        index = f"{i+1}.{card_index}"
+                        index = f"{i + 1}.{card_index}"
                         metadata = card.metadata or {}
-                        
+
                         row = [
                             index,
                             topic["name"],
+                            card.card_type,
                             card.front.question,
                             card.back.answer,
                             card.back.explanation,
@@ -406,15 +434,17 @@ def generate_cards(
                             metadata.get("prerequisites", []),
                             metadata.get("learning_outcomes", []),
                             metadata.get("misconceptions", []),
-                            metadata.get("difficulty", "beginner")
+                            metadata.get("difficulty", "beginner"),
                         ]
                         flattened_data.append(row)
                         total += 1
-                    
+
                     gr.Info(f"✅ Generated {len(cards)} cards for {topic['name']}")
-                
+
             except Exception as e:
-                logger.error(f"Failed to generate cards for topic {topic['name']}: {str(e)}")
+                logger.error(
+                    f"Failed to generate cards for topic {topic['name']}: {str(e)}"
+                )
                 gr.Warning(f"Failed to generate cards for '{topic['name']}'")
                 continue
 
@@ -424,13 +454,14 @@ def generate_cards(
             <p>Total cards generated: {total}</p>
         </div>
         """
-        
+
         # Convert to DataFrame with all columns
         df = pd.DataFrame(
             flattened_data,
             columns=[
                 "Index",
                 "Topic",
+                "Card_Type",
                 "Question",
                 "Answer",
                 "Explanation",
@@ -438,10 +469,10 @@ def generate_cards(
                 "Prerequisites",
                 "Learning_Outcomes",
                 "Common_Misconceptions",
-                "Difficulty"
-            ]
+                "Difficulty",
+            ],
         )
-        
+
         return df, final_html, total
 
     except Exception as e:
@@ -452,20 +483,21 @@ def generate_cards(
 # Update the BASIC_MODEL definition with enhanced CSS/HTML
 BASIC_MODEL = genanki.Model(
     random.randrange(1 << 30, 1 << 31),
-    'AnkiGen Enhanced',
+    "AnkiGen Enhanced",
     fields=[
-        {'name': 'Question'},
-        {'name': 'Answer'},
-        {'name': 'Explanation'},
-        {'name': 'Example'},
-        {'name': 'Prerequisites'},
-        {'name': 'Learning_Outcomes'},
-        {'name': 'Common_Misconceptions'},
-        {'name': 'Difficulty'}
+        {"name": "Question"},
+        {"name": "Answer"},
+        {"name": "Explanation"},
+        {"name": "Example"},
+        {"name": "Prerequisites"},
+        {"name": "Learning_Outcomes"},
+        {"name": "Common_Misconceptions"},
+        {"name": "Difficulty"},
     ],
-    templates=[{
-        'name': 'Card 1',
-        'qfmt': '''
+    templates=[
+        {
+            "name": "Card 1",
+            "qfmt": """
             <div class="card question-side">
                 <div class="difficulty-indicator {{Difficulty}}"></div>
                 <div class="content">
@@ -482,8 +514,8 @@ BASIC_MODEL = genanki.Model(
                     this.parentElement.classList.toggle('show');
                 });
             </script>
-        ''',
-        'afmt': '''
+        """,
+            "afmt": """
             <div class="card answer-side">
                 <div class="content">
                     <div class="question-section">
@@ -528,9 +560,10 @@ BASIC_MODEL = genanki.Model(
                     </div>
                 </div>
             </div>
-        ''',
-    }],
-    css='''
+        """,
+        }
+    ],
+    css="""
         /* Base styles */
         .card {
             font-family: 'Inter', system-ui, -apple-system, sans-serif;
@@ -714,15 +747,69 @@ BASIC_MODEL = genanki.Model(
         .tab-content.active {
             animation: fadeIn 0.2s ease-in-out;
         }
-    '''
+    """,
 )
 
+
+# Define the Cloze Model (based on Anki's default Cloze type)
+CLOZE_MODEL = genanki.Model(
+    random.randrange(1 << 30, 1 << 31),  # Needs a unique ID
+    "AnkiGen Cloze Enhanced",
+    model_type=genanki.Model.CLOZE,  # Specify model type as CLOZE
+    fields=[
+        {"name": "Text"},  # Field for the text containing the cloze deletion
+        {"name": "Extra"},  # Field for additional info shown on the back
+        {"name": "Difficulty"},  # Keep metadata
+        {"name": "SourceTopic"},  # Add topic info
+    ],
+    templates=[
+        {
+            "name": "Cloze Card",
+            "qfmt": "{{cloze:Text}}",
+            "afmt": """
+                {{cloze:Text}}
+                <hr>
+                <div class="extra-info">{{Extra}}</div>
+                <div class="metadata-footer">Difficulty: {{Difficulty}} | Topic: {{SourceTopic}}</div>
+            """,
+        }
+    ],
+    css="""
+        .card {
+            font-family: 'Inter', system-ui, -apple-system, sans-serif;
+            font-size: 16px; line-height: 1.6; color: #1a1a1a;
+            max-width: 800px; margin: 0 auto; padding: 20px;
+            background: #ffffff;
+        }
+        .cloze {
+            font-weight: bold; color: #2563eb;
+        }
+        .extra-info {
+            margin-top: 1em; padding-top: 1em;
+            border-top: 1px solid #e5e7eb;
+            font-size: 0.95em; color: #333;
+            background: #f8fafc; padding: 1em; border-radius: 6px;
+        }
+        .extra-info h3 { margin-top: 0.5em; font-size: 1.1em; color: #1e293b; }
+        .extra-info pre code {
+            display: block; padding: 1em; background: #1e293b;
+            color: #e2e8f0; border-radius: 6px; overflow-x: auto;
+            font-family: 'Fira Code', 'Consolas', monospace; font-size: 0.9em;
+            margin-top: 0.5em;
+        }
+        .metadata-footer {
+            margin-top: 1.5em; font-size: 0.85em; color: #64748b; text-align: right;
+        }
+    """,
+)
+
+
 # Split the export functions
 def export_csv(data):
     """Export the generated cards as a CSV file"""
     if data is None:
         raise gr.Error("No data to export. Please generate cards first.")
-        
+
     if len(data) < 2:  # Minimum 2 cards
         raise gr.Error("Need at least 2 cards to export.")
 
@@ -732,188 +819,91 @@ def export_csv(data):
         data.to_csv(csv_path, index=False)
         gr.Info("✅ CSV export complete!")
         return gr.File(value=csv_path, visible=True)
-    
+
     except Exception as e:
         logger.error(f"Failed to export CSV: {str(e)}", exc_info=True)
         raise gr.Error(f"Failed to export CSV: {str(e)}")
 
+
 def export_deck(data, subject):
     """Export the generated cards as an Anki deck with pedagogical metadata"""
     if data is None:
         raise gr.Error("No data to export. Please generate cards first.")
-        
+
     if len(data) < 2:  # Minimum 2 cards
         raise gr.Error("Need at least 2 cards to export.")
 
     try:
         gr.Info("💾 Creating Anki deck...")
-        
+
         deck_id = random.randrange(1 << 30, 1 << 31)
         deck = genanki.Deck(deck_id, f"AnkiGen - {subject}")
-        
-        records = data.to_dict('records')
-        
-        # Update the model to include metadata fields
-        global BASIC_MODEL
-        BASIC_MODEL = genanki.Model(
-            random.randrange(1 << 30, 1 << 31),
-            'AnkiGen Enhanced',
-            fields=[
-                {'name': 'Question'},
-                {'name': 'Answer'},
-                {'name': 'Explanation'},
-                {'name': 'Example'},
-                {'name': 'Prerequisites'},
-                {'name': 'Learning_Outcomes'},
-                {'name': 'Common_Misconceptions'},
-                {'name': 'Difficulty'}
-            ],
-            templates=[{
-                'name': 'Card 1',
-                'qfmt': '''
-                    <div class="card question">
-                        <div class="content">{{Question}}</div>
-                        <div class="prerequisites">Prerequisites: {{Prerequisites}}</div>
-                    </div>
-                ''',
-                'afmt': '''
-                    <div class="card answer">
-                        <div class="question">{{Question}}</div>
-                        <hr>
-                        <div class="content">
-                            <div class="answer-section">
-                                <h3>Answer:</h3>
-                                <div>{{Answer}}</div>
-                            </div>
-                            
-                            <div class="explanation-section">
-                                <h3>Explanation:</h3>
-                                <div>{{Explanation}}</div>
-                            </div>
-                            
-                            <div class="example-section">
-                                <h3>Example:</h3>
-                                <pre><code>{{Example}}</code></pre>
-                            </div>
-                            
-                            <div class="metadata-section">
-                                <h3>Prerequisites:</h3>
-                                <div>{{Prerequisites}}</div>
-                                
-                                <h3>Learning Outcomes:</h3>
-                                <div>{{Learning_Outcomes}}</div>
-                                
-                                <h3>Watch out for:</h3>
-                                <div>{{Common_Misconceptions}}</div>
-                                
-                                <h3>Difficulty Level:</h3>
-                                <div>{{Difficulty}}</div>
-                            </div>
-                        </div>
-                    </div>
-                '''
-            }],
-            css='''
-                .card {
-                    font-family: 'Inter', system-ui, -apple-system, sans-serif;
-                    font-size: 16px;
-                    line-height: 1.6;
-                    color: #1a1a1a;
-                    max-width: 800px;
-                    margin: 0 auto;
-                    padding: 20px;
-                    background: #ffffff;
-                }
-                
-                .question {
-                    font-size: 1.3em;
-                    font-weight: 600;
-                    color: #2563eb;
-                    margin-bottom: 1.5em;
-                }
-                
-                .prerequisites {
-                    font-size: 0.9em;
-                    color: #666;
-                    margin-top: 1em;
-                    font-style: italic;
-                }
-                
-                .answer-section,
-                .explanation-section,
-                .example-section {
-                    margin: 1.5em 0;
-                    padding: 1.2em;
-                    border-radius: 8px;
-                    box-shadow: 0 2px 4px rgba(0,0,0,0.05);
-                }
-                
-                .answer-section {
-                    background: #f0f9ff;
-                    border-left: 4px solid #2563eb;
-                }
-                
-                .explanation-section {
-                    background: #f0fdf4;
-                    border-left: 4px solid #4ade80;
-                }
-                
-                .example-section {
-                    background: #fff7ed;
-                    border-left: 4px solid #f97316;
-                }
-                
-                .metadata-section {
-                    background: #f8f9fa;
-                    padding: 1em;
-                    border-radius: 6px;
-                    margin: 1em 0;
-                }
-                
-                pre code {
-                    display: block;
-                    padding: 1em;
-                    background: #1e293b;
-                    color: #e2e8f0;
-                    border-radius: 6px;
-                    overflow-x: auto;
-                    font-family: 'Fira Code', 'Consolas', monospace;
-                    font-size: 0.9em;
-                }
-            '''
-        )
-        
+
+        records = data.to_dict("records")
+
+        # Ensure both models are added to the deck package
+        deck.add_model(BASIC_MODEL)
+        deck.add_model(CLOZE_MODEL)
+
         # Add notes to the deck
         for record in records:
-            note = genanki.Note(
-                model=BASIC_MODEL,
-                fields=[
-                    str(record['Question']),
-                    str(record['Answer']),
-                    str(record['Explanation']),
-                    str(record['Example']),
-                    str(record['Prerequisites']),
-                    str(record['Learning_Outcomes']),
-                    str(record['Common_Misconceptions']),
-                    str(record['Difficulty'])
-                ]
-            )
+            card_type = record.get("Card_Type", "basic").lower()
+
+            if card_type == "cloze":
+                # Create Cloze note
+                extra_content = f"""
+                    <h3>Explanation:</h3>
+                    <div>{record["Explanation"]}</div>
+                    <h3>Example:</h3>
+                    <pre><code>{record["Example"]}</code></pre>
+                    <h3>Prerequisites:</h3>
+                    <div>{record["Prerequisites"]}</div>
+                    <h3>Learning Outcomes:</h3>
+                    <div>{record["Learning_Outcomes"]}</div>
+                    <h3>Watch out for:</h3>
+                    <div>{record["Common_Misconceptions"]}</div>
+                """
+                note = genanki.Note(
+                    model=CLOZE_MODEL,
+                    fields=[
+                        str(record["Question"]),  # Contains {{c1::...}}
+                        extra_content,  # All other info goes here
+                        str(record["Difficulty"]),
+                        str(record["Topic"]),
+                    ],
+                )
+            else:  # Default to basic card
+                # Create Basic note (existing logic)
+                note = genanki.Note(
+                    model=BASIC_MODEL,
+                    fields=[
+                        str(record["Question"]),
+                        str(record["Answer"]),
+                        str(record["Explanation"]),
+                        str(record["Example"]),
+                        str(record["Prerequisites"]),
+                        str(record["Learning_Outcomes"]),
+                        str(record["Common_Misconceptions"]),
+                        str(record["Difficulty"]),
+                    ],
+                )
+
             deck.add_note(note)
-        
+
         # Create a temporary directory for the package
         with tempfile.TemporaryDirectory() as temp_dir:
             output_path = Path(temp_dir) / "anki_deck.apkg"
             package = genanki.Package(deck)
             package.write_to_file(output_path)
-            
+
             # Copy to a more permanent location
             final_path = "anki_deck.apkg"
-            with open(output_path, 'rb') as src, open(final_path, 'wb') as dst:
+            with open(output_path, "rb") as src, open(final_path, "wb") as dst:
                 dst.write(src.read())
-        
+
         gr.Info("✅ Anki deck export complete!")
         return gr.File(value=final_path, visible=True)
-    
+
     except Exception as e:
         logger.error(f"Failed to export Anki deck: {str(e)}", exc_info=True)
         raise gr.Error(f"Failed to export Anki deck: {str(e)}")
@@ -951,21 +941,22 @@ custom_theme = gr.themes.Soft().set(
     button_primary_text_color="white",
 )
 
+
 def analyze_learning_path(api_key, description, model):
     """Analyze a job description or learning goal to create a structured learning path"""
-    
+
     try:
         client = OpenAI(api_key=api_key)
     except Exception as e:
         logger.error(f"Failed to initialize OpenAI client: {str(e)}")
         raise gr.Error(f"Failed to initialize OpenAI client: {str(e)}")
-    
+
     system_prompt = """You are an expert curriculum designer and educational consultant.
     Your task is to analyze learning goals and create structured, achievable learning paths.
     Break down complex topics into manageable subjects, identify prerequisites,
     and suggest practical projects that reinforce learning.
     Focus on creating a logical progression that builds upon previous knowledge."""
-    
+
     path_prompt = f"""
     Analyze this description and create a structured learning path.
     Return your analysis as a JSON object with the following structure:
@@ -984,38 +975,96 @@ def analyze_learning_path(api_key, description, model):
     Description to analyze:
     {description}
     """
-    
+
     try:
         response = structured_output_completion(
-            client,
-            model,
-            {"type": "json_object"},
-            system_prompt,
-            path_prompt
+            client, model, {"type": "json_object"}, system_prompt, path_prompt
         )
-        
-        # Format the response for the UI
+
+        if (
+            not response
+            or "subjects" not in response
+            or "learning_order" not in response
+            or "projects" not in response
+        ):
+            logger.error("Invalid response format from API")
+            raise gr.Error("Failed to analyze learning path. Please try again.")
+
         subjects_df = pd.DataFrame(response["subjects"])
-        learning_order_text = f"### Recommended Learning Order\n{response['learning_order']}"
+        learning_order_text = (
+            f"### Recommended Learning Order\n{response['learning_order']}"
+        )
         projects_text = f"### Suggested Projects\n{response['projects']}"
-        
+
         return subjects_df, learning_order_text, projects_text
-        
+
     except Exception as e:
         logger.error(f"Failed to analyze learning path: {str(e)}")
         raise gr.Error(f"Failed to analyze learning path: {str(e)}")
 
+
+# --- Example Data for Initialization ---
+example_data = pd.DataFrame(
+    [
+        [
+            "1.1",
+            "SQL Basics",
+            "basic",
+            "What is a SELECT statement used for?",
+            "Retrieving data from one or more database tables.",
+            "The SELECT statement is the most common command in SQL. It allows you to specify which columns and rows you want to retrieve from a table based on certain conditions.",
+            "```sql\\nSELECT column1, column2 FROM my_table WHERE condition;\\n```",
+            ["Understanding of database tables"],
+            ["Retrieve specific data", "Filter results"],
+            ["❌ SELECT * is always efficient (Reality: Can be slow for large tables)"],
+            "beginner",
+        ],
+        [
+            "2.1",
+            "Python Fundamentals",
+            "cloze",
+            "The primary keyword to define a function in Python is {{c1::def}}.",
+            "def",
+            "Functions are defined using the `def` keyword, followed by the function name, parentheses for arguments, and a colon. The indented block below defines the function body.",
+            # Use a raw triple-quoted string for the code block to avoid escaping issues
+            r"""```python
+def greet(name):
+    print(f"Hello, {name}!")
+```""",
+            ["Basic programming concepts"],
+            ["Define reusable blocks of code"],
+            ["❌ Forgetting the colon (:) after the definition"],
+            "beginner",
+        ],
+    ],
+    columns=[
+        "Index",
+        "Topic",
+        "Card_Type",
+        "Question",
+        "Answer",
+        "Explanation",
+        "Example",
+        "Prerequisites",
+        "Learning_Outcomes",
+        "Common_Misconceptions",
+        "Difficulty",
+    ],
+)
+# -------------------------------------
+
 with gr.Blocks(
     theme=custom_theme,
     title="AnkiGen",
     css="""
         #footer {display:none !important}
-        .tall-dataframe {height: 800px !important}
-        .contain {max-width: 1200px; margin: auto;}
+        .tall-dataframe {min-height: 500px !important}
+        .contain {max-width: 95% !important; margin: auto;}
         .output-cards {border-radius: 8px; box-shadow: 0 4px 6px -1px rgba(0,0,0,0.1);}
         .hint-text {font-size: 0.9em; color: #666; margin-top: 4px;}
+        .export-group > .gradio-group { margin-bottom: 0 !important; padding-bottom: 5px !important; }
     """,
-    js=js_storage,  # Add the JavaScript
+    js=js_storage,
 ) as ankigen:
     with gr.Column(elem_classes="contain"):
         gr.Markdown("# 📚 AnkiGen - Advanced Anki Card Generator")
@@ -1026,68 +1075,62 @@ with gr.Blocks(
         with gr.Row():
             with gr.Column(scale=1):
                 gr.Markdown("### Configuration")
-                
+
                 # Add mode selection
                 generation_mode = gr.Radio(
-                    choices=[
-                        "subject",
-                        "path"
-                    ],
+                    choices=["subject", "path"],
                     value="subject",
                     label="Generation Mode",
-                    info="Choose how you want to generate content"
+                    info="Choose how you want to generate content",
                 )
-                
+
                 # Create containers for different modes
                 with gr.Group() as subject_mode:
                     subject = gr.Textbox(
                         label="Subject",
                         placeholder="Enter the subject, e.g., 'Basic SQL Concepts'",
-                        info="The topic you want to generate flashcards for"
+                        info="The topic you want to generate flashcards for",
                     )
-                
+
                 with gr.Group(visible=False) as path_mode:
                     description = gr.Textbox(
                         label="Learning Goal",
                         placeholder="Paste a job description or describe what you want to learn...",
                         info="We'll break this down into learnable subjects",
-                        lines=5
+                        lines=5,
+                    )
+                    analyze_button = gr.Button(
+                        "Analyze & Break Down", variant="secondary"
                     )
-                    analyze_button = gr.Button("Analyze & Break Down", variant="secondary")
-                
+
                 # Common settings
                 api_key_input = gr.Textbox(
                     label="OpenAI API Key",
                     type="password",
                     placeholder="Enter your OpenAI API key",
                     value=os.getenv("OPENAI_API_KEY", ""),
-                    info="Your OpenAI API key starting with 'sk-'"
+                    info="Your OpenAI API key starting with 'sk-'",
                 )
-                
+
                 # Generation Button
                 generate_button = gr.Button("Generate Cards", variant="primary")
 
                 # Advanced Settings in Accordion
                 with gr.Accordion("Advanced Settings", open=False):
                     model_choice = gr.Dropdown(
-                        choices=[
-                            "gpt-4o-mini",
-                            "gpt-4o",
-                            "o1"
-                        ],
-                        value="gpt-4o-mini",
-                        label="Model Selection", 
-                        info="Select the AI model to use for generation"
+                        choices=["gpt-4.1-mini", "gpt-4.1"],
+                        value="gpt-4.1-mini",
+                        label="Model Selection",
+                        info="Select the AI model to use for generation",
                     )
-                    
+
                     # Add tooltip/description for models
                     model_info = gr.Markdown("""
                     **Model Information:**
-                    - **gpt-4o-mini**: Fastest option, good for most use cases
-                    - **gpt-4o**: Better quality, takes longer to generate
-                    - **o1**: Highest quality, longest generation time
+                    - **gpt-4.1-mini**: Fastest option, good for most use cases
+                    - **gpt-4.1**: Better quality, takes longer to generate
                     """)
-                    
+
                     topic_number = gr.Slider(
                         label="Number of Topics",
                         minimum=2,
@@ -1110,6 +1153,11 @@ with gr.Blocks(
                         info="Customize how the content is presented",
                         lines=3,
                     )
+                    generate_cloze_checkbox = gr.Checkbox(
+                        label="Generate Cloze Cards (Experimental)",
+                        value=False,
+                        info="Allow the AI to generate fill-in-the-blank style cards where appropriate.",
+                    )
 
             # Right column - add a new container for learning path results
             with gr.Column(scale=2):
@@ -1118,32 +1166,33 @@ with gr.Blocks(
                     subjects_list = gr.Dataframe(
                         headers=["Subject", "Prerequisites", "Time Estimate"],
                         label="Recommended Subjects",
-                        interactive=False
+                        interactive=False,
                     )
                     learning_order = gr.Markdown("### Recommended Learning Order")
                     projects = gr.Markdown("### Suggested Projects")
-                    
+
                     # Replace generate_selected with use_subjects
                     use_subjects = gr.Button(
                         "Use These Subjects ℹ️",  # Added info emoji to button text
-                        variant="primary"
+                        variant="primary",
                     )
                     gr.Markdown(
                         "*Click to copy subjects to main input for card generation*",
-                        elem_classes="hint-text"
+                        elem_classes="hint-text",
                     )
-                
+
                 # Existing output components
                 with gr.Group() as cards_output:
                     gr.Markdown("### Generated Cards")
-                    
+
                     # Output Format Documentation
-                    with gr.Accordion("Output Format", open=True):
+                    with gr.Accordion("Output Format", open=False):
                         gr.Markdown("""
                         The generated cards include:
                         
                         * **Index**: Unique identifier for each card
                         * **Topic**: The specific subtopic within your subject
+                        * **Card_Type**: Type of card (basic or cloze)
                         * **Question**: Clear, focused question for the flashcard front
                         * **Answer**: Concise core answer
                         * **Explanation**: Detailed conceptual explanation
@@ -1162,7 +1211,7 @@ with gr.Blocks(
                         with gr.Accordion("Example Card Format", open=False):
                             gr.Code(
                                 label="Example Card",
-                                value='''
+                                value="""
 {
     "front": {
         "question": "What is a PRIMARY KEY constraint in SQL?"
@@ -1182,15 +1231,17 @@ with gr.Blocks(
         "difficulty": "beginner"
     }
 }
-                                ''',
-                                language="json"
+                                """,
+                                language="json",
                             )
-                    
+
                     # Dataframe Output
                     output = gr.Dataframe(
+                        value=example_data,
                         headers=[
                             "Index",
                             "Topic",
+                            "Card_Type",
                             "Question",
                             "Answer",
                             "Explanation",
@@ -1198,41 +1249,68 @@ with gr.Blocks(
                             "Prerequisites",
                             "Learning_Outcomes",
                             "Common_Misconceptions",
-                            "Difficulty"
+                            "Difficulty",
                         ],
                         interactive=True,
                         elem_classes="tall-dataframe",
                         wrap=True,
-                        column_widths=[50, 100, 200, 200, 250, 200, 150, 150, 150, 100],
+                        column_widths=[
+                            50,
+                            100,
+                            80,
+                            200,
+                            200,
+                            250,
+                            200,
+                            150,
+                            150,
+                            150,
+                            100,
+                        ],
                     )
 
                     # Export Controls
-                    with gr.Row():
-                        with gr.Column():
-                            gr.Markdown("### Export Options")
-                            with gr.Row():
-                                export_csv_button = gr.Button("Export to CSV", variant="secondary")
-                                export_anki_button = gr.Button("Export to Anki Deck", variant="secondary")
-                            download_csv = gr.File(label="Download CSV", interactive=False, visible=False)
-                            download_anki = gr.File(label="Download Anki Deck", interactive=False, visible=False)
+                    with gr.Group(elem_classes="export-group"):
+                        gr.Markdown("#### Export Generated Cards")
+                        with gr.Row():
+                            export_csv_button = gr.Button(
+                                "Export to CSV", variant="secondary"
+                            )
+                            export_anki_button = gr.Button(
+                                "Export to Anki Deck (.apkg)", variant="secondary"
+                            )
+                        # Re-wrap File components in an invisible Row
+                        with gr.Row(visible=False):
+                            download_csv = gr.File(
+                                label="Download CSV", interactive=False, visible=False
+                            )
+                            download_anki = gr.File(
+                                label="Download Anki Deck",
+                                interactive=False,
+                                visible=False,
+                            )
 
         # Add near the top of the Blocks
         with gr.Row():
             progress = gr.HTML(visible=False)
-            total_cards = gr.Number(label="Total Cards Generated", value=0, visible=False)
+            total_cards = gr.Number(
+                label="Total Cards Generated", value=0, visible=False
+            )
 
         # Add JavaScript to handle mode switching
         def update_mode_visibility(mode):
             """Update component visibility based on selected mode and clear values"""
-            is_subject = (mode == "subject")
-            is_path = (mode == "path")
-            
+            is_subject = mode == "subject"
+            is_path = mode == "path"
+
             # Clear values when switching modes
             if is_path:
                 subject.value = ""  # Clear subject when switching to path mode
             else:
-                description.value = ""  # Clear description when switching to subject mode
-            
+                description.value = (
+                    ""  # Clear description when switching to subject mode
+                )
+
             return {
                 subject_mode: gr.update(visible=is_subject),
                 path_mode: gr.update(visible=is_path),
@@ -1242,7 +1320,7 @@ with gr.Blocks(
                 description: gr.update(value="") if not is_path else gr.update(),
                 output: gr.update(value=None),  # Clear previous output
                 progress: gr.update(value="", visible=False),
-                total_cards: gr.update(value=0, visible=False)
+                total_cards: gr.update(value=0, visible=False),
             }
 
         # Update the mode switching handler to include all components that need clearing
@@ -1258,60 +1336,70 @@ with gr.Blocks(
                 description,
                 output,
                 progress,
-                total_cards
-            ]
+                total_cards,
+            ],
         )
-        
+
         # Add handler for path analysis
         analyze_button.click(
             fn=analyze_learning_path,
             inputs=[api_key_input, description, model_choice],
-            outputs=[subjects_list, learning_order, projects]
+            outputs=[subjects_list, learning_order, projects],
         )
-        
+
         # Add this function to handle copying subjects to main input
-        def use_selected_subjects(subjects_df, topic_number):
+        def use_selected_subjects(subjects_df):
             """Copy selected subjects to main input and switch to subject mode"""
             if subjects_df is None or subjects_df.empty:
-                raise gr.Error("No subjects available to copy")
-            
-            # Get all subjects and join them
+                gr.Warning("No subjects available to copy from Learning Path analysis.")
+                # Return updates for all relevant output components to avoid errors
+                return (
+                    gr.update(),
+                    gr.update(),
+                    gr.update(),
+                    gr.update(),
+                    gr.update(),
+                    gr.update(),
+                    gr.update(),
+                    gr.update(),
+                    gr.update(),
+                )
+
             subjects = subjects_df["Subject"].tolist()
             combined_subject = ", ".join(subjects)
-            
-            # Calculate reasonable number of topics based on number of subjects
-            suggested_topics = min(len(subjects) + 2, 20)  # Add 2 for related concepts, cap at 20
-            
-            # Return updates for individual components instead of groups
+            suggested_topics = min(
+                len(subjects) + 1, 20
+            )  # Suggest topics = num subjects + 1
+
+            # Return updates for relevant components
             return (
-                "subject",                # generation_mode value
-                gr.update(visible=True),  # subject textbox visibility
-                gr.update(visible=False), # description textbox visibility
-                gr.update(visible=False), # subjects_list visibility
-                gr.update(visible=False), # learning_order visibility
-                gr.update(visible=False), # projects visibility
-                gr.update(visible=True),  # output visibility
-                combined_subject,         # subject value
-                suggested_topics,         # topic_number value
-                "Focus on connections between these subjects and their practical applications"  # preference_prompt
+                "subject",  # Set mode to subject
+                gr.update(visible=True),  # Show subject_mode group
+                gr.update(visible=False),  # Hide path_mode group
+                gr.update(visible=False),  # Hide path_results group
+                gr.update(visible=True),  # Show cards_output group
+                combined_subject,  # Update subject textbox value
+                suggested_topics,  # Update topic_number slider value
+                # Update preference prompt
+                "Focus on connections between these subjects and their practical applications.",
+                example_data,  # Reset output to example data - THIS NOW WORKS
             )
 
-        # Update the click handler to match the new outputs
+        # Correct the outputs for the use_subjects click handler
         use_subjects.click(
             fn=use_selected_subjects,
-            inputs=[subjects_list, topic_number],
-            outputs=[
+            inputs=[subjects_list],  # Only needs the dataframe
+            outputs=[  # Match the return tuple of the function
                 generation_mode,
-                subject,           # Individual components instead of groups
-                description,
-                subjects_list,
-                learning_order,
-                projects,
-                output,
-                subject,
-                topic_number,
-                preference_prompt
-            ]
+                subject_mode,  # Group visibility
+                path_mode,  # Group visibility
+                path_results,  # Group visibility
+                cards_output,  # Group visibility
+                subject,  # Component value
+                topic_number,  # Component value
+                preference_prompt,  # Component value
+                output,  # Component value
+            ],
         )
 
         # Simplified event handlers
@@ -1320,13 +1408,14 @@ with gr.Blocks(
             inputs=[
                 api_key_input,
                 subject,
-                model_choice,  # Add model selection
+                model_choice,
                 topic_number,
                 cards_per_topic,
                 preference_prompt,
+                generate_cloze_checkbox,
             ],
             outputs=[output, progress, total_cards],
-            show_progress=True,
+            show_progress="full",
         )
 
         export_csv_button.click(

pyproject.toml

@@ -4,22 +4,23 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ankigen"
-version = "0.1.0"
+version = "0.2.0"
 description = ""
 authors = [
-    {name = "Justin", email = "9146678+brickfrog@users.noreply.github.com"}
+    { 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",
+    "tenacity>=9.1.2",
+    "genanki>=0.13.1",
+    "pydantic==2.10.6",
 ]
 
 [project.optional-dependencies]
-dev = [
-    "ipykernel>=6.29.5",
-]
+dev = ["ipykernel>=6.29.5"]
 
 [tool.setuptools]
-py-modules = ["app"]
+py-modules = ["app"]

requirements.txt

@@ -1,5 +1,60 @@
-gradio
-openai
-tenacity>=8.2.3
-genanki>=0.13.0
-pandas>=2.0.0
+aiofiles==23.2.1
+-e file:///home/justin/Documents/Code/ankigen
+annotated-types==0.7.0
+anyio==4.9.0
+cached-property==2.0.1
+certifi==2025.1.31
+charset-normalizer==3.4.1
+chevron==0.14.0
+click==8.1.8
+distro==1.9.0
+fastapi==0.115.12
+ffmpy==0.5.0
+filelock==3.18.0
+frozendict==2.4.6
+fsspec==2025.3.2
+genanki==0.13.1
+gradio==5.3.0
+gradio-client==1.4.2
+h11==0.14.0
+httpcore==1.0.8
+httpx==0.28.1
+huggingface-hub==0.30.2
+idna==3.10
+jinja2==3.1.6
+jiter==0.9.0
+markdown-it-py==3.0.0
+markupsafe==2.1.5
+mdurl==0.1.2
+numpy==2.2.4
+openai==1.75.0
+orjson==3.10.16
+packaging==24.2
+pandas==2.2.3
+pillow==10.4.0
+pydantic==2.10.6
+pydantic-core==2.27.2
+pydub==0.25.1
+pygments==2.19.1
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pytz==2025.2
+pyyaml==6.0.2
+requests==2.32.3
+rich==14.0.0
+ruff==0.11.6
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+starlette==0.46.2
+tenacity==9.1.2
+tomlkit==0.12.0
+tqdm==4.67.1
+typer==0.15.2
+typing-extensions==4.13.2
+typing-inspection==0.4.0
+tzdata==2025.2
+urllib3==2.4.0
+uvicorn==0.34.1
+websockets==12.0