initial commit

README.md

@@ -10,5 +10,4 @@ pinned: false
 license: mit
 short_description: A AI powered Anki card generator
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# agent-demo-track

agent.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import base64
+import mimetypes
+import os
+import re
+import tempfile
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import requests
+from langgraph.graph import StateGraph, START, END
+from typing_extensions import TypedDict
+
+import anthropic
+import dotenv
+# Load environment variables from .env file
+dotenv.load_dotenv()
+
+# ----------------------------------------------------------------------------
+# 1. State definition
+# ----------------------------------------------------------------------------
+
+class AnkiGeneratorState(TypedDict, total=False):
+    user_requirements: str           # Extra user instructions / tags
+    card_types: str                 # Allowed card types (string)
+
+    # Exactly one of the following
+    pdf_file: Optional[Path]
+    img_file: Optional[Path]
+    url: Optional[str]
+
+    input_type: str                 # "pdf" | "image" | "url"
+
+    # Internal artifacts
+    model_response: str
+    result: Dict[str, Any]
+
+
+# ----------------------------------------------------------------------------
+# 2. Helpers
+# ----------------------------------------------------------------------------
+
+ANTHROPIC_MODEL = "claude-opus-4-20250514"
+client = anthropic.Anthropic()
+
+
+def _file_to_b64(p: Path) -> str:
+    return base64.b64encode(p.read_bytes()).decode()
+
+
+def _url_fetch(url: str, timeout: int = 15) -> tuple[str, bytes]:
+    r = requests.get(url, timeout=timeout)
+    r.raise_for_status()
+    mime = r.headers.get("content-type", "application/octet-stream").split(";")[0]
+    return mime, r.content
+
+
+def _join_text(msg) -> str:
+    if isinstance(msg.content, list):
+        return "\n".join(part.get("text", "") for part in msg.content if part.get("type") == "text")
+    return str(msg.content)
+
+
+def _extract_xml(text: str) -> str:
+    m = re.search(r"<anki_cards[\s\S]*?</anki_cards>", text, re.I)
+    if not m:
+        raise ValueError("LLM output missing <anki_cards> block")
+    return m.group()
+
+
+def _parse_cards(xml_str: str) -> list[dict]:
+    root = ET.fromstring(xml_str)
+    cards = []
+    for card in root.findall("card"):
+        cards.append({
+            "type": (card.findtext("type") or "").strip(),
+            "front": (card.findtext("front") or "").strip(),
+            "back": (card.findtext("back") or "").strip(),
+        })
+    return cards
+
+
+def _prompt(src_kind: str, state: AnkiGeneratorState) -> str:
+    return (
+        f"""You are an AI assistant tasked with generating Anki cards from a {src_kind}. 
+        Follow these rules:\n"
+        1. Read the provided content.\n"
+        2. Allowed card types: {state.get("card_types", "")}\n
+        3. User notes:  {state.get("user_requirements", "")}\n
+        4. output your response as an XML block with <anki_cards> root element.\n"""
+    )
+
+# ----------------------------------------------------------------------------
+# 3. Node implementations
+# ----------------------------------------------------------------------------
+
+def get_input_type(state: AnkiGeneratorState) -> AnkiGeneratorState:
+    if state.get("pdf_file"):
+        state["input_type"] = "pdf"
+    elif state.get("img_file"):
+        state["input_type"] = "image"
+    elif state.get("url"):
+        state["input_type"] = "url"
+    else:
+        raise ValueError("Must supply pdf_file, img_file or url")
+    return state
+
+
+def process_pdf(state: AnkiGeneratorState) -> AnkiGeneratorState:
+    pdf_b64 = _file_to_b64(state["pdf_file"])
+    message = client.messages.create(
+        model=ANTHROPIC_MODEL,
+        max_tokens=2048,
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "document",
+                        "source": {
+                            "type": "base64",
+                            "media_type": "application/pdf",
+                            "data": pdf_b64,
+                        },
+                    },
+                    {"type": "text", "text": _prompt("PDF", state)},
+                ],
+            }
+        ],
+    )
+    state["model_response"] = message.content[0].text
+    return state
+
+
+def process_image(state: AnkiGeneratorState) -> AnkiGeneratorState:
+    img_b64 = _file_to_b64(state["img_file"])
+    mime = mimetypes.guess_type(state["img_file"])[0] or "image/png"
+    message = client.messages.create(
+        model=ANTHROPIC_MODEL,
+        max_tokens=2048,
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "image",
+                        "source": {"type": "base64", "media_type": mime, "data": img_b64},
+                    },
+                    {"type": "text", "text": _prompt("image", state)},
+                ],
+            }
+        ],
+    )
+    state["model_response"] = message.content[0].text
+    return state
+
+
+def process_url(state: AnkiGeneratorState) -> AnkiGeneratorState:
+    mime, raw = _url_fetch(state["url"])
+    if mime == "application/pdf" or state["url"].lower().endswith(".pdf"):
+        tmp = Path(tempfile.mkstemp(suffix=".pdf")[1])
+        tmp.write_bytes(raw)
+        state["pdf_file"] = tmp
+        return process_pdf(state)
+    if mime.startswith("image/"):
+        ext = mimetypes.guess_extension(mime) or ".png"
+        tmp = Path(tempfile.mkstemp(suffix=ext)[1])
+        tmp.write_bytes(raw)
+        state["img_file"] = tmp
+        return process_image(state)
+    text = raw.decode("utf-8", errors="ignore")[:15000]
+    message = client.messages.create(
+        model=ANTHROPIC_MODEL,
+        max_tokens=1024,
+        messages=[
+            {"role": "user", "content": [{"type": "text", "text": text}, {"type": "text", "text": _prompt("webpage", state)}]},
+        ],
+    )
+    state["model_response"] = message.content[0].text
+    return state
+
+
+def parse_and_generate(state: AnkiGeneratorState) -> AnkiGeneratorState:
+    print(state["model_response"])
+    xml_str = _extract_xml(state["model_response"])
+    cards = _parse_cards(xml_str)
+    if not cards:
+        raise ValueError("No cards extracted")
+    source = (
+        state.get("pdf_file") and state["pdf_file"].stem
+    ) or (
+        state.get("img_file") and state["img_file"].stem
+    ) or re.sub(r"\W+", "_", state.get("url", "source"))
+    state["result"] = {
+        "deck": {
+            "name": f"{source}_AnkiDeck",
+            "cards": cards,
+            "tags": [t.strip() for t in state.get("user_requirements", "").split(",") if t.strip()],
+        }
+    }
+    return state
+
+# ----------------------------------------------------------------------------
+# 4. Graph assembly
+# ----------------------------------------------------------------------------
+
+graph = StateGraph(AnkiGeneratorState)
+
+for n, fn in [
+    ("get_input_type", get_input_type),
+    ("process_pdf", process_pdf),
+    ("process_image", process_image),
+    ("process_url", process_url),
+    ("parse_and_generate", parse_and_generate),
+]:
+    graph.add_node(n, fn)
+
+# Conditional edges with single‑arg route func (current state only)
+graph.add_edge(START, "get_input_type")
+
+graph.add_conditional_edges(
+    "get_input_type",
+    lambda state: state["input_type"],
+    {"pdf": "process_pdf", "image": "process_image", "url": "process_url"},
+)
+
+for node in ["process_pdf", "process_image", "process_url"]:
+    graph.add_edge(node, "parse_and_generate")
+
+graph.add_edge("parse_and_generate", END)
+
+app_graph = graph.compile()
+
+# ----------------------------------------------------------------------------
+# 5. Public helper
+# ----------------------------------------------------------------------------
+
+def create_anki_deck(**kwargs) -> Dict[str, Any]:
+    state: AnkiGeneratorState = kwargs  # type: ignore
+    final = app_graph.invoke(state)
+    return final["result"]
+
+

app.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+import json
+import random
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+import gradio as gr
+from agent import create_anki_deck
+
+try:
+    import genanki  # type: ignore
+
+    GENANKI_AVAILABLE = True
+except ImportError:
+    GENANKI_AVAILABLE = False
+
+# ---------------------------------------------------------------------------
+# generate .apkg or JSON)
+# ---------------------------------------------------------------------------
+
+def _build_package_file(deck_dict: dict, deck_name_override: str | None = None) -> str:  # ← 返回 str
+    deck_title = (deck_name_override or deck_dict.get("name") or "AI_Deck").strip()
+
+    if GENANKI_AVAILABLE:
+        # ---------- generate .apkg ----------
+        import genanki
+        basic_model = genanki.Model(
+            1607392319,
+            "AI Basic Model",
+            fields=[{"name": "Front"}, {"name": "Back"}],
+            templates=[{
+                "name": "Card 1",
+                "qfmt": "{{Front}}",
+                "afmt": "{{FrontSide}}<hr id=answer>{{Back}}",
+            }],
+        )
+        cloze_model = genanki.Model(
+            1091735104,
+            "AI Cloze Model",
+            model_type=genanki.Model.CLOZE,
+            fields=[{"name": "Text"}, {"name": "Back"}],
+            templates=[{
+                "name": "Cloze Card",
+                "qfmt": "{{cloze:Text}}",
+                "afmt": "{{cloze:Text}}<br>{{Back}}",
+            }],
+        )
+        deck = genanki.Deck(random.getrandbits(32), deck_title)
+        tags = deck_dict.get("tags", [])
+        for card in deck_dict["cards"]:
+            model = cloze_model if card["type"].lower().startswith("cloze") else basic_model
+            note = genanki.Note(model=model, fields=[card["front"], card["back"]], tags=tags)
+            deck.add_note(note)
+        pkg = genanki.Package(deck)
+        tmpf = tempfile.NamedTemporaryFile(delete=False, suffix=".apkg")
+        pkg.write_to_file(tmpf.name)
+        return tmpf.name 
+
+    # ---------- generate JSON ----------
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".json", mode="w", encoding="utf-8") as tf:
+        json.dump(deck_dict, tf, ensure_ascii=False, indent=2)
+        return tf.name
+
+# ---------------------------------------------------------------------------
+# callback function to generate Anki deck
+# ---------------------------------------------------------------------------
+
+def generate_deck(
+    uploaded_path: Optional[str],
+    url_input: str,
+    card_type_pref: str,
+    deck_name_pref: str,
+    tags_pref: str,
+    user_req_pref: str,
+):
+    if not uploaded_path and not url_input.strip():
+        raise gr.Error("Please upload a file or enter a URL.")
+
+    params: dict[str, object] = {
+        "card_types": card_type_pref,
+        "user_requirements": user_req_pref,
+    }
+
+    if uploaded_path:
+        path = Path(uploaded_path)
+        params["pdf_file" if path.suffix.lower() == ".pdf" else "img_file"] = path
+    else:
+        params["url"] = url_input.strip()
+
+    # agent
+    deck_dict = create_anki_deck(**params)["deck"]
+
+    if deck_name_pref.strip():
+        deck_dict["name"] = deck_name_pref.strip()
+    if tags_pref.strip():
+        deck_dict["tags"] = [t.strip() for t in tags_pref.split(",") if t.strip()]
+
+    output_path = _build_package_file(deck_dict, deck_name_pref)
+    return str(output_path) 
+
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+
+demo = gr.Blocks(theme=gr.themes.Soft(), title="Anki Card Generator")
+
+with demo:
+    gr.Markdown("# 🧠 Anki Card Generator")
+    gr.Markdown("Upload an image or PDF, or enter a URL to generate Anki cards.")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            file_input = gr.File(label="📁 Upload PDF or image", file_types=["image", ".pdf"], type="filepath")
+            url_input = gr.Textbox(label="🌐 Or enter url", placeholder="https://example.com/article")
+            user_requirements_input = gr.Textbox(label="🎯 Your requirements", lines=4)
+            card_type_input = gr.Textbox(label="📇 Card type", value="Basic,Cloze")
+            deck_name_input = gr.Textbox(label="🏷️ Deck name", value="Animal")
+            tags_input = gr.Textbox(label="✨ Tags (comma-separated)", placeholder="e.g. biology, mammals", value="biology,mammals")
+            generate_button = gr.Button("Generate", variant="primary")
+
+        with gr.Column(scale=1):
+            anki_output_file = gr.File(label="📥 Download (.apkg / .json)")
+
+    generate_button.click(
+        fn=generate_deck,
+        inputs=[file_input, url_input, card_type_input, deck_name_input, tags_input, user_requirements_input],
+        outputs=[anki_output_file],
+    )
+
+    gr.Markdown("---")
+    gr.Markdown("✅ genanki :{}".format("Available" if GENANKI_AVAILABLE else "Not installed (will export JSON)"))
+
+if __name__ == "__main__":
+    demo.launch()