fix: CI errors

Author: pkulkark

ai_eval/backends/base.py

@@ -1,3 +1,5 @@
+"""Abstract interfaces for code execution backends."""
+
 from abc import ABC, abstractmethod
 from typing import Dict, Any
 
@@ -6,39 +8,32 @@ class CodeExecutionBackend(ABC):
     """
     Abstract base class for code execution backends.
     """
-    
     @abstractmethod
     def submit_code(self, code: str, language_label: str) -> str:
         """
         Submit code for execution.
-        
+
         Args:
             code: The source code to execute
             language_label: Human-readable language label (e.g., "Python").
                 Implementations map this to their own representation.
-            
+
         Returns:
             str: Submission ID for retrieving results
         """
-        pass
-    
+
     @abstractmethod
     def get_result(self, submission_id: str) -> Dict[str, Any]:
         """
         Get execution result for a submission.
-        
+
         Args:
             submission_id: The submission ID from submit_code()
-            
+
         Returns:
             dict: Execution result containing:
                 - status: dict with 'id' and 'description'
                 - stdout: str or None
                 - stderr: str or None
                 - compile_output: str or None
-                - time: str or None
-                - memory: str or None
         """
-        pass
-    
-    

ai_eval/backends/custom.py

@@ -1,20 +1,22 @@
-import requests
+"""Custom service code execution backend."""
+
 from typing import Dict, Any, Optional
+import requests
+from ai_eval.utils import SUPPORTED_LANGUAGE_MAP, LanguageLabels, DEFAULT_HTTP_TIMEOUT
 from .base import CodeExecutionBackend
 
 
 class CustomServiceBackend(CodeExecutionBackend):
     """
     Generic custom code execution backend.
     """
-    
-    def __init__(
+    def __init__(   # pylint: disable=too-many-positional-arguments
         self,
         submit_endpoint: str,
         results_endpoint: str,
         languages_endpoint: str,
         api_key: str = "",
-        timeout: int = 30,
+        timeout: int = DEFAULT_HTTP_TIMEOUT,
         auth_header_name: str = "Authorization",
         auth_scheme: Optional[str] = "Bearer",
     ):
@@ -25,8 +27,8 @@ def __init__(
         self.timeout = timeout
         self.auth_header_name = auth_header_name
         self.auth_scheme = auth_scheme
-        self._validate_languages()
-    
+        self._languages_validated = False
+
     def _get_headers(self) -> Dict[str, str]:
         """
         Get headers for API requests.
@@ -38,7 +40,7 @@ def _get_headers(self) -> Dict[str, str]:
             else:
                 headers[self.auth_header_name] = self.api_key
         return headers
-    
+
     def _validate_languages(self):
         """
         Validate that static languages are supported by the custom service.
@@ -50,43 +52,56 @@ def _validate_languages(self):
                 timeout=self.timeout
             )
             response.raise_for_status()
-            
+
             service_languages = response.json()
             # Expected format: [{"id": "92", "name": "Python"}, ...] or [{"id": "python", "name": "Python"}, ...]
             service_language_names = {lang['name'].lower() for lang in service_languages}
-            
-            from ai_eval.utils import SUPPORTED_LANGUAGE_MAP, LanguageLabels
-            static_language_names = {name.lower() for name in SUPPORTED_LANGUAGE_MAP.keys() 
-                                   if name != LanguageLabels.HTML_CSS}
-            
+
+            static_language_names = {
+                name.lower() for name in SUPPORTED_LANGUAGE_MAP
+                if name != LanguageLabels.HTML_CSS
+            }
+
             unsupported = static_language_names - service_language_names
             if unsupported:
                 raise ValueError(
                     f"Custom service does not support languages: {', '.join(unsupported)}. "
                 )
-            
+
         except (requests.RequestException, KeyError, ValueError) as e:
-            raise ValueError(f"Failed to validate supported languages: {e}")
-    
+            raise ValueError(f"Failed to validate supported languages: {e}") from e
+
+    def _ensure_languages_validated(self):
+        """Validate supported languages lazily once, if endpoint is configured."""
+        if self._languages_validated:
+            return
+        if not self.languages_endpoint:
+            # No endpoint provided; skip validation.
+            self._languages_validated = True
+            return
+        self._validate_languages()
+        self._languages_validated = True
+
     def submit_code(self, code: str, language_label: str) -> str:
         """
         Submit code to custom service for execution.
         """
+        self._ensure_languages_validated()
         # By default, send the language label; services will need to map as needed
         payload = {
             'code': code,
             'language': language_label
         }
-        
+
         try:
             response = requests.post(
-                self.submit_endpoint, 
-                json=payload, 
+                self.submit_endpoint,
+                json=payload,
                 headers=self._get_headers(),
                 timeout=self.timeout
             )
             response.raise_for_status()
-            
+
             # Handle different response formats
             result = response.json()
             if 'submission_id' in result:
@@ -95,28 +110,29 @@ def submit_code(self, code: str, language_label: str) -> str:
                 return str(result['id'])
             else:
                 raise ValueError("Custom service response missing submission ID")
-                
+
         except requests.RequestException as e:
-            raise ValueError(f"Failed to submit code for execution: {e}")
+            raise ValueError(f"Failed to submit code for execution: {e}") from e
         except (KeyError, ValueError) as e:
-            raise ValueError(f"Invalid response from custom service: {e}")
-    
+            raise ValueError(f"Invalid response from custom service: {e}") from e
+
     def get_result(self, submission_id: str) -> Dict[str, Any]:
         """
         Get execution result from custom service.
         """
+        self._ensure_languages_validated()
         url = self.results_endpoint.format(submission_id=submission_id)
-        
+
         try:
             response = requests.get(
                 url,
                 headers=self._get_headers(),
                 timeout=self.timeout
             )
             response.raise_for_status()
-            
+
             result = response.json()
-            
+
             # Map custom service response to standard format
             return {
                 'status': {
@@ -127,9 +143,8 @@ def get_result(self, submission_id: str) -> Dict[str, Any]:
                 'stderr': result.get('stderr'),
                 'compile_output': result.get('compile_error')
             }
-            
+
         except requests.RequestException as e:
-            raise ValueError(f"Failed to get submission result: {e}")
+            raise ValueError(f"Failed to get submission result: {e}") from e
         except (KeyError, ValueError) as e:
-            raise ValueError(f"Invalid response from custom service: {e}")
-    
+            raise ValueError(f"Invalid response from custom service: {e}") from e

ai_eval/backends/factory.py

@@ -1,4 +1,6 @@
-from django.conf import settings
+"""Backend selection factory."""
+
+import django.conf as django_conf
 from .judge0 import Judge0Backend
 from .custom import CustomServiceBackend
 
@@ -7,20 +9,21 @@ class BackendFactory:
     """
     Factory for creating code execution backends.
     """
-    
     @classmethod
     def get_backend(cls, api_key: str = ""):
         """
         Get the appropriate backend based on Django settings.
-        
+
         Args:
             api_key: Judge0 API key (only used for judge0 backend)
-            
+
         Returns:
             CodeExecutionBackend: Configured backend instance
         """
-        backend_config = getattr(settings, 'AI_EVAL_CODE_EXECUTION_BACKEND', {})
-        
+        backend_config = getattr(
+            django_conf.settings, 'AI_EVAL_CODE_EXECUTION_BACKEND', {}
+        )
+
         if backend_config.get('backend') == 'custom':
             config = backend_config.get('custom_config', {})
             return CustomServiceBackend(
@@ -32,7 +35,7 @@ def get_backend(cls, api_key: str = ""):
                 auth_header_name=config.get('auth_header_name', 'Authorization'),
                 auth_scheme=config.get('auth_scheme', 'Bearer'),
             )
-        
+
         # Default to judge0 backend
         judge0_config = backend_config.get('judge0_config', {})
         return Judge0Backend(

ai_eval/backends/judge0.py

@@ -1,25 +1,26 @@
-import requests
+"""Judge0 code execution backend."""
+
 from typing import Dict, Any
+import requests
+from ai_eval.utils import SUPPORTED_LANGUAGE_MAP, DEFAULT_HTTP_TIMEOUT
 from .base import CodeExecutionBackend
-from ai_eval.utils import SUPPORTED_LANGUAGE_MAP, LanguageLabels
 
 
 class Judge0Backend(CodeExecutionBackend):
     """
     Judge0 code execution backend.
     """
-    
     def __init__(self, api_key: str = "", base_url: str = None):
         self.api_key = api_key
         self.base_url = base_url or "https://judge0-ce.p.rapidapi.com"
-    
+
     def submit_code(self, code: str, language_label: str) -> str:
         """
         Submit code to Judge0 for execution.
         """
         if not self.api_key:
             raise ValueError("Judge0 API key is required")
-        
+
         # Map the human-readable label to Judge0 numeric id
         try:
             judge0_id = SUPPORTED_LANGUAGE_MAP[language_label].judge0_id
@@ -35,40 +36,48 @@ def submit_code(self, code: str, language_label: str) -> str:
             'source_code': code,
             'language_id': int(judge0_id)
         }
-        
+
         try:
-            response = requests.post(url, json=payload, headers=headers)
+            response = requests.post(
+                url,
+                json=payload,
+                headers=headers,
+                timeout=DEFAULT_HTTP_TIMEOUT,
+            )
             response.raise_for_status()
-            
+
             result = response.json()
             if 'token' in result:
                 return result['token']
             else:
                 raise ValueError("Judge0 response missing submission token")
-                
+
         except requests.RequestException as e:
-            raise ValueError(f"Failed to submit code to Judge0: {e}")
+            raise ValueError(f"Failed to submit code to Judge0: {e}") from e
         except (KeyError, ValueError) as e:
-            raise ValueError(f"Invalid response from Judge0: {e}")
-    
+            raise ValueError(f"Invalid response from Judge0: {e}") from e
+
     def get_result(self, submission_id: str) -> Dict[str, Any]:
         """
         Get execution result from Judge0.
         """
         if not self.api_key:
             raise ValueError("Judge0 API key is required")
-        
+
         url = f"{self.base_url}/submissions/{submission_id}"
         headers = {'x-rapidapi-key': self.api_key}
-        
+
         try:
-            response = requests.get(url, headers=headers)
+            response = requests.get(
+                url,
+                headers=headers,
+                timeout=DEFAULT_HTTP_TIMEOUT,
+            )
             response.raise_for_status()
-            
+
             return response.json()
-            
+
         except requests.RequestException as e:
-            raise ValueError(f"Failed to get submission result from Judge0: {e}")
+            raise ValueError(f"Failed to get submission result from Judge0: {e}") from e
         except (KeyError, ValueError) as e:
-            raise ValueError(f"Invalid response from Judge0: {e}")
-    
+            raise ValueError(f"Invalid response from Judge0: {e}") from e

ai_eval/coding_ai_eval.py

@@ -3,6 +3,7 @@
 import logging
 import pkg_resources
 
+from django.conf import settings
 from django.utils.translation import gettext_noop as _
 from web_fragments.fragment import Fragment
 from xblock.core import XBlock
@@ -16,7 +17,6 @@
     LanguageLabels,
 )
 from .backends.factory import BackendFactory
-from django.conf import settings
 
 logger = logging.getLogger(__name__)
 

ai_eval/tests/test_ai_eval.py

@@ -321,7 +321,7 @@ def test_custom_backend_language_validation_fails(mock_get):
     """Test CustomServiceBackend raises error for unsupported languages."""
     mock_response = Mock()
     mock_response.json.return_value = [
-{"name": "Python"}  # Only Python supported
+        {"name": "Python"}  # Only Python supported
     ]
     mock_response.raise_for_status = Mock()
     mock_get.return_value = mock_response