Merge branch 'main' into athena/feature/model-choice

Author: LeonWehrhahn

.github/workflows/athena_test.yml

@@ -37,7 +37,7 @@ jobs:
         echo "$HOME/.local/bin" >> $GITHUB_PATH
         poetry install
         poetry run install_all
-
+        
     - name: Run tests
       working-directory: athena
       run: poetry run test_all

.github/workflows/hyperion_check-openapi.yml

@@ -27,7 +27,7 @@ jobs:
           fetch-depth: 0
 
       - name: Set up Python 3.13
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v5
         with:
           python-version: 3.13
 

.github/workflows/hyperion_lint.yml

@@ -17,7 +17,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: Set up Python 3.13
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v5
         with:
           python-version: 3.13
 

athena/modules/text/module_text_llm/poetry.lock

@@ -16,14 +16,12 @@ nltk = "3.9.1"
 python-dotenv = "1.0.0"
 tiktoken = "0.7.0"
 
-[tool.poetry.dev-dependencies]
-pydantic = "1.10.17"
-prospector = "^1.10.2"
-
 [tool.poetry.scripts]
 module = "athena:run_module"
 
 [tool.poetry.group.dev.dependencies]
+pydantic = "1.10.17"
+prospector = "^1.10.2"
 types-requests = "^2.31.0.8"
 
 [build-system]

athena/modules/text/module_text_llm/pyproject.toml

@@ -8,12 +8,19 @@ package-mode = true
 [tool.poetry.dependencies]
 python = "3.11.*"
 
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.5"
+pytest-asyncio = "^0.26.0"
+
 [tool.poetry.scripts]
 lint_all = "scripts.lint_modules:main"
 install_all = "scripts.install_modules:main"
 lock_all = "scripts.lock_modules:main"
 test_all = "scripts.test_modules:main"
 
+[tool.pytest.ini_options]
+pythonpath = ["athena"]
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

athena/poetry.lock

@@ -19,6 +19,46 @@ def main():
     ]
 
     success = True
+    path_env = os.environ["PATH"]
+
+    for module in modules:
+        # Check if test directory exists
+        test_dir = f"tests/{module}"
+        if not os.path.exists(test_dir):
+            print(f"No tests found for {module}, skipping...")
+            continue
+
+        # Get the module's virtual environment
+        venv_path = os.path.join(os.getcwd(), module, ".venv")
+        if not os.path.exists(venv_path):
+            print(f"Virtual environment not found for {module} at {venv_path}")
+            continue
+
+        # Set environment variables for the virtual environment
+        os.environ["VIRTUAL_ENV"] = venv_path
+        os.environ["PATH"] = os.path.join(venv_path, "bin") + os.pathsep + path_env
+        python_path = os.path.join(venv_path, "bin", "python")
+        pip_path = os.path.join(venv_path, "bin", "pip")
+
+        print(f"Using Python path: {python_path}")
+
+        try:
+            # Install pytest in the virtual environment
+            print(f"Installing pytest for {module}...")
+            subprocess.run([pip_path, "install", "pytest"], check=True, capture_output=True, text=True)
+
+            # Run pytest using the module's virtual environment
+            result = subprocess.run([python_path, "-m", "pytest", test_dir], capture_output=True, text=True)
+            if result.returncode != 0:
+                print(f"Tests failed for {module}:")
+                print(result.stdout)
+                print(result.stderr)
+                success = False
+            else:
+                print(f"Tests passed for {module}")
+        except Exception as e:
+            print(f"Error running tests for {module}: {str(e)}")
+            success = False
 
     if success:
         sys.exit(0)

athena/pyproject.toml

@@ -0,0 +1,35 @@
+# Import OpenAI mocks first to ensure they're in place before any other imports
+from tests.utils.mock_openai import mock_openai, mock_openai_client
+
+import pytest
+from tests.utils.mock_llm import MockLanguageModel, MockStructuredMockLanguageModel, MockAssessmentModel
+from tests.utils.mock_config import MockApproachConfig, MockModelConfig
+from tests.utils.mock_env import mock_sent_tokenize
+
+
+@pytest.fixture
+def mock_llm():
+    """Fixture providing a basic mock language model."""
+    return MockLanguageModel()
+
+
+@pytest.fixture
+def mock_structured_llm():
+    """Fixture providing a structured mock language model."""
+    return MockStructuredMockLanguageModel()
+
+
+@pytest.fixture
+def mock_assessment_model():
+    """Fixture providing a mock assessment model."""
+    return MockAssessmentModel()
+
+
+@pytest.fixture
+def mock_config():
+    """Create a mock configuration for testing."""
+    return MockApproachConfig(
+        max_input_tokens=5000,
+        model=MockModelConfig(),
+        type="basic"
+    )

athena/scripts/test_modules.py

@@ -0,0 +1,131 @@
+import pytest
+from module_text_llm.basic_approach.generate_suggestions import generate_suggestions
+from athena.text import Exercise, Submission, Feedback
+from athena.schemas.exercise_type import ExerciseType
+from tests.utils.mock_env import mock_sent_tokenize
+from tests.utils.mock_llm import MockLanguageModel, MockAssessmentModel, MockFeedbackModel
+
+
+@pytest.fixture
+def mock_exercise():
+    """Create a mock exercise for testing."""
+    return Exercise(
+        id=1,
+        title="Test Exercise",
+        type=ExerciseType.text,
+        max_points=10,
+        bonus_points=2,
+        grading_instructions="Test grading instructions",
+        problem_statement="Test problem statement",
+        example_solution="Test example solution",
+        grading_criteria=[]
+    )
+
+
+@pytest.fixture
+def mock_submission(mock_exercise):
+    """Create a mock submission for testing."""
+    return Submission(
+        id=1,
+        exerciseId=mock_exercise.id,
+        text="This is a test submission.\nIt has multiple lines.\nFor testing purposes."
+    )
+
+
+@pytest.mark.asyncio
+async def test_generate_suggestions_basic(
+        mock_exercise, mock_submission, mock_config):
+    """Test basic feedback generation with a simple submission."""
+    mock_model = MockLanguageModel(return_value=MockAssessmentModel(feedbacks=[
+        MockFeedbackModel(
+            title="Test Feedback",
+            description="Test description",
+            line_start=1,
+            line_end=2,
+            credits=5.0
+        )
+    ]))
+    mock_config.model.get_model = lambda: mock_model
+    mock_sent_tokenize.return_value = [
+        "This is a test submission.",
+        "It has multiple lines.",
+        "For testing purposes."
+    ]
+
+    feedbacks = await generate_suggestions(
+        exercise=mock_exercise,
+        submission=mock_submission,
+        config=mock_config,
+        debug=False,
+        is_graded=True
+    )
+
+    assert isinstance(feedbacks, list)
+    assert all(isinstance(feedback, Feedback) for feedback in feedbacks)
+    assert all(feedback.exercise_id ==
+               mock_exercise.id for feedback in feedbacks)
+    assert all(feedback.submission_id ==
+               mock_submission.id for feedback in feedbacks)
+
+
+@pytest.mark.asyncio
+async def test_generate_suggestions_empty_submission(
+        mock_exercise, mock_config):
+    """Test feedback generation with an empty submission."""
+    empty_submission = Submission(
+        id=2,
+        exerciseId=mock_exercise.id,
+        text=""
+    )
+    mock_model = MockLanguageModel(
+        return_value=MockAssessmentModel(
+            feedbacks=[]))
+    mock_config.model.get_model = lambda: mock_model
+    mock_sent_tokenize.return_value = []
+
+    feedbacks = await generate_suggestions(
+        exercise=mock_exercise,
+        submission=empty_submission,
+        config=mock_config,
+        debug=False,
+        is_graded=True
+    )
+
+    assert isinstance(feedbacks, list)
+    assert len(feedbacks) == 0
+
+
+@pytest.mark.asyncio
+async def test_generate_suggestions_long_input(mock_exercise, mock_config):
+    """Test feedback generation with a long submission."""
+    long_submission = Submission(
+        id=3,
+        exerciseId=mock_exercise.id,
+        text="Test " * 1000
+    )
+    mock_model = MockLanguageModel(return_value=MockAssessmentModel(feedbacks=[
+        MockFeedbackModel(
+            title="Test Long Input Feedback",
+            description="Test description for long input",
+            line_start=1,
+            line_end=100,
+            credits=7.0
+        )
+    ]))
+    mock_config.model.get_model = lambda: mock_model
+    mock_sent_tokenize.return_value = ["Test " * 100 for _ in range(10)]
+
+    feedbacks = await generate_suggestions(
+        exercise=mock_exercise,
+        submission=long_submission,
+        config=mock_config,
+        debug=False,
+        is_graded=True
+    )
+
+    assert isinstance(feedbacks, list)
+    assert all(isinstance(feedback, Feedback) for feedback in feedbacks)
+    assert all(feedback.exercise_id ==
+               mock_exercise.id for feedback in feedbacks)
+    assert all(feedback.submission_id ==
+               long_submission.id for feedback in feedbacks)