import flet as ft
import json
import requests
import yaml
import os
import csv
import logging
from typing import Dict, List, Any
from result import Ok
# Set up logging
logging.basicConfig(
level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger("flashcard-creator")
class FlashcardCreator:
def __init__(self):
# Anki configuration
from anki import AnkiConnect
self.anki = AnkiConnect()
# File picker
self.file_picker = ft.FilePicker()
# LiteLLM configuration
self.llm_provider = "openai"
self.llm_model = "gpt-3.5-turbo"
self.base_url = ""
self.api_key = ""
self.load_settings()
# Languages
self.source_language = "English"
self.target_language = "German"
self.languages = [
"English",
"German",
"French",
"Spanish",
"Italian",
"Chinese",
"Japanese",
"Russian",
]
# Flashcards
self.flashcards = {}
def load_settings(self):
settings_path = os.path.join(
os.path.expanduser("~"), ".flashcard_creator", "settings.json"
)
settings = {}
if os.path.exists(settings_path):
with open(settings_path, "r") as f:
try:
settings = json.load(f)
print(settings)
self.llm_provider = settings.get("provider", self.llm_provider)
self.llm_model = settings.get("model", self.llm_model)
self.base_url = settings.get("base_url", self.base_url)
# Load provider-specific settings
provider_settings = settings.get(self.llm_provider, {})
self.llm_model = provider_settings.get("model", self.llm_model)
self.base_url = provider_settings.get("base_url", self.base_url)
self.api_key = provider_settings.get("api_key", self.api_key)
except:
pass
def build_ui(self, page: ft.Page):
page.title = "Flashcard Creator"
page.theme_mode = ft.ThemeMode.LIGHT
# Language selection dropdowns
self.source_dropdown = ft.Dropdown(
label="Source Language",
options=[ft.dropdown.Option(lang) for lang in self.languages],
value=self.source_language,
width=200,
on_change=self.on_source_language_change,
)
self.target_dropdown = ft.Dropdown(
label="Target Language",
options=[ft.dropdown.Option(lang) for lang in self.languages],
value=self.target_language,
width=200,
on_change=self.on_target_language_change,
)
# Text input for content to process
self.input_text = ft.TextField(
label="Input Text", multiline=True, min_lines=5, max_lines=15, width=600
)
# Process button
self.process_button = ft.ElevatedButton(
text="Process Text", on_click=self.on_process_text
)
# Settings button
self.settings_button = ft.ElevatedButton(
text="Settings", on_click=self.open_settings
)
# Stack name and description
self.stack_name = ft.TextField(label="Stack Name", width=300)
self.stack_description = ft.TextField(
label="Stack Description",
multiline=True,
min_lines=2,
max_lines=4,
width=600,
)
# Action buttons
self.add_to_anki_button = ft.ElevatedButton(
text="Add to Anki", on_click=self.add_to_anki
)
self.export_yaml_button = ft.ElevatedButton(
text="Export as YAML", on_click=self.export_as_yaml
)
self.export_csv_button = ft.ElevatedButton(
text="Export as CSV", on_click=self.export_as_csv
)
# Flashcard data table - make it expand to fill available width
self.flashcard_table = ft.DataTable(
columns=[
ft.DataColumn(ft.Text("Front")),
ft.DataColumn(ft.Text("Back")),
ft.DataColumn(ft.Text("Actions")),
],
rows=[],
expand=True, # Make table expand to fill available width
column_spacing=10, # Space between columns
horizontal_lines=ft.border.BorderSide(1, ft.colors.OUTLINE),
vertical_lines=ft.border.BorderSide(1, ft.colors.OUTLINE),
width=page.width, # Make table as wide as the window
)
# Wrap the table in a Container with specific height to ensure visibility
flashcard_table_container = ft.Container(
content=ft.Column(
expand=True,
controls=[self.flashcard_table],
scroll=ft.ScrollMode.ALWAYS,
),
padding=10,
expand=True,
# height=400,
border=ft.border.all(1, ft.colors.OUTLINE),
border_radius=5,
width=page.width,
)
# Add file picker to page overlay
page.overlay.append(self.file_picker)
# Create a scrollable column for the main content
main_content = ft.Column(
[
ft.Row(
[self.source_dropdown, self.target_dropdown, self.settings_button]
),
ft.Divider(),
ft.Text("Input Text", size=16, weight=ft.FontWeight.BOLD),
self.input_text,
self.process_button,
ft.Divider(),
ft.Text("Flashcard Information", size=16, weight=ft.FontWeight.BOLD),
self.stack_name,
self.stack_description,
ft.Divider(),
ft.Text("Generated Flashcards", size=16, weight=ft.FontWeight.BOLD),
flashcard_table_container,
ft.Row(
[
self.add_to_anki_button,
self.export_yaml_button,
self.export_csv_button,
]
),
],
scroll=ft.ScrollMode.AUTO,
expand=True,
)
# Add the scrollable content to the page
page.add(main_content)
def on_source_language_change(self, e):
self.source_language = e.control.value
def on_target_language_change(self, e):
self.target_language = e.control.value
def open_settings(self, e):
print("opening settings..")
self.load_settings()
# Create a settings dialog
def close_dialog_save(e):
self.llm_provider = provider_dropdown.value
self.llm_model = model_input.value
self.api_key = api_key_input.value
self.base_url = base_url_input.value
# Save settings to local storage
settings_dir = os.path.join(os.path.expanduser("~"), ".flashcard_creator")
os.makedirs(settings_dir, exist_ok=True)
settings_path = os.path.join(settings_dir, "settings.json")
settings = {}
if os.path.exists(settings_path):
try:
with open(settings_path, "r") as f:
settings = json.load(f)
except:
pass
# Update provider-specific settings
settings[self.llm_provider] = {
"model": self.llm_model,
"base_url": self.base_url,
"api_key": self.api_key,
}
with open(settings_path, "w") as f:
json.dump(settings, f, indent=4)
e.page.close(dialog)
e.page.update()
# Load settings if they exist
settings_path = os.path.join(
os.path.expanduser("~"), ".flashcard_creator", "settings.json"
)
settings = {}
if os.path.exists(settings_path):
with open(settings_path, "r") as f:
try:
settings = json.load(f)
print(settings)
self.llm_provider = settings.get("provider", self.llm_provider)
# Load provider-specific settings
provider_settings = settings.get(self.llm_provider, {})
self.llm_model = provider_settings.get("model", self.llm_model)
self.base_url = provider_settings.get("base_url", self.base_url)
self.api_key = provider_settings.get("api_key", self.api_key)
except:
pass
provider_dropdown = ft.Dropdown(
label="LLM Provider",
options=[
ft.dropdown.Option("openai"),
ft.dropdown.Option("anthropic"),
ft.dropdown.Option("vertexai"),
ft.dropdown.Option("huggingface"),
ft.dropdown.Option("deepseek"),
],
value=self.llm_provider,
)
model_input = ft.TextField(label="Model Name", value=self.llm_model)
base_url_input = ft.TextField(label="Base URL (optional)", value=self.base_url)
api_key_input = ft.TextField(label="API Key", value=self.api_key, password=True)
dialog = ft.AlertDialog(
title=ft.Text("Settings"),
content=ft.Column(
[provider_dropdown, model_input, base_url_input, api_key_input],
width=400,
height=400,
),
actions=[
ft.TextButton("Cancel", on_click=lambda e: e.page.close(dialog)),
ft.TextButton("Save", on_click=close_dialog_save),
],
)
e.page.open(dialog)
# e.page.dialog = dialog
# dialog.open = True
e.page.update()
def on_process_text(self, e):
input_text = self.input_text.value
if not input_text:
e.page.open(
ft.SnackBar(content=ft.Text("Please enter some text to process"))
)
return
logger.info("Processing input text")
# Use LiteLLM to process the text and generate flashcards
flashcards = self.generate_flashcards(input_text, e.page)
# Update the data table with the generated flashcards
self.update_flashcard_table(flashcards, e.page)
def generate_flashcards(self, text: str, page: ft.Page = None) -> Dict:
"""Use LiteLLM to generate flashcards from the input text."""
from litellm import completion
# Show progress bar
progress = None
if page:
progress = ft.ProgressBar(width=600)
page.add(
ft.Column([ft.Text("Generating flashcards...", size=16), progress])
)
page.update()
logger.info(
f"Generating flashcards: {self.source_language} -> {self.target_language}"
)
logger.info(f"Using model: {self.llm_provider}/{self.llm_model}")
prompt = f"""You are a language learning assistant creating flashcards to help students learn {self.target_language} from {self.source_language}.
TASK: Create effective flashcards from the provided text.
INSTRUCTIONS:
1. Extract important vocabulary, phrases, and concepts from the text
2. Create flashcards with {self.source_language} on the front and {self.target_language} on the back
3. For vocabulary words:
- Include articles for nouns (e.g., "der/die/das" in German)
- Include plural forms where appropriate
- Include gender information for languages that have grammatical gender
4. For verbs, include the infinitive form and note if irregular
5. For idiomatic expressions, provide the closest equivalent in the target language
6. Choose content that represents different difficulty levels
7. Ensure translations are accurate and natural-sounding in the target language
8. Make sure to create flashcards for ALL relevant words in the input! If you are unsure, err on the side of too many flashcards.
OUTPUT FORMAT:
Return your response in valid YAML format with the following structure:
```yaml
name: [Create a concise, descriptive name for this flashcard set]
description: [Write a brief description of the content covered]
cards:
- "[source term 1]": "[target translation 1]"
- "[source term 2]": "[target translation 2]"
- "[source phrase]": "[target translation with grammatical notes if needed]"
```
For example, for Chinese -> German, based on some vocab text including the following words,
your output could look like this:
```yaml
name: Basic Chinese to German Vocabulary
description: Essential vocabulary and phrases translated from Chinese to German
cards:
- "你好": "Hallo"
- "谢谢": "Danke"
- "再见": "Auf Wiedersehen"
- "苹果": "der Apfel (pl. die Äpfel)"
- "书": "das Buch (pl. die Bücher)"
- "学生": "der/die Student/Studentin (pl. die Studenten/Studentinnen)"
- "喝水": "Wasser trinken (verb, regular)"
- "吃饭": "essen (verb, irregular: isst, aß, gegessen)"
- "我很高兴认识你": "Es freut mich, dich kennenzulernen"
- "慢走": "Komm gut nach Hause (idiom.)"
```
Here's the text to process:
{text}
"""
try:
# Set the API key for the selected provider
# Load provider-specific settings
settings_path = os.path.join(
os.path.expanduser("~"), ".flashcard_creator", "settings.json"
)
settings = {}
if os.path.exists(settings_path):
with open(settings_path, "r") as f:
try:
settings = json.load(f)
except:
pass
provider_settings = settings.get(self.llm_provider, {})
api_key = provider_settings.get("api_key", "")
os.environ[f"{self.llm_provider.upper()}_API_KEY"] = api_key
logger.info("Sending request to LLM API...")
# Use LiteLLM to generate flashcards
response = completion(
model=f"{self.llm_provider}/{self.llm_model}",
api_base=self.base_url if self.base_url else None,
messages=[{"role": "user", "content": prompt}],
)
logger.info("Received response from LLM API")
# Extract the YAML content from the response
yaml_content = response.choices[0].message.content
logger.info("Extracting YAML content from response")
# Extract YAML content from code blocks if present
if "```yaml" in yaml_content:
# Extract content between yaml and the next
yaml_content = (
yaml_content.split("```yaml", 1)[1].split("```")[0].strip()
)
elif "```" in yaml_content:
# Try to extract content between any
yaml_blocks = yaml_content.split("```")
if len(yaml_blocks) >= 3: # At least one complete code block
yaml_content = yaml_blocks[1].strip()
# Parse the YAML content
logger.info("Parsing YAML content")
flashcards = yaml.safe_load(yaml_content)
logger.info(
f"Generated {len(flashcards.get('cards', []))} flashcards successfully"
)
return flashcards
except Exception as e:
logger.error(f"Error generating flashcards: {e}", exc_info=True)
return {"name": "", "description": "", "cards": []}
finally:
# Remove progress bar
if page and progress:
page.controls.pop()
page.update()
def update_flashcard_table(self, flashcards: Dict, page: ft.Page):
"""Update the flashcard table with the generated flashcards."""
self.flashcards = flashcards
# Set the stack name and description
self.stack_name.value = flashcards.get("name", "")
self.stack_description.value = flashcards.get("description", "")
# Clear the existing rows
self.flashcard_table.rows.clear()
# Add a row for each flashcard
for card in flashcards.get("cards", []):
if isinstance(card, dict):
for front, back in card.items():
self.add_row_to_table(front, back)
else:
# Handle case where card is a string with format "front: back"
if ": " in card:
front, back = card.split(": ", 1)
self.add_row_to_table(front, back)
# Add a row for adding new flashcards
self.add_new_card_row()
# Update the page
page.update()
def add_row_to_table(self, front, back):
"""Add a row to the flashcard table."""
# Calculate width to make text fields take approximately 40% of screen width each
text_field_width = 400 # Adjust this value based on typical screen width
front_field = ft.TextField(
value=front,
width=text_field_width,
multiline=True, # Allow multiple lines for longer text
min_lines=1,
max_lines=3,
)
back_field = ft.TextField(
value=back,
width=text_field_width,
multiline=True, # Allow multiple lines for longer text
min_lines=1,
max_lines=3,
)
delete_button = ft.IconButton(
icon=ft.icons.DELETE,
on_click=lambda e, f=front_field, b=back_field: self.delete_flashcard(
e, f, b
),
)
self.flashcard_table.rows.append(
ft.DataRow(
cells=[
ft.DataCell(front_field),
ft.DataCell(back_field),
ft.DataCell(delete_button),
]
)
)
def add_new_card_row(self):
"""Add a row for adding new flashcards."""
# Calculate width to make text fields take approximately 40% of screen width each
text_field_width = 400 # Adjust this value based on typical screen width
new_front_field = ft.TextField(
hint_text="New Front",
width=text_field_width,
multiline=True,
min_lines=1,
max_lines=3,
)
new_back_field = ft.TextField(
hint_text="New Back",
width=text_field_width,
multiline=True,
min_lines=1,
max_lines=3,
)
add_button = ft.IconButton(
icon=ft.icons.ADD,
on_click=lambda e: self.add_flashcard(e, new_front_field, new_back_field),
)
self.flashcard_table.rows.append(
ft.DataRow(
cells=[
ft.DataCell(new_front_field),
ft.DataCell(new_back_field),
ft.DataCell(add_button),
]
)
)
def delete_flashcard(self, e, front_field, back_field):
"""Delete a flashcard from the table."""
for i, row in enumerate(self.flashcard_table.rows):
if (
row.cells[0].content == front_field
and row.cells[1].content == back_field
):
self.flashcard_table.rows.pop(i)
e.page.update()
return
def add_flashcard(self, e, front_field, back_field):
"""Add a new flashcard to the table."""
if not front_field.value or not back_field.value:
e.page.open(
ft.SnackBar(content=ft.Text("Please enter both front and back values"))
)
e.page.update()
return
# Add a new row with the entered values
self.add_row_to_table(front_field.value, back_field.value)
# Clear the input fields
front_field.value = ""
back_field.value = ""
# Update the page
e.page.update()
def add_to_anki(self, e):
"""Add the flashcards to Anki using AnkiConnect."""
# Collect the flashcards from the table
cards = []
for row in self.flashcard_table.rows[:-1]: # Exclude the last row (add row)
front = row.cells[0].content.value
back = row.cells[1].content.value
if front and back:
cards.append({"front": front, "back": back})
if not cards:
e.page.open(ft.SnackBar(content=ft.Text("No flashcards to add")))
return
# Create a dialog for selecting the Anki deck
decks = self.get_anki_decks()
if not decks:
e.page.open(
ft.SnackBar(
content=ft.Text("Failed to connect to Anki or no decks found")
)
)
e.page.snack_bar.open = True
e.page.update()
return
deck_dropdown = ft.Dropdown(
label="Select Deck",
options=[ft.dropdown.Option(deck) for deck in decks],
width=300,
)
def add_cards(e):
selected_deck = deck_dropdown.value
if not selected_deck:
e.page.open(ft.SnackBar(content=ft.Text("Please select a deck")))
return
success = self.create_anki_cards(selected_deck, cards)
e.page.close(dialog)
e.page.update()
if success:
e.page.open(
ft.SnackBar(
content=ft.Text(
f"Added {len(cards)} flashcards to {selected_deck}"
)
)
)
else:
e.page.open(
ft.SnackBar(content=ft.Text("Failed to add flashcards to Anki"))
)
dialog = ft.AlertDialog(
title=ft.Text("Add to Anki"),
content=ft.Column([deck_dropdown], width=400, height=100),
actions=[
ft.TextButton(
"Cancel", on_click=lambda e: setattr(dialog, "open", False)
),
ft.TextButton("Add", on_click=add_cards),
],
)
e.page.open(dialog)
e.page.update()
def get_anki_decks(self) -> List[str]:
"""Get the list of decks from Anki using AnkiConnect."""
result = self.anki.get_decks()
if isinstance(result, Ok):
return result.value
else:
logger.error(f"Error getting Anki decks: {result.value}")
return []
def create_anki_cards(self, deck: str, cards: List[Dict[str, str]]) -> bool:
"""Create flashcards in Anki using Anki-connect."""
result = self.anki.create_cards(deck, cards)
if isinstance(result, Ok):
return result.value
else:
logger.error(f"Error creating Anki cards: {result.value}")
return False
def export_as_yaml(self, e):
"""Export the flashcards as a YAML file."""
# Collect the flashcards from the table
cards = []
for row in self.flashcard_table.rows[:-1]: # Exclude the last row (add row)
front = row.cells[0].content.value
back = row.cells[1].content.value
if front and back:
cards.append({front: back})
if not cards:
e.page.open(ft.SnackBar(content=ft.Text("No flashcards to export")))
return
# Create the YAML content
yaml_content = {
"name": self.stack_name.value,
"description": self.stack_description.value,
"cards": cards,
}
# Create a file picker
def save_file(e: ft.FilePickerResultEvent):
if e.path:
try:
with open(e.path, "w", encoding="utf-8") as f:
yaml.dump(yaml_content, f, allow_unicode=True)
e.page.open(ft.SnackBar(content=ft.Text(f"Saved to {e.path}")))
except Exception as ex:
e.page.open(
ft.SnackBar(content=ft.Text(f"Error saving file: {ex}"))
)
self.file_picker.on_result = save_file
e.page.update()
self.file_picker.save_file(
file_name=f"{self.stack_name.value or 'flashcards'}.yaml",
file_type=ft.FilePickerFileType.CUSTOM,
allowed_extensions=["yaml"],
)
def export_as_csv(self, e):
"""Export the flashcards as a CSV file."""
# Collect the flashcards from the table
cards = []
for row in self.flashcard_table.rows[:-1]: # Exclude the last row (add row)
front = row.cells[0].content.value
back = row.cells[1].content.value
if front and back:
cards.append([front, back])
if not cards:
e.page.open(ft.SnackBar(content=ft.Text("No flashcards to export")))
return
# Create a file picker
def save_file(e: ft.FilePickerResultEvent):
if e.path:
try:
with open(e.path, "w", encoding="utf-8", newline="") as f:
writer = csv.writer(f)
writer.writerow(["Front", "Back"])
writer.writerows(cards)
e.page.open(ft.SnackBar(content=ft.Text(f"Saved to {e.path}")))
except Exception as ex:
e.page.open(
ft.SnackBar(content=ft.Text(f"Error saving file: {ex}"))
)
self.file_picker.on_result = save_file
e.page.update()
self.file_picker.save_file(
file_name=f"{self.stack_name.value or 'flashcards'}.csv",
file_type=ft.FilePickerFileType.CUSTOM,
allowed_extensions=["csv"],
)
def main(page: ft.Page):
app = FlashcardCreator()
app.build_ui(page)
if __name__ == "__main__":
ft.app(target=main)