Upload folder using huggingface_hub

tests/__init__.py

@@ -1 +0,0 @@
-# This file marks tests as a Python package

tests/test_card_generator.py

@@ -0,0 +1,146 @@
+from ankigen_core.card_generator import (
+    _parse_model_selection,
+    _map_generation_mode_to_subject,
+    _build_generation_context,
+    format_cards_for_dataframe,
+    get_dataframe_columns,
+    generate_token_usage_html,
+)
+from ankigen_core.models import Card, CardFront, CardBack
+
+# --- _parse_model_selection Tests ---
+
+
+def test_parse_model_selection():
+    assert _parse_model_selection("gpt-5.2-auto") == ("gpt-5.2", None)
+    assert _parse_model_selection("gpt-5.2-instant") == ("gpt-5.2", "none")
+    assert _parse_model_selection("gpt-5.2-thinking") == ("gpt-5.2", "high")
+    assert _parse_model_selection("custom-model") == ("custom-model", None)
+    assert _parse_model_selection("") == ("gpt-5.2", None)
+
+
+# --- _map_generation_mode_to_subject Tests ---
+
+
+def test_map_generation_mode_to_subject():
+    assert _map_generation_mode_to_subject("subject", "Math") == "Math"
+    assert _map_generation_mode_to_subject("subject", "") == "general"
+    assert _map_generation_mode_to_subject("path", "") == "curriculum_design"
+    assert _map_generation_mode_to_subject("text", "") == "content_analysis"
+    assert _map_generation_mode_to_subject("unknown", "") == "general"
+
+
+# --- _build_generation_context Tests ---
+
+
+def test_build_generation_context():
+    assert _build_generation_context("text", "some text") == {
+        "source_text": "some text"
+    }
+    assert _build_generation_context("subject", "ignored") == {}
+    assert _build_generation_context("text", "") == {}
+
+
+# --- format_cards_for_dataframe Tests ---
+
+
+def test_format_cards_for_dataframe():
+    card = Card(
+        front=CardFront(question="Q"),
+        back=CardBack(answer="A", explanation="E", example="Ex"),
+        metadata={
+            "prerequisites": ["P1", "P2"],
+            "learning_outcomes": ["L1"],
+            "difficulty": "beginner",
+            "source_url": "http://example.com",
+        },
+        card_type="cloze",
+    )
+
+    formatted = format_cards_for_dataframe([card], "Test Topic")
+    assert len(formatted) == 1
+    f_card = formatted[0]
+    assert f_card["Index"] == "1"
+    assert f_card["Topic"] == "Test Topic"
+    assert f_card["Card_Type"] == "cloze"
+    assert f_card["Question"] == "Q"
+    assert f_card["Prerequisites"] == "P1, P2"
+    assert f_card["Learning_Outcomes"] == "L1"
+    assert f_card["Difficulty"] == "beginner"
+    assert f_card["Source_URL"] == "http://example.com"
+
+
+def test_format_cards_for_dataframe_missing_metadata():
+    card = Card(
+        front=CardFront(question="Q"),
+        back=CardBack(answer="A", explanation="E", example="Ex"),
+        card_type="basic",
+    )
+    formatted = format_cards_for_dataframe([card], "No Metadata")
+    f_card = formatted[0]
+    assert f_card["Prerequisites"] == ""
+    assert f_card["Difficulty"] == "N/A"
+
+
+# --- get_dataframe_columns Tests ---
+
+
+def test_get_dataframe_columns():
+    cols = get_dataframe_columns()
+    assert isinstance(cols, list)
+    assert "Question" in cols
+    assert "Answer" in cols
+    assert "Topic" in cols
+
+
+# --- generate_token_usage_html Tests ---
+
+
+def test_generate_token_usage_html():
+    usage = {"total_tokens": 100}
+    html = generate_token_usage_html(usage)
+    assert "100 tokens" in html
+
+    html_none = generate_token_usage_html(None)
+    assert "No usage data" in html_none
+
+    html_invalid = generate_token_usage_html("invalid")
+    assert "No usage data" in html_invalid
+
+
+# --- Additional Tests to meet 10+ requirement ---
+
+
+def test_available_models_constant():
+    from ankigen_core.card_generator import AVAILABLE_MODELS
+
+    assert len(AVAILABLE_MODELS) >= 3
+    assert AVAILABLE_MODELS[0]["value"] == "gpt-5.2-auto"
+
+
+def test_generation_modes_constant():
+    from ankigen_core.card_generator import GENERATION_MODES
+
+    assert len(GENERATION_MODES) >= 1
+    assert GENERATION_MODES[0]["value"] == "subject"
+
+
+def test_format_cards_for_dataframe_empty():
+    assert format_cards_for_dataframe([], "Empty") == []
+
+
+def test_format_cards_for_dataframe_multiple_cards():
+    cards = [
+        Card(
+            front=CardFront(question="Q1"),
+            back=CardBack(answer="A1", explanation="E1", example="X1"),
+        ),
+        Card(
+            front=CardFront(question="Q2"),
+            back=CardBack(answer="A2", explanation="E2", example="X2"),
+        ),
+    ]
+    formatted = format_cards_for_dataframe(cards, "Multiple", start_index=10)
+    assert len(formatted) == 2
+    assert formatted[0]["Index"] == "10"
+    assert formatted[1]["Index"] == "11"

tests/test_exporters.py

@@ -0,0 +1,174 @@
+import pytest
+import pandas as pd
+import os
+import gradio as gr
+from unittest.mock import patch
+from ankigen_core.exporters import (
+    _format_field_as_string,
+    _generate_timestamped_filename,
+    _validate_non_empty_data,
+    export_cards_to_csv,
+    export_cards_to_apkg,
+    export_cards_from_crawled_content,
+    export_dataframe_to_csv,
+    export_dataframe_to_apkg,
+)
+
+# --- _format_field_as_string Tests ---
+
+
+def test_format_field_as_string():
+    assert _format_field_as_string("test") == "test"
+    assert _format_field_as_string(["a", "b"]) == "a, b"
+    assert _format_field_as_string(("c", "d")) == "c, d"
+    assert _format_field_as_string(None) == ""
+    assert _format_field_as_string(float("nan")) == ""
+    assert _format_field_as_string(123) == "123"
+
+
+# --- _generate_timestamped_filename Tests ---
+
+
+def test_generate_timestamped_filename():
+    filename = _generate_timestamped_filename("test", "csv", include_timestamp=False)
+    assert filename == "test.csv"
+
+    filename_ts = _generate_timestamped_filename("test", "csv", include_timestamp=True)
+    assert filename_ts.startswith("test_")
+    assert filename_ts.endswith(".csv")
+    assert len(filename_ts) > len("test.csv")
+
+
+# --- _validate_non_empty_data Tests ---
+
+
+def test_validate_non_empty_data():
+    _validate_non_empty_data([1], "test")  # Should not raise
+    _validate_non_empty_data(pd.DataFrame({"a": [1]}), "test")  # Should not raise
+
+    with pytest.raises(ValueError, match="No test provided to export."):
+        _validate_non_empty_data(None, "test")
+
+    with pytest.raises(ValueError, match="No test provided to export."):
+        _validate_non_empty_data([], "test")
+
+    with pytest.raises(ValueError, match="No test available to export."):
+        _validate_non_empty_data(pd.DataFrame(), "test")
+
+
+# --- export_cards_to_csv Tests ---
+
+
+def test_export_cards_to_csv_success(tmp_path):
+    cards = [
+        {"front": "Q1", "back": "A1", "tags": "tag1", "note_type": "Basic"},
+        {"front": "Q2", "back": "A2"},
+    ]
+    filename = str(tmp_path / "test.csv")
+    result = export_cards_to_csv(cards, filename=filename)
+
+    assert result == filename
+    assert os.path.exists(filename)
+    df = pd.read_csv(filename)
+    assert len(df) == 2
+    assert df.iloc[0]["front"] == "Q1"
+    assert df.iloc[1]["note_type"] == "Basic"
+
+
+def test_export_cards_to_csv_missing_keys(tmp_path):
+    cards = [
+        {"front": "Q1", "back": "A1"},
+        {"only_front": "Q2"},  # Missing 'back', should be skipped
+    ]
+    filename = str(tmp_path / "test_missing.csv")
+    export_cards_to_csv(cards, filename=filename)
+
+    df = pd.read_csv(filename)
+    assert len(df) == 1  # Only one card should be exported
+
+
+# --- export_cards_to_apkg Tests ---
+
+
+@patch("genanki.Package.write_to_file")
+def test_export_cards_to_apkg_success(mock_write, tmp_path):
+    cards = [
+        {"Question": "Q1", "Answer": "A1", "note_type": "Basic"},
+        {"Question": "Q2", "Answer": "A2", "note_type": "Cloze"},
+    ]
+    filename = str(tmp_path / "test.apkg")
+    result = export_cards_to_apkg(cards, filename=filename)
+
+    assert result == filename
+    assert mock_write.called
+
+
+@patch("genanki.Package.write_to_file")
+def test_export_cards_to_apkg_skip_empty_question(mock_write, tmp_path):
+    cards = [
+        {"Question": "Q1", "Answer": "A1"},
+        {"Question": "", "Answer": "A2"},  # Empty question, should skip
+    ]
+    filename = str(tmp_path / "test_skip.apkg")
+    export_cards_to_apkg(cards, filename=filename)
+    # genanki objects are a bit hard to inspect, but we mainly check it doesn't crash
+
+
+def test_export_cards_to_apkg_zero_valid_notes():
+    cards = [{"Question": ""}]  # No valid notes
+    with pytest.raises(gr.Error, match="Failed to create any valid Anki notes"):
+        export_cards_to_apkg(cards)
+
+
+# --- export_cards_from_crawled_content Tests ---
+
+
+@patch("ankigen_core.exporters.export_cards_to_csv")
+def test_export_cards_from_crawled_content_csv(mock_csv):
+    cards = [{"front": "Q", "back": "A"}]
+    export_cards_from_crawled_content(cards, export_format="csv")
+    mock_csv.assert_called_once()
+
+
+@patch("ankigen_core.exporters.export_cards_to_apkg")
+def test_export_cards_from_crawled_content_apkg(mock_apkg):
+    cards = [{"front": "Q", "back": "A"}]
+    export_cards_from_crawled_content(cards, export_format="apkg")
+    mock_apkg.assert_called_once()
+
+
+def test_export_cards_from_crawled_content_unsupported():
+    with pytest.raises(ValueError, match="Unsupported export format"):
+        export_cards_from_crawled_content([{"f": "b"}], export_format="pdf")
+
+
+# --- DataFrame Export Tests ---
+
+
+def test_export_dataframe_to_csv_success(tmp_path):
+    df = pd.DataFrame({"Question": ["Q1"], "Answer": ["A1"]})
+    # We need to mock gr.Info to avoid issues if it requires a running Gradio app
+    with patch("gradio.Info"):
+        filename = export_dataframe_to_csv(
+            df, filename_suggestion=str(tmp_path / "suggested.csv")
+        )
+        assert filename is not None
+        assert os.path.exists(filename)
+
+
+def test_export_dataframe_to_csv_empty():
+    with pytest.raises(gr.Error, match="No card data available"):
+        export_dataframe_to_csv(None)
+
+
+@patch("ankigen_core.exporters.export_cards_to_apkg")
+def test_export_dataframe_to_apkg_success(mock_apkg):
+    df = pd.DataFrame({"Question": ["Q1"], "Answer": ["A1"], "Card_Type": ["Basic"]})
+    export_dataframe_to_apkg(df, output_path="test.apkg", deck_name="Test Deck")
+    mock_apkg.assert_called_once()
+    # Check that cards were processed correctly
+    args, kwargs = mock_apkg.call_args
+    processed_cards = args[0]
+    assert len(processed_cards) == 1
+    assert processed_cards[0]["Question"] == "Q1"
+    assert processed_cards[0]["note_type"] == "Basic"

tests/test_models.py

@@ -0,0 +1,97 @@
+import pytest
+from pydantic import ValidationError
+from ankigen_core.models import (
+    Step,
+    Subtopics,
+    Topics,
+    CardFront,
+    CardBack,
+    Card,
+    CardList,
+    ConceptBreakdown,
+    CardGeneration,
+    LearningSequence,
+)
+
+
+def test_step_model():
+    step = Step(explanation="expl", output="out")
+    assert step.explanation == "expl"
+    assert step.output == "out"
+
+    with pytest.raises(ValidationError):
+        Step(explanation="expl")  # missing output
+
+
+def test_subtopics_model():
+    sub = Subtopics(steps=[Step(explanation="e", output="o")], result=["r1"])
+    assert len(sub.steps) == 1
+    assert sub.result == ["r1"]
+
+
+def test_topics_model():
+    topics = Topics(result=[Subtopics(steps=[], result=[])])
+    assert len(topics.result) == 1
+
+
+def test_card_front_model():
+    cf = CardFront(question="Q?")
+    assert cf.question == "Q?"
+    assert CardFront().question is None
+
+
+def test_card_back_model():
+    cb = CardBack(answer="A", explanation="E", example="Ex")
+    assert cb.answer == "A"
+    assert cb.explanation == "E"
+    assert cb.example == "Ex"
+
+
+def test_card_model():
+    cf = CardFront(question="Q")
+    cb = CardBack(answer="A", explanation="E", example="Ex")
+    card = Card(front=cf, back=cb, metadata={"key": "val"}, card_type="cloze")
+    assert card.front.question == "Q"
+    assert card.card_type == "cloze"
+    assert card.metadata["key"] == "val"
+
+
+def test_card_list_model():
+    cf = CardFront(question="Q")
+    cb = CardBack(answer="A", explanation="E", example="Ex")
+    card = Card(front=cf, back=cb)
+    cl = CardList(topic="test", cards=[card])
+    assert cl.topic == "test"
+    assert len(cl.cards) == 1
+
+
+def test_concept_breakdown_model():
+    cb = ConceptBreakdown(
+        main_concept="C",
+        prerequisites=["P"],
+        learning_outcomes=["L"],
+        difficulty_level="beginner",
+    )
+    assert cb.difficulty_level == "beginner"
+
+
+def test_card_generation_model():
+    cf = CardFront(question="Q")
+    cb = CardBack(answer="A", explanation="E", example="Ex")
+    card = Card(front=cf, back=cb)
+    cg = CardGeneration(
+        concept="C", thought_process="T", verification_steps=["V"], card=card
+    )
+    assert cg.concept == "C"
+    assert cg.card.front.question == "Q"
+
+
+def test_learning_sequence_model():
+    ls = LearningSequence(
+        topic="T",
+        concepts=[],
+        cards=[],
+        suggested_study_order=[],
+        review_recommendations=[],
+    )
+    assert ls.topic == "T"

tests/test_utils.py

@@ -0,0 +1,186 @@
+import pytest
+import hashlib
+from unittest.mock import MagicMock
+from ankigen_core.utils import (
+    ResponseCache,
+    RateLimiter,
+    strip_html_tags,
+    fetch_webpage_text,
+    setup_logging,
+    get_logger,
+)
+import requests
+
+# --- ResponseCache Tests ---
+
+
+def test_cache_set_get():
+    cache = ResponseCache(maxsize=2)
+    cache.set("prompt1", "model1", "response1")
+    assert cache.get("prompt1", "model1") == "response1"
+    assert cache.hits == 1
+    assert cache.misses == 0
+
+
+def test_cache_miss():
+    cache = ResponseCache(maxsize=2)
+    assert cache.get("nonexistent", "model1") is None
+    assert cache.hits == 0
+    assert cache.misses == 1
+
+
+def test_cache_eviction():
+    cache = ResponseCache(maxsize=2)
+    cache.set("p1", "m1", "r1")
+    cache.set("p2", "m2", "r2")
+    cache.set("p3", "m3", "r3")  # Should evict p1
+
+    assert cache.get("p1", "m1") is None
+    assert cache.get("p2", "m2") == "r2"
+    assert cache.get("p3", "m3") == "r3"
+
+
+def test_cache_lru_update():
+    cache = ResponseCache(maxsize=2)
+    cache.set("p1", "m1", "r1")
+    cache.set("p2", "m2", "r2")
+    cache.get("p1", "m1")  # p1 is now MRU
+    cache.set("p3", "m3", "r3")  # Should evict p2
+
+    assert cache.get("p2", "m2") is None
+    assert cache.get("p1", "m1") == "r1"
+    assert cache.get("p3", "m3") == "r3"
+
+
+def test_cache_clear():
+    cache = ResponseCache(maxsize=2)
+    cache.set("p1", "m1", "r1")
+    cache.hits = 5
+    cache.misses = 2
+    cache.clear()
+
+    assert cache.get("p1", "m1") is None
+    assert cache.hits == 0
+    assert cache.misses == 1  # Miss from the get() call above
+
+
+def test_cache_key_hashing():
+    cache = ResponseCache()
+    prompt = "test prompt"
+    model = "gpt-4"
+    expected_key = hashlib.md5(f"{model}:{prompt}".encode("utf-8")).hexdigest()
+    assert cache._create_key(prompt, model) == expected_key
+
+
+# --- RateLimiter Tests ---
+
+
+def test_rate_limiter_init_invalid():
+    with pytest.raises(ValueError, match="Requests per second must be positive."):
+        RateLimiter(0)
+    with pytest.raises(ValueError, match="Requests per second must be positive."):
+        RateLimiter(-1)
+
+
+def test_rate_limiter_wait(mocker):
+    # Mock time.monotonic and time.sleep
+    mock_monotonic = mocker.patch("time.monotonic")
+    mock_sleep = mocker.patch("time.sleep")
+
+    # First call: current_time = 10.0, last_request = 0.0
+    # Interval = 1.0 (for 1 req/sec)
+    # diff = 10.0 >= 1.0, no sleep
+    mock_monotonic.side_effect = [10.0, 10.1, 10.2, 10.3]
+
+    limiter = RateLimiter(1.0)
+    limiter.wait()
+    assert mock_sleep.call_count == 0
+
+    # Second call: current_time = 10.2, last_request = 10.1 (from end of first wait)
+    # diff = 0.1 < 1.0, sleep for 0.9
+    limiter.wait()
+    mock_sleep.assert_called_once_with(pytest.approx(0.9))
+
+
+# --- strip_html_tags Tests ---
+
+
+def test_strip_html_tags_normal():
+    html = "<div>Hello <b>World</b></div>"
+    assert strip_html_tags(html) == "Hello World"
+
+
+def test_strip_html_tags_empty():
+    assert strip_html_tags("") == ""
+
+
+def test_strip_html_tags_non_string():
+    assert strip_html_tags(None) == "None"
+    assert strip_html_tags(123) == "123"
+
+
+# --- fetch_webpage_text Tests ---
+
+
+def test_fetch_webpage_text_success(mocker):
+    mock_get = mocker.patch("requests.get")
+    mock_response = MagicMock()
+    mock_response.text = "<html><body><main>Relevant content</main></body></html>"
+    mock_response.status_code = 200
+    mock_get.return_value = mock_response
+
+    result = fetch_webpage_text("http://example.com")
+    assert result == "Relevant content"
+
+
+def test_fetch_webpage_text_article_fallback(mocker):
+    mock_get = mocker.patch("requests.get")
+    mock_response = MagicMock()
+    mock_response.text = "<html><body><article>Article content</article></body></html>"
+    mock_get.return_value = mock_response
+
+    result = fetch_webpage_text("http://example.com")
+    assert result == "Article content"
+
+
+def test_fetch_webpage_text_body_fallback(mocker):
+    mock_get = mocker.patch("requests.get")
+    mock_response = MagicMock()
+    mock_response.text = "<html><body>Body content</body></html>"
+    mock_get.return_value = mock_response
+
+    result = fetch_webpage_text("http://example.com")
+    assert result == "Body content"
+
+
+def test_fetch_webpage_text_network_error(mocker):
+    mock_get = mocker.patch("requests.get")
+    mock_get.side_effect = requests.exceptions.RequestException("Connection failed")
+
+    with pytest.raises(ConnectionError, match="Could not fetch URL"):
+        fetch_webpage_text("http://example.com")
+
+
+def test_fetch_webpage_text_empty_content(mocker):
+    mock_get = mocker.patch("requests.get")
+    mock_response = MagicMock()
+    mock_response.text = "<html><body></body></html>"
+    mock_get.return_value = mock_response
+
+    assert fetch_webpage_text("http://example.com") == ""
+
+
+# --- Logging Tests ---
+
+
+def test_get_logger_singleton():
+    logger1 = get_logger()
+    logger2 = get_logger()
+    assert logger1 is logger2
+
+
+def test_setup_logging_idempotent():
+    # Calling setup_logging twice should return same logger
+    logger1 = setup_logging()
+    logger2 = setup_logging()
+    assert logger1 is logger2