learnx-cli 0.3.0__py3-none-any.whl

tutor/tests/ingestion/test_chunker.py

@@ -0,0 +1,94 @@
+from tutor.constants import MIN_CHUNK_TOKENS
+from tutor.ingestion.chunker import chunk
+from tutor.models import DocProfile
+
+SAMPLE_B = """
+## The JVM
+
+The JVM loads bytecode stored in .class files and executes it on any operating system.
+JIT compilation identifies hot code paths and compiles them to native machine code at
+runtime, so repeated calls become significantly faster than interpreted execution.
+Memory is split into the stack for local variables and method calls, and the heap for
+all objects created with the new keyword.
+
+## Primitives
+
+Java has eight primitive types: int, long, double, float, boolean, char, byte, and short.
+Primitives are stored directly on the stack and hold their values inline, unlike reference
+types which store a pointer to an object on the heap. Autoboxing converts primitives to
+their wrapper classes such as Integer or Boolean automatically when needed.
+
+## Pass-by-Value
+
+Java is strictly pass-by-value. When you pass a variable to a method, Java copies the
+value of that variable into the method parameter. For primitives this is the actual number.
+For reference types this is the memory address, which means the caller and the method share
+the same heap object, but reassigning the parameter inside the method does not affect the
+caller's original variable.
+""".strip()
+
+SAMPLE_NO_HEADINGS = "Java is a language. It has classes and objects. " * 100
+
+
+def _make_profile(text: str, strategy: str) -> DocProfile:
+    return DocProfile(
+        filepath="test.md",
+        raw_bytes=len(text.encode()),
+        estimated_tokens=int(len(text.split()) * 1.3),
+        strategy=strategy,
+        section_count=3,
+        has_code_blocks=False,
+        language_hint="java",
+    )
+
+
+def test_strategy_b_produces_multiple_chunks():
+    profile = _make_profile(SAMPLE_B, "B")
+    chunks = chunk(SAMPLE_B, profile)
+    assert len(chunks) >= 2
+
+
+def test_strategy_b_chunk_ids_are_slugified():
+    profile = _make_profile(SAMPLE_B, "B")
+    chunks = chunk(SAMPLE_B, profile)
+    for c in chunks:
+        assert " " not in c.chunk_id
+        assert c.chunk_id == c.chunk_id.lower()
+
+
+def test_strategy_b_no_headings_falls_back_to_c():
+    profile = _make_profile(SAMPLE_NO_HEADINGS, "B")
+    chunks = chunk(SAMPLE_NO_HEADINGS, profile)
+    assert any("window" in c.chunk_id for c in chunks)
+
+
+def test_strategy_a_produces_single_chunk():
+    short = "Java is statically typed."
+    profile = _make_profile(short, "A")
+    chunks = chunk(short, profile)
+    assert len(chunks) == 1
+    assert chunks[0].chunk_id == "full_doc"
+
+
+def test_strategy_c_produces_window_chunks():
+    long_text = "Java is a language. " * 500
+    profile = _make_profile(long_text, "C")
+    chunks = chunk(long_text, profile)
+    assert len(chunks) > 1
+    assert all("window" in c.chunk_id for c in chunks)
+
+
+def test_strategy_c_overlap_flag():
+    long_text = "Java is a language. " * 500
+    profile = _make_profile(long_text, "C")
+    chunks = chunk(long_text, profile)
+    # First chunk is not overlapping, rest are
+    assert chunks[0].overlapping is False
+    assert all(c.overlapping is True for c in chunks[1:])
+
+
+def test_no_chunk_under_min_tokens():
+    profile = _make_profile(SAMPLE_B, "B")
+    chunks = chunk(SAMPLE_B, profile)
+    for c in chunks:
+        assert c.token_count >= MIN_CHUNK_TOKENS

tutor/tests/ingestion/test_doc_analyzer.py

@@ -0,0 +1,51 @@
+import pytest
+
+from tutor.exceptions import IngestionError
+from tutor.ingestion.doc_analyzer import analyze
+
+
+def test_small_doc_strategy_a(tmp_path):
+    doc = tmp_path / "small.md"
+    doc.write_text("# Title\n\nShort content. " * 20)
+    profile = analyze(str(doc))
+    assert profile.strategy == "A"
+
+
+def test_medium_doc_strategy_b(tmp_path):
+    doc = tmp_path / "medium.md"
+    doc.write_text("# Title\n\nContent word. " * 8_000)
+    profile = analyze(str(doc))
+    assert profile.strategy == "B"
+
+
+def test_large_doc_strategy_c(tmp_path):
+    doc = tmp_path / "large.md"
+    doc.write_text("# Title\n\nContent word. " * 50_000)
+    profile = analyze(str(doc))
+    assert profile.strategy == "C"
+
+
+def test_java_language_hint(tmp_path):
+    doc = tmp_path / "java.md"
+    doc.write_text("# Java\n\n```java\nint x = 5;\n```\n")
+    profile = analyze(str(doc))
+    assert profile.language_hint == "java"
+
+
+def test_has_code_blocks_detection(tmp_path):
+    doc = tmp_path / "code.md"
+    doc.write_text("# Title\n\n```python\nprint('hi')\n```\n")
+    profile = analyze(str(doc))
+    assert profile.has_code_blocks is True
+
+
+def test_no_code_blocks(tmp_path):
+    doc = tmp_path / "nocode.md"
+    doc.write_text("# Title\n\nJust plain text, no code blocks here.")
+    profile = analyze(str(doc))
+    assert profile.has_code_blocks is False
+
+
+def test_nonexistent_file_raises():
+    with pytest.raises(IngestionError):
+        analyze("/nonexistent/path/file.md")

tutor/tests/player/test_player_states.py

@@ -0,0 +1,88 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from tutor.models import TeachingUnit
+
+
+def _make_unit(n: int = 1) -> TeachingUnit:
+    return TeachingUnit(
+        unit=n,
+        concept=f"Concept {n}",
+        source_sections=[],
+        complexity=2,
+        word_budget=400,
+        key_facts=["fact"],
+        common_misconception="wrong",
+        good_analogy="like a thing",
+        question_style="recall",
+        memory_hook="remember this",
+    )
+
+
+@pytest.fixture
+def player(tmp_path):
+    """Create a TutorPlayer with mocked pygame."""
+    fake_mp3 = tmp_path / "unit_01.mp3"
+    fake_mp3.write_bytes(b"fake")
+
+    with patch("tutor.player.player.pygame") as mock_pygame:
+        mock_pygame.USEREVENT = 0
+        mock_pygame.mixer = MagicMock()
+
+        from tutor.player.player import TutorPlayer
+
+        p = TutorPlayer(
+            unit_files=[str(fake_mp3)],
+            units=[_make_unit()],
+        )
+        p._state = "PAUSED"
+        yield p
+
+
+def test_initial_state_is_paused(player):
+    assert player._state == "PAUSED"
+
+
+def test_toggle_play_pause_from_paused(player):
+    with patch.object(player, "_resume") as mock_resume:
+        player._toggle_play_pause()
+        mock_resume.assert_called_once()
+
+
+def test_toggle_play_pause_from_playing(player):
+    player._state = "PLAYING"
+    with patch.object(player, "_pause") as mock_pause:
+        player._toggle_play_pause()
+        mock_pause.assert_called_once()
+
+
+def test_quit_sets_stopped(player):
+    with patch("tutor.player.player.pygame"):
+        player._quit()
+    assert player._state == "STOPPED"
+
+
+def test_no_qa_flag_skips_llm(player, capsys):
+    player.no_qa = True
+    player._state = "PAUSED"
+    player._ask_question()
+    out = capsys.readouterr().out
+    assert "disabled" in out.lower() or "no-qa" in out.lower()
+
+
+def test_ask_question_pauses_if_playing(player):
+    player._state = "PLAYING"
+    player.no_qa = True
+    player._ask_question()
+    assert player._state in ("PAUSED", "PLAYING")
+
+
+def test_next_unit_bounded(player):
+    player._current_idx = 0
+    with patch("tutor.player.player.pygame"):
+        with patch.object(player, "_load_unit") as mock_load:
+            with patch.object(player, "_play"):
+                player._state = "PLAYING"
+                player._next_unit()
+                mock_load.assert_called_with(0)

tutor/tests/test_assets.py

@@ -0,0 +1,39 @@
+"""Tests for tutor/assets/__init__.py — path constants."""
+
+from pathlib import Path
+
+from tutor.assets import ASSETS_DIR, FONTS_DIR, LOGO_PATH
+
+
+def test_assets_dir_is_path():
+    assert isinstance(ASSETS_DIR, Path)
+
+
+def test_fonts_dir_is_path():
+    assert isinstance(FONTS_DIR, Path)
+
+
+def test_logo_path_is_path():
+    assert isinstance(LOGO_PATH, Path)
+
+
+def test_fonts_dir_is_child_of_assets_dir():
+    assert FONTS_DIR.parent == ASSETS_DIR
+
+
+def test_logo_path_is_inside_assets_dir():
+    assert LOGO_PATH.parent == ASSETS_DIR
+
+
+def test_assets_dir_exists():
+    """The assets package directory should exist on disk."""
+    assert ASSETS_DIR.exists()
+    assert ASSETS_DIR.is_dir()
+
+
+def test_fonts_dir_name_is_fonts():
+    assert FONTS_DIR.name == "fonts"
+
+
+def test_logo_path_name():
+    assert LOGO_PATH.name == "logo_small.png"

tutor/tests/test_models_visual.py

@@ -0,0 +1,180 @@
+"""
+Tests for PR additions in tutor/models.py (VisualSpec) and tutor/exceptions.py (VideoError).
+"""
+
+import dataclasses
+
+import pytest
+
+from tutor.exceptions import ConfigError, LLMError, TutorError, VideoError
+from tutor.models import VisualSpec
+
+# ── VideoError ────────────────────────────────────────────────────────────────
+
+
+def test_video_error_is_tutor_error():
+    assert issubclass(VideoError, TutorError)
+
+
+def test_video_error_can_be_raised_and_caught():
+    with pytest.raises(VideoError):
+        raise VideoError("pipeline failed")
+
+
+def test_video_error_caught_as_tutor_error():
+    with pytest.raises(TutorError):
+        raise VideoError("wrapped")
+
+
+def test_video_error_message_preserved():
+    try:
+        raise VideoError("step 3 failed")
+    except VideoError as exc:
+        assert "step 3 failed" in str(exc)
+
+
+def test_video_error_not_same_as_config_error():
+    assert VideoError is not ConfigError
+    assert not issubclass(VideoError, ConfigError)
+
+
+def test_video_error_not_same_as_llm_error():
+    assert VideoError is not LLMError
+    assert not issubclass(VideoError, LLMError)
+
+
+# ── VisualSpec — defaults ─────────────────────────────────────────────────────
+
+
+def test_visual_spec_minimal_construction():
+    spec = VisualSpec(unit_index=1, slide_type="unit")
+    assert spec.unit_index == 1
+    assert spec.slide_type == "unit"
+
+
+def test_visual_spec_default_diagram_type_is_none():
+    spec = VisualSpec(unit_index=1, slide_type="unit")
+    assert spec.diagram_type == "none"
+
+
+def test_visual_spec_default_diagram_spec_is_none():
+    spec = VisualSpec(unit_index=1, slide_type="unit")
+    assert spec.diagram_spec is None
+
+
+def test_visual_spec_default_key_points_is_empty_list():
+    spec = VisualSpec(unit_index=1, slide_type="unit")
+    assert spec.key_points == []
+    assert isinstance(spec.key_points, list)
+
+
+def test_visual_spec_default_memory_hooks_is_empty_list():
+    spec = VisualSpec(unit_index=0, slide_type="outro")
+    assert spec.memory_hooks == []
+    assert isinstance(spec.memory_hooks, list)
+
+
+def test_visual_spec_default_string_fields_are_empty():
+    spec = VisualSpec(unit_index=1, slide_type="unit")
+    assert spec.concept == ""
+    assert spec.hook_question == ""
+    assert spec.memory_hook == ""
+    assert spec.analogy == ""
+    assert spec.code_snippet is None
+    assert spec.title == ""
+    assert spec.subtitle == ""
+    assert spec.doc_source == ""
+    assert spec.session_stats == ""
+
+
+def test_visual_spec_title_card_fields():
+    spec = VisualSpec(
+        unit_index=0,
+        slide_type="title_card",
+        title="Java Basics",
+        subtitle="5 units · beginner",
+        doc_source="week1_1",
+    )
+    assert spec.title == "Java Basics"
+    assert spec.subtitle == "5 units · beginner"
+    assert spec.doc_source == "week1_1"
+
+
+def test_visual_spec_unit_fields():
+    spec = VisualSpec(
+        unit_index=3,
+        slide_type="unit",
+        concept="Pass-by-Value",
+        hook_question="What really happens?",
+        key_points=["fact1", "fact2"],
+        code_snippet="int x = 5;",
+        diagram_type="flowchart",
+        diagram_spec="digraph G { A -> B }",
+        memory_hook="Copy the address",
+        analogy="Like copying an address",
+    )
+    assert spec.concept == "Pass-by-Value"
+    assert spec.hook_question == "What really happens?"
+    assert spec.key_points == ["fact1", "fact2"]
+    assert spec.code_snippet == "int x = 5;"
+    assert spec.diagram_type == "flowchart"
+    assert spec.diagram_spec == "digraph G { A -> B }"
+    assert spec.memory_hook == "Copy the address"
+    assert spec.analogy == "Like copying an address"
+
+
+def test_visual_spec_outro_fields():
+    spec = VisualSpec(
+        unit_index=5,
+        slide_type="outro",
+        memory_hooks=["Hook A", "Hook B"],
+        session_stats="4 units",
+    )
+    assert spec.memory_hooks == ["Hook A", "Hook B"]
+    assert spec.session_stats == "4 units"
+
+
+def test_visual_spec_is_dataclass():
+    assert dataclasses.is_dataclass(VisualSpec)
+
+
+def test_visual_spec_mutable_list_fields_independent():
+    """Each VisualSpec should have its own list instances, not share them."""
+    a = VisualSpec(unit_index=1, slide_type="unit")
+    b = VisualSpec(unit_index=2, slide_type="unit")
+    a.key_points.append("fact")
+    assert b.key_points == [], "Shared mutable default detected"
+
+
+def test_visual_spec_asdict_roundtrip():
+    """dataclasses.asdict / reconstruct should preserve all fields."""
+    original = VisualSpec(
+        unit_index=2,
+        slide_type="unit",
+        concept="Concept",
+        key_points=["a", "b"],
+        diagram_type="flowchart",
+        diagram_spec="digraph G { A -> B }",
+        memory_hook="remember",
+        analogy="like something",
+    )
+    d = dataclasses.asdict(original)
+    reconstructed = VisualSpec(**d)
+    assert reconstructed == original
+
+
+def test_visual_spec_code_comparison_diagram_spec():
+    """diagram_spec can be a dict for code_comparison type."""
+    spec = VisualSpec(
+        unit_index=1,
+        slide_type="unit",
+        diagram_type="code_comparison",
+        diagram_spec={
+            "wrong": "a == b",
+            "right": "a.equals(b)",
+            "label_wrong": "ref check",
+            "label_right": "content check",
+        },
+    )
+    assert isinstance(spec.diagram_spec, dict)
+    assert "wrong" in spec.diagram_spec