Make Submission work with pydantic.

Author: fkdosilovic

examples/1000_http_callback_aka_webhook/main.py

@@ -1,18 +1,10 @@
 #!/usr/bin/env python3
-from fastapi import FastAPI, Depends
-from pydantic import BaseModel
-
-import uvicorn
 import asyncio
-import judge0
 
+import judge0
 
-class CallbackResponse(BaseModel):
-    created_at: str
-    finished_at: str
-    language: dict
-    status: dict
-    stdout: str
+import uvicorn
+from fastapi import Depends, FastAPI
 
 
 class AppContext:
@@ -47,13 +39,14 @@ async def root(app_context=Depends(get_app_context)):
 
 
 @app.put("/callback")
-async def callback(response: CallbackResponse):
+async def callback(response: judge0.Submission):
     print(f"Received: {response}")
 
 
-# We are using free service from https://localhost.run to get a public URL for our local server.
-# This approach is not recommended for production use. It is only for demonstration purposes
-# since domain names change regularly and there is a speed limit for the free service.
+# We are using free service from https://localhost.run to get a public URL for
+# our local server. This approach is not recommended for production use. It is
+# only for demonstration purposes since domain names change regularly and there
+# is a speed limit for the free service.
 async def run_ssh_tunnel():
     app_context = get_app_context()
 
@@ -69,7 +62,9 @@ async def run_ssh_tunnel():
     ]
 
     process = await asyncio.create_subprocess_exec(
-        *command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.STDOUT
+        *command,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
     )
 
     while True:
@@ -86,7 +81,11 @@ async def run_ssh_tunnel():
 
 async def run_server():
     config = uvicorn.Config(
-        app, host="127.0.0.1", port=LOCAL_SERVER_PORT, workers=5, loop="asyncio"
+        app,
+        host="127.0.0.1",
+        port=LOCAL_SERVER_PORT,
+        workers=5,
+        loop="asyncio",
     )
     server = uvicorn.Server(config)
     await server.serve()

src/judge0/common.py

@@ -17,11 +17,13 @@ def encode(content: Union[bytes, str, Encodeable]) -> str:
 
 def decode(content: Union[bytes, str]) -> str:
     if isinstance(content, bytes):
-        return b64decode(content.decode(errors="backslashreplace")).decode(
+        return b64decode(
+            content.decode(errors="backslashreplace"), validate=True
+        ).decode(errors="backslashreplace")
+    if isinstance(content, str):
+        return b64decode(content.encode(), validate=True).decode(
             errors="backslashreplace"
         )
-    if isinstance(content, str):
-        return b64decode(content.encode()).decode(errors="backslashreplace")
     raise ValueError(f"Unsupported type. Expected bytes or str, got {type(content)}!")
 
 

src/judge0/submission.py

@@ -2,7 +2,7 @@
 from datetime import datetime
 from typing import Any, Optional, Union
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict, Field, field_validator, UUID4
 
 from .base_types import Iterable, LanguageAlias, Status
 from .common import decode, encode
@@ -18,7 +18,7 @@
     "stdout",
     "stderr",
     "compile_output",
-    "post_execution_filesystem",
+    # "post_execution_filesystem",
 }
 ENCODED_FIELDS = ENCODED_REQUEST_FIELDS | ENCODED_RESPONSE_FIELDS
 EXTRA_REQUEST_FIELDS = {
@@ -126,42 +126,86 @@ class Submission(BaseModel):
         URL for a callback to report execution results or status.
     """
 
-    source_code: Optional[str] = None
-    language: Union[LanguageAlias, int] = LanguageAlias.PYTHON
-    additional_files: Optional[str] = None
-    compiler_options: Optional[str] = None
-    command_line_arguments: Optional[str] = None
-    stdin: Optional[str] = None
-    expected_output: Optional[str] = None
-    cpu_time_limit: Optional[float] = None
-    cpu_extra_time: Optional[float] = None
-    wall_time_limit: Optional[float] = None
-    memory_limit: Optional[float] = None
-    stack_limit: Optional[int] = None
-    max_processes_and_or_threads: Optional[int] = None
-    enable_per_process_and_thread_time_limit: Optional[bool] = None
-    enable_per_process_and_thread_memory_limit: Optional[bool] = None
-    max_file_size: Optional[int] = None
-    redirect_stderr_to_stdout: Optional[bool] = None
-    enable_network: Optional[bool] = None
-    number_of_runs: Optional[int] = None
-    callback_url: Optional[str] = None
+    source_code: Optional[str] = Field(default=None, repr=True)
+    language: Union[LanguageAlias, int] = Field(
+        default=LanguageAlias.PYTHON,
+        repr=True,
+    )
+    additional_files: Optional[str] = Field(default=None, repr=True)
+    compiler_options: Optional[str] = Field(default=None, repr=True)
+    command_line_arguments: Optional[str] = Field(default=None, repr=True)
+    stdin: Optional[str] = Field(default=None, repr=True)
+    expected_output: Optional[str] = Field(default=None, repr=True)
+    cpu_time_limit: Optional[float] = Field(default=None, repr=True)
+    cpu_extra_time: Optional[float] = Field(default=None, repr=True)
+    wall_time_limit: Optional[float] = Field(default=None, repr=True)
+    memory_limit: Optional[float] = Field(default=None, repr=True)
+    stack_limit: Optional[int] = Field(default=None, repr=True)
+    max_processes_and_or_threads: Optional[int] = Field(default=None, repr=True)
+    enable_per_process_and_thread_time_limit: Optional[bool] = Field(
+        default=None, repr=True
+    )
+    enable_per_process_and_thread_memory_limit: Optional[bool] = Field(
+        default=None, repr=True
+    )
+    max_file_size: Optional[int] = Field(default=None, repr=True)
+    redirect_stderr_to_stdout: Optional[bool] = Field(default=None, repr=True)
+    enable_network: Optional[bool] = Field(default=None, repr=True)
+    number_of_runs: Optional[int] = Field(default=None, repr=True)
+    callback_url: Optional[str] = Field(default=None, repr=True)
 
     # Post-execution submission attributes.
-    stdout: Optional[str] = None
-    stderr: Optional[str] = None
-    compile_output: Optional[str] = None
-    message: Optional[str] = None
-    exit_code: Optional[int] = None
-    exit_signal: Optional[int] = None
-    status: Optional[Status] = None
-    created_at: Optional[datetime] = None
-    finished_at: Optional[datetime] = None
-    token: str = ""
-    time: Optional[float] = None
-    wall_time: Optional[float] = None
-    memory: Optional[float] = None
-    post_execution_filesystem: Optional[Filesystem] = None
+    stdout: Optional[str] = Field(default=None, repr=True)
+    stderr: Optional[str] = Field(default=None, repr=True)
+    compile_output: Optional[str] = Field(default=None, repr=True)
+    message: Optional[str] = Field(default=None, repr=True)
+    exit_code: Optional[int] = Field(default=None, repr=True)
+    exit_signal: Optional[int] = Field(default=None, repr=True)
+    status: Optional[Status] = Field(default=None, repr=True)
+    created_at: Optional[datetime] = Field(default=None, repr=True)
+    finished_at: Optional[datetime] = Field(default=None, repr=True)
+    token: Optional[UUID4] = Field(default=None, repr=True)
+    time: Optional[float] = Field(default=None, repr=True)
+    wall_time: Optional[float] = Field(default=None, repr=True)
+    memory: Optional[float] = Field(default=None, repr=True)
+    post_execution_filesystem: Optional[Filesystem] = Field(default=None, repr=True)
+
+    model_config = ConfigDict(extra="ignore")
+
+    @field_validator(*ENCODED_FIELDS, mode="before")
+    @classmethod
+    def process_encoded_fields(cls, value: str) -> Optional[str]:
+        """Validate all encoded attributes."""
+        if value is None:
+            return None
+        else:
+            try:
+                return decode(value)
+            except Exception:
+                return value
+
+    @field_validator("post_execution_filesystem", mode="before")
+    @classmethod
+    def process_post_execution_filesystem(cls, content: str) -> Filesystem:
+        """Validate post_execution_filesystem attribute."""
+        return Filesystem(content=content)
+
+    @field_validator("status", mode="before")
+    @classmethod
+    def process_status(cls, value: dict) -> Status:
+        """Validate status attribute."""
+        return Status(value["id"])
+
+    @field_validator("language", mode="before")
+    @classmethod
+    def process_language(
+        cls, value: Union[LanguageAlias, dict]
+    ) -> Union[LanguageAlias, int]:
+        """Validate status attribute."""
+        if isinstance(value, dict):
+            return value["id"]
+        else:
+            return value
 
     def set_attributes(self, attributes: dict[str, Any]) -> None:
         """Set Submissions attributes while taking into account different
@@ -177,7 +221,7 @@ def set_attributes(self, attributes: dict[str, Any]) -> None:
             if attr in SKIP_FIELDS:
                 continue
 
-            if attr in ENCODED_FIELDS and attr not in ("post_execution_filesystem",):
+            if attr in ENCODED_FIELDS:
                 value = decode(value) if value else None
             elif attr == "status":
                 value = Status(value["id"])
@@ -229,10 +273,6 @@ def pre_execution_copy(self) -> "Submission":
             setattr(new_submission, attr, copy.deepcopy(getattr(self, attr)))
         return new_submission
 
-    def __repr__(self) -> str:
-        arguments = ", ".join(f"{field}={getattr(self, field)!r}" for field in FIELDS)
-        return f"{self.__class__.__name__}({arguments})"
-
     def __iter__(self):
         if self.post_execution_filesystem is None:
             return iter([])

tests/test_submission.py

@@ -1,6 +1,53 @@
 from judge0 import Status, Submission, wait
 
 
+def test_from_json():
+    submission_dict = {
+        "source_code": "cHJpbnQoJ0hlbGxvLCBXb3JsZCEnKQ==",
+        "language_id": 100,
+        "stdin": None,
+        "expected_output": None,
+        "stdout": "SGVsbG8sIFdvcmxkIQo=",
+        "status_id": 3,
+        "created_at": "2024-12-09T17:22:55.662Z",
+        "finished_at": "2024-12-09T17:22:56.045Z",
+        "time": "0.152",
+        "memory": 13740,
+        "stderr": None,
+        "token": "5513d8ca-975b-4499-b54b-342f1952d00e",
+        "number_of_runs": 1,
+        "cpu_time_limit": "5.0",
+        "cpu_extra_time": "1.0",
+        "wall_time_limit": "10.0",
+        "memory_limit": 128000,
+        "stack_limit": 64000,
+        "max_processes_and_or_threads": 60,
+        "enable_per_process_and_thread_time_limit": False,
+        "enable_per_process_and_thread_memory_limit": False,
+        "max_file_size": 1024,
+        "compile_output": None,
+        "exit_code": 0,
+        "exit_signal": None,
+        "message": None,
+        "wall_time": "0.17",
+        "compiler_options": None,
+        "command_line_arguments": None,
+        "redirect_stderr_to_stdout": False,
+        "callback_url": None,
+        "additional_files": None,
+        "enable_network": False,
+        "post_execution_filesystem": "UEsDBBQACAAIANyKiVkAAAAAAAAAABYAAAAJABwAc"
+        "2NyaXB0LnB5VVQJAANvJ1dncCdXZ3V4CwABBOgDAAAE6AMAACsoyswr0VD3SM3JyddRCM8v"
+        "yklRVNcEAFBLBwgynNLKGAAAABYAAABQSwECHgMUAAgACADciolZMpzSyhgAAAAWAAAACQA"
+        "YAAAAAAABAAAApIEAAAAAc2NyaXB0LnB5VVQFAANvJ1dndXgLAAEE6AMAAAToAwAAUEsFBg"
+        "AAAAABAAEATwAAAGsAAAAAAA==",
+        "status": {"id": 3, "description": "Accepted"},
+        "language": {"id": 100, "name": "Python (3.12.5)"},
+    }
+
+    _ = Submission(**submission_dict)
+
+
 def test_status_before_and_after_submission(request):
     client = request.getfixturevalue("judge0_ce_client")
     submission = Submission(source_code='print("Hello World!")')