Fix all black and ruff issues

Author: bnmnetp

bases/rsptx/admin_server_api/routers/instructor.py

@@ -1255,9 +1255,7 @@ async def post_create_course_page(
 
         # if invoice is true then we need to create an invoice for the course
         if invoice == "true":
-            res = await create_invoice_request(
-                user.username, projectname, 0.0, user.email
-            )
+            await create_invoice_request(user.username, projectname, 0.0, user.email)
         # Copy attributes from base course
         bc = await fetch_course(coursetype)
         attrs = await fetch_all_course_attributes(bc.id)

bases/rsptx/assignment_server_api/core.py

@@ -22,7 +22,6 @@
 from .routers import student
 from .routers import instructor
 from .routers import peer
-from rsptx.configuration import settings
 from rsptx.exceptions.core import add_exception_handlers
 from rsptx.logging import rslogger
 from rsptx.templates import template_folder

bases/rsptx/book_server_api/routers/coach.py

@@ -208,7 +208,7 @@ async def parsons_scaffolding(request: Request, course: Optional[str]):
     rslogger.warning("CodeTailor: api_token obtained successfully")
     # Start to process the request from activecode.js
     req_bytes = await request.body()
-    req = req_bytes.decode("utf-8")
+    _ = req_bytes.decode("utf-8")
     data = await request.json()
 
     language = data.get("language")  # Capture the question language from the front end

bases/rsptx/book_server_api/routers/personalized_parsons/end_to_end.py

@@ -1,11 +1,15 @@
 # import necessary packages
-from .buggy_code_checker import *
-from .get_personalized_solution import *
-from .evaluate_fixed_code import *
-from .generate_parsons_blocks import *
-from .personalize_parsons import *
-from .token_compare import *
-from .get_parsons_code_distractors import *
+from .buggy_code_checker import student_code_checker
+from .evaluate_fixed_code import (
+    clean_student_code,
+    code_distractor_unittest_evaluation,
+    unittest_evaluation,
+)
+from .generate_parsons_blocks import generate_Parsons_block
+from .get_parsons_code_distractors import generate_code_with_distrator
+from .get_personalized_solution import get_example_solution, get_fixed_code
+from .personalize_parsons import compare_code, personalize_Parsons_block
+from .token_compare import code_similarity_score
 
 
 def get_parsons_help(api_token, language, dict_buggy_code, personalize_level):
@@ -149,7 +153,7 @@ def request_fixed_code_from_openai(
     if not unittest_result:
         return example_solution.lstrip(), "example_solution"
 
-    if unittest_result == True:
+    if unittest_result:
         similarity_personalized = code_similarity_score(
             cleaned_buggy_code, cleaned_fixed_code, language
         )
@@ -248,7 +252,7 @@ def generate_personalized_fixed_code(
             default_test_code,
             unittest_case=unittest_code,
         )
-        if unittest_result != True:
+        if not unittest_result:
             # If the code is not correct, we will TRY to get an example solution first
             example_solution = generate_example_solution(
                 api_token,
@@ -358,7 +362,7 @@ def generate_multi_personalized_Parsons_blocks(
                 unittest_code,
             )
             # If the code with distractors passes the unittest, we will remove the distractor from the distractors list
-            if unittest_flag == True:
+            if unittest_flag:
                 distractors.pop(distractor_correct_line)
 
     if Parsons_type == "Correct":

bases/rsptx/book_server_api/routers/personalized_parsons/evaluate_fixed_code.py

@@ -4,16 +4,11 @@
 from types import ModuleType
 import threading
 import signal
-import subprocess
-import tempfile
-import os
-import shutil
-from unittest import result
 import requests as rq
 import hashlib
 import base64
 import json
-from ..rsproxy import get_jobe_server, settings
+from ..rsproxy import settings
 
 
 class NullOutput:
@@ -504,16 +499,16 @@ def code_distractor_unittest_evaluation(
                 return results.wasSuccessful(), code_with_distrator
             else:
                 return "No starting code", code_with_distrator
-        except:
+        except Exception:
             try:
                 code_with_distrator = fix_indentation(code_with_distrator)
                 results = load_and_run_tests(unittest_case, code_with_distrator)
                 if contain_default_starting_code(starting_code, code_with_distrator):
                     return results.wasSuccessful(), code_with_distrator
                 else:
                     return "No starting code", code_with_distrator
-            except Exception:
-                return False, code_with_distrator
+            except Exception as e:
+                return f"We got errors, {e}", code_with_distrator
 
 
 def clean_student_code(student_code, default_test_code):
@@ -530,7 +525,7 @@ def clean_student_code(student_code, default_test_code):
         cleaned_student_code = remove_default_testline(student_code, default_test_code)
         cleaned_student_code = remove_empty_lines(cleaned_student_code)
         cleaned_student_code = remove_python_comments(cleaned_student_code)
-    except:
+    except Exception:
         cleaned_student_code = student_code
 
     return cleaned_student_code

bases/rsptx/book_server_api/routers/personalized_parsons/generate_parsons_blocks.py

@@ -215,15 +215,15 @@ def generate_partial_Parsons(
         line_indentation = fixed_line_code[
             : len(fixed_line_code) - len(fixed_line_code.lstrip())
         ]
-        if type(distractor_tuple_dict[fixed_line_key]) == tuple:
+        if type(distractor_tuple_dict[fixed_line_key]) is tuple:
             distractor_tuple_dict[fixed_line_key] = (
                 fixed_line_key[0] + 0.5,
                 fixed_line_key[0],
                 line_indentation
                 + distractor_tuple_dict[fixed_line_key][2].strip()
                 + " #paired",
             )
-        elif type(distractor_tuple_dict[fixed_line_key]) == str:
+        elif type(distractor_tuple_dict[fixed_line_key]) is str:
             distractor_tuple_dict[fixed_line_key] = (
                 fixed_line_key[0] + 0.5,
                 fixed_line_key[0],
@@ -257,10 +257,10 @@ def keep_last_hash_tag_lines(input_string, hash_tag):
     output_lines = []
     found_last_settled = False
     for line in reversed(lines):
-        if (hash_tag in line) & (not found_last_settled):
+        if (hash_tag in line) and not found_last_settled:
             output_lines.append(line)
             found_last_settled = True
-        elif (hash_tag in line) & (found_last_settled == True):
+        elif (hash_tag in line) and found_last_settled:
             line = line.replace(hash_tag, "")
             output_lines.append(line)
         else:

bases/rsptx/book_server_api/routers/personalized_parsons/get_personalized_solution.py

@@ -1,7 +1,7 @@
 from openai import OpenAI
 import re
 
-from .evaluate_fixed_code import *
+from .evaluate_fixed_code import clean_student_code, unittest_evaluation
 
 # Below is the system message as part of the prompt to generate the fixed code
 system_message = """
@@ -263,7 +263,7 @@ def get_example_solution(api_token, language, problem_description, unittest_code
     unittest_result, cleaned_LLM_example_code = unittest_evaluation(
         language, LLM_example_code, "", "", unittest_case=unittest_code
     )
-    if unittest_result == True:
+    if unittest_result:
         # LLM_example_code is correct
         return cleaned_LLM_example_code
     else:

bases/rsptx/book_server_api/routers/personalized_parsons/personalize_parsons.py

@@ -1,7 +1,6 @@
 import difflib
 from collections import namedtuple
-from .generate_parsons_blocks import *
-from .token_compare import *
+from .token_compare import code_similarity_score
 import random
 import re
 
@@ -163,8 +162,8 @@ def find_distractor(fixed_line, removed_lines, language):
         )
         if (
             (similarity > highest_similarity)
-            & (similarity != 1)
-            & (normalized_line_comparision == False)
+            and (similarity != 1)
+            and (not normalized_line_comparision)
         ):
             highest_similarity = similarity
             distractor_line = student_line
@@ -291,12 +290,12 @@ def personalize_Parsons_block(
             normalize_and_compare = normalize_and_compare_lines(
                 pair[0][2], pair[1][2], pair[2]
             )
-            if normalize_and_compare == False:
+            if not normalize_and_compare:
                 # if the student code is wrong (not just a different way to write the same code), generate a distractor using student buggy code
                 distractor_similarity, distractor = find_distractor(
                     pair[1][2], removed_lines, language
                 )
-                if distractor != False:
+                if distractor:
                     distractors[pair[1]] = (distractor_similarity, distractor)
                 else:
                     continue

bases/rsptx/book_server_api/routers/personalized_parsons/token_compare.py

@@ -82,7 +82,7 @@ def code_similarity_score(code1, code2, language):
     try:
         tokens1, type1 = tokenize_code(code1, language)
         tokens2 = following_tokenize_code(code2, type1, language)
-    except:
+    except Exception:
         tokens2, type2 = tokenize_code(code2, language)
         tokens1 = following_tokenize_code(code1, type2, language)