Merge branch 'main' into css-fix

Author: wil93

cms/__init__.py

@@ -33,6 +33,7 @@
     "TOKEN_MODE_DISABLED", "TOKEN_MODE_FINITE", "TOKEN_MODE_INFINITE",
     "TOKEN_MODE_MIXED",
     "FEEDBACK_LEVEL_FULL", "FEEDBACK_LEVEL_RESTRICTED",
+    "FEEDBACK_LEVEL_OI_RESTRICTED",
     # log
     # Nothing intended for external use, no need to advertise anything.
     # conf
@@ -68,6 +69,9 @@
 # Restricted set of information (no killing signal, time or memory, testcases
 # can be omitted).
 FEEDBACK_LEVEL_RESTRICTED = "restricted"
+# Restricted set of information in accordance with the Contest Rules of
+# the International Olympiad of Informatics
+FEEDBACK_LEVEL_OI_RESTRICTED = "oi_restricted"
 
 
 from .conf import Address, ServiceCoord, ConfigError, async_config, config

cms/db/contest.py

@@ -101,6 +101,12 @@ class Contest(Base):
         nullable=False,
         default=True)
 
+    # Allow unofficial submission before analysis mode
+    allow_unofficial_submission_before_analysis_mode = Column(
+        Boolean,
+        nullable=False,
+        default=False)
+
     # Whether to prevent hidden participations to log in.
     block_hidden_participations: bool = Column(
         Boolean,

cms/db/submission.py

@@ -364,6 +364,11 @@ class SubmissionResult(Base):
         JSONB,
         nullable=True)
 
+    # Time when the submission is scored for the first time
+    scored_at = Column(
+        DateTime,
+        nullable=True)
+
     # The same as the last two fields, but only showing information
     # visible to the user (assuming they did not use a token on this
     # submission).

cms/db/task.py

@@ -36,7 +36,7 @@
     Interval, Enum, BigInteger
 
 from cms import TOKEN_MODE_DISABLED, TOKEN_MODE_FINITE, TOKEN_MODE_INFINITE, \
-    FEEDBACK_LEVEL_FULL, FEEDBACK_LEVEL_RESTRICTED
+    FEEDBACK_LEVEL_FULL, FEEDBACK_LEVEL_RESTRICTED, FEEDBACK_LEVEL_OI_RESTRICTED
 from cmscommon.constants import \
     SCORE_MODE_MAX, SCORE_MODE_MAX_SUBTASK, SCORE_MODE_MAX_TOKENED_LAST
 from . import Codename, Filename, FilenameSchemaArray, Digest, Base, Contest
@@ -199,6 +199,7 @@ class Task(Base):
     # reverse engineer task data.
     feedback_level: str = Column(
         Enum(FEEDBACK_LEVEL_FULL, FEEDBACK_LEVEL_RESTRICTED,
+             FEEDBACK_LEVEL_OI_RESTRICTED,
              name="feedback_level"),
         nullable=False,
         default=FEEDBACK_LEVEL_RESTRICTED)

cms/grading/scoretypes/abc.py

@@ -274,9 +274,13 @@ class ScoreTypeGroup(ScoreTypeAlone):
             </thead>
             <tbody>
     {% for tc in st["testcases"] %}
-        {% if "outcome" in tc
-               and (feedback_level == FEEDBACK_LEVEL_FULL
-                    or tc["show_in_restricted_feedback"]) %}
+        {% set show_tc = "outcome" in tc
+               and ((feedback_level == FEEDBACK_LEVEL_FULL)
+               or (feedback_level == FEEDBACK_LEVEL_RESTRICTED
+               and tc["show_in_restricted_feedback"])
+               or (feedback_level == FEEDBACK_LEVEL_OI_RESTRICTED
+               and tc["show_in_oi_restricted_feedback"])) %}
+        {% if show_tc %}
             {% if tc["outcome"] == "Correct" %}
                 <tr class="correct">
             {% elif tc["outcome"] == "Not correct" %}
@@ -307,16 +311,18 @@ class ScoreTypeGroup(ScoreTypeAlone):
             {% endif %}
                 </tr>
         {% else %}
+            {% if feedback_level != FEEDBACK_LEVEL_OI_RESTRICTED %}
                 <tr class="undefined">
                     <td class="idx">{{ loop.index }}</td>
-            {% if feedback_level == FEEDBACK_LEVEL_FULL %}
+                {% if feedback_level == FEEDBACK_LEVEL_FULL %}
                     <td colspan="4">
-            {% else %}
+                {% else %}
                     <td colspan="2">
-            {% endif %}
+                {% endif %}
                         {% trans %}N/A{% endtrans %}
                     </td>
                 </tr>
+            {% endif %}
         {% endif %}
     {% endfor %}
             </tbody>
@@ -412,25 +418,33 @@ def compute_score(self, submission_result):
 
             testcases = []
             public_testcases = []
-            previous_tc_all_correct = True
+            # In "Restricted" feedback mode:
+            #   show until the first testcase with a lowest score
+            # In "OI Restricted" feedback mode:
+            #   show only the first testcase with a lowest score
+
+            tc_first_lowest_idx = None
+            tc_first_lowest_score = None
             for tc_idx in target:
+                tc_score = float(evaluations[tc_idx].outcome)
                 tc_outcome = self.get_public_outcome(
-                    float(evaluations[tc_idx].outcome), parameter)
+                    tc_score, parameter)
 
                 testcases.append({
                     "idx": tc_idx,
                     "outcome": tc_outcome,
                     "text": evaluations[tc_idx].text,
                     "time": evaluations[tc_idx].execution_time,
                     "memory": evaluations[tc_idx].execution_memory,
-                    "show_in_restricted_feedback": previous_tc_all_correct})
+                    "show_in_restricted_feedback": self.public_testcases[tc_idx],
+                    "show_in_oi_restricted_feedback": self.public_testcases[tc_idx]})
+
                 if self.public_testcases[tc_idx]:
                     public_testcases.append(testcases[-1])
-                    # Only block restricted feedback if this is the first
-                    # *public* non-correct testcase, otherwise we might be
-                    # leaking info on private testcases.
-                    if tc_outcome != "Correct":
-                        previous_tc_all_correct = False
+                    if tc_first_lowest_score is None or \
+                            tc_score < tc_first_lowest_score:
+                        tc_first_lowest_idx = tc_idx
+                        tc_first_lowest_score = tc_score
                 else:
                     public_testcases.append({"idx": tc_idx})
 
@@ -439,6 +453,15 @@ def compute_score(self, submission_result):
                 parameter)
             st_score = st_score_fraction * parameter[0]
 
+            if tc_first_lowest_idx is not None and st_score_fraction < 1.0:
+                for tc in testcases:
+                    if not self.public_testcases[tc["idx"]]:
+                        continue
+                    tc["show_in_restricted_feedback"] = (
+                        tc["idx"] <= tc_first_lowest_idx)
+                    tc["show_in_oi_restricted_feedback"] = (
+                        tc["idx"] == tc_first_lowest_idx)
+
             score += st_score
             subtasks.append({
                 "idx": st_idx + 1,

cms/grading/steps/stats.py

@@ -103,19 +103,40 @@ def merge_execution_stats(
     if first_stats is None:
         return second_stats.copy()
 
+    Stat = typing.TypeVar('Stat', int, float)
+
+    def safe_sum(x: Stat | None, y: Stat | None) -> Stat | None:
+        if x is None:
+            return y
+        elif y is None:
+            return x
+        else:
+            return x + y
+
+    def safe_max(x: Stat | None, y: Stat | None) -> Stat | None:
+        if x is None:
+            return y
+        elif y is None:
+            return x
+        else:
+            return max(x, y)
+
     ret = first_stats.copy()
-    ret["execution_time"] += second_stats["execution_time"]
+    ret["execution_time"] = safe_sum(ret["execution_time"],
+                                     second_stats["execution_time"])
 
     if concurrent:
-        ret["execution_wall_clock_time"] = max(
+        ret["execution_wall_clock_time"] = safe_max(
             ret["execution_wall_clock_time"],
             second_stats["execution_wall_clock_time"])
-        ret["execution_memory"] += second_stats["execution_memory"]
+        ret["execution_memory"] = safe_sum(ret["execution_memory"],
+                                           second_stats["execution_memory"])
     else:
-        ret["execution_wall_clock_time"] += \
-            second_stats["execution_wall_clock_time"]
-        ret["execution_memory"] = max(ret["execution_memory"],
-                                      second_stats["execution_memory"])
+        ret["execution_wall_clock_time"] = safe_sum(
+            ret["execution_wall_clock_time"],
+            second_stats["execution_wall_clock_time"])
+        ret["execution_memory"] = safe_max(ret["execution_memory"],
+                                           second_stats["execution_memory"])
 
     if first_stats["exit_status"] == Sandbox.EXIT_OK:
         ret["exit_status"] = second_stats["exit_status"]

cms/grading/steps/trusted.py

@@ -36,6 +36,7 @@
 """
 
 import logging
+import re
 
 from cms import config
 from cms.grading.Sandbox import Sandbox
@@ -55,24 +56,25 @@
 CHECKER_FILENAME = "checker"
 
 
-def _filter_ansi_escape(string: str) -> str:
-    """Filter out ANSI commands from the given string.
+def _sanitize_message(string: str) -> str:
+    """Sanitize a message read from manager output.
+
+    Percent signs are escaped (so they are not treated as formatting specifiers
+    later). Control characters are rejected.
 
     string: string to process.
 
-    return: string with ANSI commands stripped.
+    return: sanitized string.
+
+    raise (ValueError): if invalid characters were found.
 
     """
-    ansi_mode = False
-    res = ''
-    for char in string:
-        if char == u'\033':
-            ansi_mode = True
-        if not ansi_mode:
-            res += char
-        if char == u'm':
-            ansi_mode = False
-    return res
+    match = re.search('[\x00-\x08\x0a-\x1f\x7f-\xbf]', string)
+    if match:
+        ch = ord(match[0])
+        raise ValueError(f'Invalid character in outcome: 0x{ch:02x}')
+
+    return string.replace('%', '%%')
 
 
 def extract_outcome_and_text(sandbox: Sandbox) -> tuple[float, list[str]]:
@@ -98,10 +100,13 @@ def extract_outcome_and_text(sandbox: Sandbox) -> tuple[float, list[str]]:
 
     with sandbox.get_file_text(sandbox.stderr_file) as stderr_file:
         try:
-            text = _filter_ansi_escape(stderr_file.readline().strip())
+            text = _sanitize_message(stderr_file.readline().strip())
         except UnicodeDecodeError as error:
             logger.error("Manager stderr (text) is not valid UTF-8. %r", error)
             raise ValueError("Cannot decode the text.")
+        except ValueError as error:
+            logger.error("Manager stderr (text) is malformed. %r", error)
+            raise error
 
     try:
         outcome = float(outcome)

cms/log.py

@@ -393,16 +393,16 @@ def process(self, msg: str, kwargs: dict):
 
 
 # Install a shell handler.
-shell_handler = StreamHandler(sys.stdout)
+shell_handler = StreamHandler(sys.stderr)
 shell_handler.setLevel(logging.INFO)
-shell_handler.setFormatter(CustomFormatter(has_color_support(sys.stdout)))
+shell_handler.setFormatter(CustomFormatter(has_color_support(sys.stderr)))
 root_logger.addHandler(shell_handler)
 
 
 def set_detailed_logs(detailed: bool):
     """Set or unset the shell logs to detailed."""
     global shell_handler
-    color = has_color_support(sys.stdout)
+    color = has_color_support(sys.stderr)
     formatter = DetailedFormatter(color) \
         if detailed else CustomFormatter(color)
     shell_handler.setFormatter(formatter)

cms/server/admin/handlers/contest.py

@@ -96,6 +96,7 @@ def post(self, contest_id: str):
             self.get_bool(attrs, "submissions_download_allowed")
             self.get_bool(attrs, "allow_questions")
             self.get_bool(attrs, "allow_user_tests")
+            self.get_bool(attrs, "allow_unofficial_submission_before_analysis_mode")
             self.get_bool(attrs, "block_hidden_participations")
             self.get_bool(attrs, "allow_password_authentication")
             self.get_bool(attrs, "allow_registration")

cms/server/admin/handlers/contestquestion.py

@@ -71,9 +71,8 @@ class QuestionReplyHandler(BaseHandler):
     QUICK_ANSWERS = {
         "yes": "Yes",
         "no": "No",
-        "answered": "Answered in task description",
-        "invalid": "Invalid question",
-        "nocomment": "No comment",
+        "invalid": "Invalid Question (not a Yes/No Question)",
+        "nocomment": "No Comment/Please refer to task statement",
     }
 
     @require_permission(BaseHandler.PERMISSION_MESSAGING)
@@ -86,7 +85,8 @@ def post(self, contest_id, question_id):
         if self.contest is not question.participation.contest:
             raise tornado_web.HTTPError(404)
 
-        reply_subject_code: str = self.get_argument("reply_question_quick_answer", "")
+        reply_subject_code: str = self.get_argument(
+            "reply_question_quick_answer", "")
         question.reply_text = self.get_argument("reply_question_text", "")
 
         # Ignore invalid answers