Enforce strict (0,1) task score outputs for validators

server/tasks/base.py

@@ -4,6 +4,16 @@ from typing import Dict, Any, List, Optional, Tuple
 
 
 class BaseTask(ABC):
+    _MIN_STRICT_SCORE = 0.001
+    _MAX_STRICT_SCORE = 0.999
+
+    def _strict_score(self, score: float) -> float:
+        """Keep task score strictly inside (0, 1) for validator compatibility."""
+        return round(
+            min(self._MAX_STRICT_SCORE, max(self._MIN_STRICT_SCORE, score)),
+            3,
+        )
+
     """
     Abstract base for all tasks.
 
@@ -93,19 +103,19 @@ class BaseTask(ABC):
         - 0.0: null result, syntax error, or empty when non-empty expected
         """
         if not actual_rows:
-            return 0.0
+            return self._strict_score(0.0)
 
         expected = self.expected_output
 
         if not expected:
             # Expected empty result
-            return 1.0 if len(actual_rows) == 0 else 0.0
+            return self._strict_score(1.0 if len(actual_rows) == 0 else 0.0)
 
         # Exact row count match
         if len(actual_rows) != len(expected):
             # Partial credit for getting some rows right
             overlap = self._count_matching_rows(actual_rows, expected)
-            return round(min(0.5, overlap / max(len(expected), 1) * 0.5), 3)
+            return self._strict_score(min(0.5, overlap / max(len(expected), 1) * 0.5))
 
         # Check row-by-row match (order-sensitive if task requires it)
         matching = self._count_matching_rows(actual_rows, expected)
@@ -118,7 +128,7 @@ class BaseTask(ABC):
             if actual_cols != expected_cols:
                 score *= 0.7  # Penalty for wrong columns
 
-        return round(score, 3)
+        return self._strict_score(score)
 
     def _count_matching_rows(
         self,

server/tasks/task_medium.py

@@ -127,10 +127,20 @@ class MediumTaskGrader:
     """
     Custom grader for medium task — handles NULL comparison.
     """
+    _MIN_STRICT_SCORE = 0.001
+    _MAX_STRICT_SCORE = 0.999
+
+    @staticmethod
+    def _strict_score(score: float) -> float:
+        return round(
+            min(MediumTaskGrader._MAX_STRICT_SCORE, max(MediumTaskGrader._MIN_STRICT_SCORE, score)),
+            3,
+        )
+
     @staticmethod
     def grade(actual: List[Dict]) -> float:
         if not actual or len(actual) != 4:
-            return 0.0
+            return MediumTaskGrader._strict_score(0.0)
 
         # Sort both by dept name for comparison
         actual_sorted = sorted(actual, key=lambda r: r.get("department_name", ""))
@@ -159,5 +169,5 @@ class MediumTaskGrader:
             if dept_ok and count_ok and salary_ok:
                 matches += 1
 
-        return round(matches / 4, 3)
+        return MediumTaskGrader._strict_score(matches / 4)
 

tests/test_graders.py

@@ -9,22 +9,22 @@ class TestGraders(unittest.TestCase):
     def test_easy_grade_perfect(self):
         task = EasyTask()
         score = task.grade(task.expected_output)
-        self.assertAlmostEqual(score, 1.0, places=3)
+        self.assertAlmostEqual(score, 0.999, places=3)
 
     def test_hard_grade_perfect(self):
         task = HardTask()
         score = task.grade(task.expected_output)
-        self.assertAlmostEqual(score, 1.0, places=3)
+        self.assertAlmostEqual(score, 0.999, places=3)
 
     def test_easy_grade_empty(self):
         task = EasyTask()
         score = task.grade(None)
-        self.assertEqual(score, 0.0)
+        self.assertAlmostEqual(score, 0.001, places=3)
 
     def test_medium_grader_perfect(self):
         task = MediumTask()
         score = MediumTaskGrader.grade(task.expected_output)
-        self.assertAlmostEqual(score, 1.0, places=3)
+        self.assertAlmostEqual(score, 0.999, places=3)
 
     def test_medium_grader_partial(self):
         # Flip one row's avg_salary so it no longer matches within tolerance.
@@ -37,7 +37,7 @@ class TestGraders(unittest.TestCase):
                 r["avg_salary"] = 12345.0
 
         score = MediumTaskGrader.grade(actual)
-        self.assertLess(score, 1.0)
+        self.assertLess(score, 0.999)
         self.assertAlmostEqual(score, 0.75, places=3)