def store_uploaded_file(problem_id, base_path): student_upload = input.get_input(problem_id) filename = input.get_input("{}:filename".format(problem_id)) filename_with_path = Path(base_path) / filename # Stores a copy of this file inside "student" folder with open(filename_with_path, 'w+') as fileUpload: fileUpload.write(student_upload.decode('utf-8')) fileUpload.close() return filename_with_path
def checkStack(q,correct): stack=getStack(input.get_input(q)) response = "" errors = 0 grade = 0 if(stack == correct): grade=100 feedback.set_problem_result("success", q) feedback.set_problem_feedback(response, q) return grade else: if not (stack.startswith( correct[0:1] ) ): response += "The top-label of your stack is incorrect.\n" if not (stack.endswith( correct[-2:] ) ): response += "The bottom label of your stack is incorrect.\n" clist=correct.split(':') slist=stack.split(':') if len(slist) > len(clist): response += "Your answer contains more labels in its stack than the correct one.\n" if len(slist) < len(clist): response += "Your answer contains fewer labels in its stack than the correct one.\n" feedback.set_problem_result("failed", q) response += "Your answer to this question is incorrect.\n" feedback.set_problem_feedback(response, q) return grade
def code_2_string(problem_id): student_upload = input.get_input(problem_id) # Extract the given code into a single String file with no space, leading stuff, etc... # FYI: It is done to simplify the verification as statements in java could be on multiple lines return student_upload.strip().replace("\n", '').replace("\t", '').replace(" ", '')
def checkNPaths(q, correct): path = getPath(input.get_input(q)) list = path.split(',') clist = correct.split(',') errors = 0 grade = 0 response = "" if (len(list) != len(clist)): feedback.set_problem_result("failed", q) response += "Your answer to this question is incorrect. There are {} paths from this router.\n".format( len(clist)) feedback.set_problem_feedback(response, q) return 0 for l in clist: if not (l in list): feedback.set_problem_result("failed", q) response += "Your answer to this question is incorrect.\n" feedback.set_problem_feedback(response, q) return 0 feedback.set_problem_result("success", q) feedback.set_problem_feedback(response, "q1") return 100
def checkSinglePath(q, correct): path = getPath(input.get_input(q)) response = "" errors = 0 grade = 0 if (path == correct): grade = 100 feedback.set_problem_result("success", q) feedback.set_problem_feedback(response, q) return grade else: if not (path.startswith(correct[0:1])): response += "Your answer does not start with {}\n".format( correct[0:1]) if not (path.endswith(correct[-2:])): response += "Your answer does not end with {}\n".format( correct[-2:]) if (',' in path): response += "There is only one path from this router.\n" feedback.set_problem_result("failed", q) response += "Your answer to this question is incorrect. There is only one path from this router to the destination.\n" feedback.set_problem_feedback(response, q) return grade
def get_random(i=0, upper=1000): """Return a random number. :optional param i: The index of the random number of INGInious. :optional param upper: The upper bound of the random number. The default is 1000 """ return int(input.get_input("@random")[i] * upper)
def get_single_line_answer(problem_id): """Return the answer of the student to the question identified by the argument. Return "NONE" if the answer was "None", otherwise return a list of string which is the answer of the student, split by the coma.""" answer = input.get_input(problem_id).upper() if answer == "NONE": return answer answer = ''.join(answer.split()) # remove spaces return answer.split(",")
def contains_prohibited_statement_in_input(prohibited_array, problem_id): student_upload = input.get_input(problem_id) # Extract the given code into a single String file with no space, leading stuff, etc... # FYI: It is done to simplify the verification as statements in java could be on multiple lines source_code_as_string = student_upload.strip().replace("\n", '').replace( "\t", '').replace(" ", '') # if any match , student tried to cheat return any( prohibited_statment.strip().replace(" ", '') in source_code_as_string for prohibited_statment in prohibited_array)
def get_multiple_line_answer(problem_id): """Return the answer of the student to the question identified by the argument. Return "NONE" if the answer was "None", otherwise return a bidimensional list, where the the first list is a split of the answer according to new lines, and the second list according to comas. (Example: "1,2,3\n4,4,6" will return [[1, 2, 3], [4, 5, 6]])""" answer = input.get_input(problem_id).upper() if answer == "NONE": return answer return [''.join(a.split()).split(",") for a in answer.split("\n")]
def initTranslations(): """ Initialise la fonction _() qui permettra de traduire les chaines de caractère. Crée un fichier contenant le code de langue afin que le code Java puisse le récupérer plus tard """ import gettext current_locale = input.get_input("@lang") with open("student/lang","w+") as f: # This file will be used by Java to get the correct lang f.write(current_locale) try: # Try to load translations. language = gettext.translation ('run', 'student/Translations/translations_run', [current_locale]) _ = language.gettext except OSError: _ = gettext.gettext # This will use String id if an error occurs return _
def main(): ##################################### # Load feedback task settings # ##################################### feedback_settings = config.config_file_to_dict(FEEDBACK_REVIEW_PATH) print("FEEDBACK SETTINGS LOADED") ##################################### # Check prohibited statements # ##################################### feedback.handle_prohibited_statements(feedback_settings) print("NO PROHIBITED STATMENT(S) DETECTED") ##################################### # Apply templates # ##################################### # we have a folder where we have only these files helper.apply_templates(PATH_TEMPLATES) print("TEMPLATE(S) APPLIED") ##################################### # CREATE A CLASSES FOLDER # ##################################### Path(PATH_CLASSES).mkdir(parents=True, exist_ok=True) print("SET UP CLASSES FOLDER FOR COMPILATION") ##################################### # EXTERNAL LIBRARIES TO USE ? # ##################################### libs = helper.libraries(feedback_settings["external_libraries"]) ##################################### # COMPILE ALL CODE IN SRC # ##################################### # Possible paths where we could keep source code : src, templates and flavour (optional) folders_to_compile = [PATH_SRC, PATH_TEMPLATES, PATH_FLAVOUR] # For custom structure, for example many packages in folders_to_compile # we need a generic way to find all files to compiles all_folders_to_compile = [ item for sublist in [ helper.find_files_folder_in_path(folder) for folder in folders_to_compile ] for item in sublist ] # Files that must be compiled by javac files_to_compile = [ "{}/{}{}".format(folder, "*", FILE_EXTENSION) for folder in all_folders_to_compile ] compile_cmd = helper.generate_java_command_string(files_to_compile, libs, "javac") print("COMPILING CODE : {}".format(compile_cmd)) result = helper.run_command(compile_cmd) # handle compilation errors feedback.compilation_feedback(result) ##################################### # GENERATE A JAR FILE # ##################################### # We need a manifest in order to make the created jar runnable helper.create_manifest(libs) # Create a jar file create_jar = helper.generate_jar_file() print("GENERATING JAR : {}".format(create_jar)) # WARNING ; JUST FOR JAVA TO NOT MISUNDERSTAND OUR STRUCTURE, we have to change the CWD in the command result = helper.run_command(create_jar, PATH_CLASSES) # For debug the jar construction # print(result.stdout) # handle jar creation errors feedback.jar_feedback(result) ##################################### # RUN TEST RUNNER # ##################################### # invoke runner with classes as arg # in the case of code coverage ( Jacoco ) , we need to generate also the report file (exec ) by the JaCoco agent coverage_required = True if feedback_settings[ "feedback_kind"] == "JaCoCo" else False run_code = helper.generate_java_command_string(JAR_FILE, libs, coverage=coverage_required, is_jar=True) print("RUNNING CODE : {}".format(run_code)) result = helper.run_command(run_code) ##################################### # Show and handle results # ##################################### feedback.result_feedback(result, feedback_settings) ##################################### # Prepare archive for JPlag # ##################################### if feedback_settings["plagiarism"]: student_name = input.get_input("@username") # The files filled by the student are all inside PATH_TEMPLATES files_to_be_tested = helper.find_files_in_path(PATH_TEMPLATES) # Creates the archive like expected by JPlag for student_file in files_to_be_tested: command = "archive -a {} -o {}".format(student_file, student_name) helper.run_command(command, universal_newlines=True)
pre: aucune post: renvoie 'True' si la réponse est juste, 'False' sinon """ answer = answer.strip() answer = list(answer) simp_answer = "(" for el in answer: if el in "-.,1234567890": simp_answer += el simp_answer += ")" return simp_answer == correction answer = input.get_input( "q1") #Remplacez tous les 'q1' par l'ID du sous-problème grade = 0 check = is_coordinates(answer) if check != True: #Renvoie un feedback personnalisé en fonction des erreurs rencontrées feedback.set_problem_result("failed", "q1") #Ici if check == "parenthese": feedback.set_problem_feedback( "Votre réponse doit contenir des parenthèses pour délimiter le point", "q1") #Ici if check == "lettre": feedback.set_problem_feedback( "Votre réponse ne doit contenir que des chiffres", "q1") #Ici if check == "separateur": feedback.set_problem_feedback( "Les coordonnées doivent être séparées par une virgule",
stderr=subprocess.STDOUT, stdout=subprocess.PIPE) readelf_output = p.communicate()[0].decode('utf-8') for func in banned_funcs: if re.search("UND {}\n".format(func), readelf_output): feedback.set_tag("banned_funcs", True) feedback.set_global_result("failed") feedback.set_global_feedback( "Vous utilisez la fonction {}, qui n'est pas autorisée.". format(func)) exit(0) # Remove source files subprocess.run("rm -rf *.c *.tpl *.h *.o", shell=True) LANG = input.get_input('@lang') # Run the code in a parallel container p = subprocess.Popen(shlex.split( "run_student --time 20 --hard-time 60 ./tests LANGUAGE={}".format(LANG)), stderr=subprocess.STDOUT, stdout=subprocess.PIPE) o, e = p.communicate() print(o.decode("utf-8")) # If run failed, exit with "failed" result if p.returncode: feedback.set_global_result("failed") if p.returncode == 256 - 8: montest_output = rst.get_admonition( "warning", "**Erreur d'exécution**",
#! /usr/bin/python3 # -*- coding: utf-8 -*- from inginious import input, feedback, rst correct = "]-4;2]" # Insérer la bonne réponse ici answer = input.get_input("q1") #Remplacer q1 par l'id du sous-problème grade = 0 """ Vérifie que @n soit bien un nombre entier ou + ou - l'infini. pre: @n, une chaine de caractères post: renvoie @b, un boolean, vrai si @n représente un nombre entier ou +/- infini, faux sinon @s, une chaine de caractères contenant un commentaire """ def is_integer(n): if n in ["+inf", "-inf", "inf"]: return True, "+ ou - infini" try: int(n) return True, "correct" except: return False, "{} n'est pas un nombre correct".format(n) """ Vérifie que @set soit bien un ensemble de nombres entiers.
import os, re, hashlib, subprocess, shlex, shutil import tempfile, tarfile from inginious import feedback, rst, input ################# # Check filename ################# fname = input.get_input("p1archive:filename") if re.match(r"^[0-9]{6}00\.tar\.gz$", fname) is None: feedback.set_global_result("failed") feedback.set_global_feedback( "Nom de l'archive incorrect. Format attendu: NOMA.tar.gz (exemple: 12341500.tar.gz)" ) exit(1) noma = fname.replace(".tar.gz", "") ################## # Extracting file ################## fp = tempfile.TemporaryFile() fp.write(input.get_input("p1archive:value")) fp.seek(0) try: tar = tarfile.open(fileobj=fp) tar.extractall() tar.close()
# Ce fichier doit être utilisé pour un exercice de type 'random' à un seul sous-problème import re #import math Si nécessaire, effacer le '#' from sympy import sympify, simplify from sympy.parsing.latex import parse_latex from inginious import input, feedback, rst # Intégrer les variables que vous avez définie dans le sous-problème # nom_de_variable = int(input.get_input("@random")[indice]*100) # Ce qui correspond à l'exemple d'énoncé du TUTO (à remplacer) : somme = 10000 * int(input.get_input("@random")[0] * 100 + 1) plus2 = 1000 * int(input.get_input("@random")[1] * 100 + 1) minus3 = 1000 * int(input.get_input("@random")[2] * 100 + 1) # Définir comment la réponse correcte sera vérifiée avec les différents paramètres # Ce qui correspond à l'exemple du TUTO (à remplacer) : correct_equation = str(somme) + " = x + x + " + str(plus2) + " + x + " + str( plus2) + " - " + str(minus3) def parse_equation(latex_str): latex_str = re.sub("(\\\left|\\\\right)", "", latex_str) return parse_latex(latex_str)