def configure_docker(): """Function used to configure base profile.""" profiles = [ epicbox.Profile("linter", "epicbox-linter:latest"), epicbox.Profile("formatter", "epicbox-formatter:latest"), ] epicbox.configure(profiles=profiles)
def python(code: str, testcase_dir: str) -> SubmissionResult: files = [{'name': 'main.py', 'content': code}] result = SubmissionResult() epicbox.configure( profiles=[epicbox.Profile('python', 'python:3.6.5-alpine')]) test_no = 0 while test_no < MAX_NUMBER_OF_TESTCASES: stdin, expected = get_input_expected_output(testcase_dir, test_no) if stdin == None or expected == None: break output = epicbox.run('python', 'python3 main.py', stdin=stdin, files=files, limits=limits['py']) process_output(test_no, output, expected, result) test_no += 1 return result
def translate_keras(filename): """Translate a keras model defined in a file into the neural network graph. Arguments: filename {String} -- name of the file to be translated Returns: object -- the result of this translation, can be an error """ if keras_ext in filename: try: return graph_from_model_file(filename) except Exception as err: return { 'error_class': '', 'line_number': 1, 'detail': "Model could not be loaded correctly. Error: " + str(err) } else: epicbox.configure( profiles=[epicbox.Profile('python', 'tf_plus_keras:latest')]) general_reader = open('translate/keras_loader.txt', 'rb') general_code = general_reader.read() with open(filename, 'rb') as myfile: keras_code = myfile.read() try: return graph_from_external_file(keras_code, general_code) except Exception as err: return { 'error_class': '', 'line_number': 1, 'detail': str(err) }
def configure(docker_url): epicbox.configure( profiles=[ epicbox.Profile('python3', 'stepic/epicbox-python', user='******', read_only=True), epicbox.Profile('gcc', 'stepik/epicbox-gcc:5.3.0'), ], docker_url=docker_url, ) structlog.configure( processors=[ structlog.processors.TimeStamper(fmt='iso'), structlog.processors.KeyValueRenderer(key_order=['event']), ], logger_factory=structlog.PrintLoggerFactory(), )
def post(self, request): """Post method to execute code.""" serializer = CodeSerializerExercise(data=request.data) if serializer.is_valid(): main_code = render_main(serializer.validated_data["code_input"], ) exercise = get_object_or_404( Exercise, id=serializer.validated_data["exercise_id"], ) epicbox.configure(profiles=[ epicbox.Profile( exercise.docker_image.profile_name, exercise.docker_image.image_name, ), ]) result_run1 = docker_run( exercise.docker_image.profile_name, "python {0}".format(serializer.validated_data["filename"]), files=[ { "name": serializer.validated_data["filename"], "content": main_code.encode(), }, ], limits={ "cputime": 50, "memory": 128 }, ) errors_set = set() for template in exercise.errors_template.all(): for error in template.errors.all().distinct().values_list( "code", flat=True): errors_set.add(error) if len(errors_set) > 0: errors_string = " ".join(errors_set) else: errors_string = None result_run2 = lint(serializer, errors_string) result_run1["lint_results"] = result_run2["lint_results"] create_submission.delay( self.request.user.mail, serializer.validated_data["exercise_id"], serializer.validated_data["code_input"], result_run1, serializer.validated_data["final"], ) return Response(result_run1, status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def __init__(self, grader_root='/tmp/', fork_per_item=True, logger_name=__name__, fail_on_error=False, alert_mail=None): """ grader_root = root path to graders fork_per_item = fork a process for every request logger_name = name of logger alert_mail = SMTP credentials and recipients list """ self.log = logging.getLogger(logger_name) self.grader_root = path(grader_root) self.fork_per_item = fork_per_item self.fail_on_error = fail_on_error self.alert_mail = alert_mail if check_mail(alert_mail, self.log) else None epicbox.configure(profiles=[ epicbox.Profile('python', 'python:3.7-alpine'), epicbox.Profile('python-server', 'python-server:1.0'), ]) self.server_files = [ {"name": "main.py", "content": get_server_file("main.py")}, {"name": "helper.py", "content": get_server_file("helper.py")}, ]
from flask import Flask, render_template, request, session import random, epicbox, os # docker pull epicbox.configure(profiles=[epicbox.Profile('python', 'python:3.9.6-alpine')]) app = Flask(__name__) app.secret_key = os.urandom(16) flag = open('flag.txt').read() @app.route('/') def yeet(): return render_template('yeet.html') @app.route('/yeet') def yeetyeet(): return render_template('yeetyeet.html') @app.route('/yeetyeet', methods=['POST']) def yeetyeetyeet(): if 'run' in session and session['run']: return { 'error': True, 'msg': 'You already have code running, please wait for it to finish.' } session['run'] = True
import epicbox epicbox.configure( profiles=[ epicbox.Profile('python', 'python:3.6.5-alpine') ] ) files = [{'name': 'main.py', 'content': b'print(42)'}] limits = {'cputime': 1, 'memory': 64} result = epicbox.run('python', 'python3 main.py', files=files, limits=limits)
from flask_cors import CORS from flask_pymongo import PyMongo from psypl.experiments import EXPERIMENTS from bson import json_util import epicbox app = Flask(__name__) CORS(app) app.debug = True app.config[ "MONGO_URI"] = "mongodb://*****:*****@localhost:27017/experiments?authSource=admin" mongo = PyMongo(app) experiments_db = mongo.db.experiments epicbox.configure(profiles=[epicbox.Profile('rust', 'rust')]) def get_experiment(name): name = ''.join(name.split('_') + ['experiment']) cls = [e for e in EXPERIMENTS if e.__name__.lower() == name][0] return cls() @app.route("/") def index(): return render_template('index.html', experiments=[{ 'url': '_'.join([s.lower() for s in e.name_parts()]), 'name':
import epicbox epicbox.configure(profiles=[ # epicbox.Profile('python', 'python:3.6.5-alpine') epicbox.Profile('python', 'continuumio/anaconda3:latest') ]) class ResponseWrapper: def __init__(self, exit_code: int, stdout: bytes, stderr: bytes, duration: float, timeout: bool, oom_killed: bool): self.exit_code = exit_code self.output: str = stdout.decode("ascii") self.stderr: bytes = stderr.decode("ascii") self.duration: bytes = duration self.timeout: float = timeout self.oom_killed: bool = oom_killed def getProcessResponse(content: bytes): files = [{'name': 'main.py', 'content': content}] limits = {'cputime': 1, 'memory': 64} result = epicbox.run('python', 'python3 main.py', files=files, limits=limits) return ResponseWrapper(**result)
def profile_read_only(docker_image): return epicbox.Profile('python_read_only', docker_image, command='python3 -c \'print("profile stdout")\'', read_only=True)
def profile(docker_image): return epicbox.Profile('python', docker_image, command='python3 -c \'print("profile stdout")\'')
import epicbox epicbox.configure( profiles=[ epicbox.Profile('python', 'czentye/matplotlib-minimal') ] ) files = [{'name': 'main.py', 'content': b'x = input(); print(x); y = input(); print("Hi " + y)'}] limits = {'cputime': 10, 'memory': 64} result = epicbox.run('python', 'python3 -u main.py', stdin=b'x\nalex\n', files=files, limits=limits) print(result)
def profile_unknown_image(): return epicbox.Profile('unknown_image', 'unknown_image:tag', command='unknown')
def __init__(self): epicbox.configure( profiles=[epicbox.Profile('python', self.DOCKER_IMAGE)])
from xblockutils.resources import ResourceLoader from xblockutils.studio_editable import StudioEditableXBlockMixin from xmodule.contentstore.content import StaticContent from nand2tetris.utils import (file_contents_iter, get_file_modified_time_utc, get_file_storage_path, get_sha1) from nand2tetris.tasks import (get_zip_file_name, get_zip_file_path, zip_student_submissions) log = logging.getLogger(__name__) loader = ResourceLoader(__name__) ITEM_TYPE = "nand2tetrisxblock" epicbox.configure(profiles=[ epicbox.Profile('nand2tetris', 'tcarreira/nand2tetris-autograder:2.6.1-epicbox') ]) limits = {'cputime': 1, 'memory': 64} def reify(meth): """ Decorator which caches value so it is only computed once. Keyword arguments: inst """ def getter(inst): """ Set value to meth name in dict and returns value. """ value = meth(inst)
import epicbox import hashlib from random import randint from sys import stderr epicbox.configure(profiles=[ #epicbox.Profile('python', 'python:3.6.5-alpine') epicbox.Profile('python', 'hortune/python3.6-alpine') ]) q_num = 0 def is_valid(digest, diff): bits = ''.join(bin(i)[2:].zfill(8) for i in digest) return bits[:diff] == '0' * diff def proofofwork(): hardness = 23 prefix = hex( randint(1000000000000000000000000000000000000, 123123123213123000000123213**3))[-18:-2] print(f'prefix = "{prefix}"') print(f'sha256(prefix + answer) has {hardness} leading zeros. (In binary)') print("input:") inp = input().strip() s = prefix + inp assert is_valid(hashlib.sha256(s.encode()).digest(), hardness)
def grade_epicbox( submission: dict, script_name: str, prepared_files: list, docker_profile: dict, docker_limits: dict, ) -> dict: """ Running grading script in a separate Docker container. https://github.com/StepicOrg/epicbox :param submission: Student submission received from message broker. :param script_name: Name of the grading script. :param prepared_files: List of files and their paths. :param docker_profile: Epicbox profile. :param docker_limits: Docker container limits. :return: Results of grading. """ logger: Logger = get_logger("process_answer") epicbox.configure(profiles=[ epicbox.Profile( name="python", docker_image=docker_profile["docker_image"], user=docker_profile["user"], read_only=docker_profile["read_only"], network_disabled=docker_profile["network_disabled"], ) ]) # Get all files used during grading # Content field should be bytes files: list = [] # Grading script with Path(PATH_GRADER_SCRIPTS_DIRECTORY / script_name / "grade.py").open("rb") as f: files.append({"name": "grade.py", "content": f.read()}) # Required files for file in prepared_files: with Path(file["path"]).open("rb") as f: files.append({"name": file["name"], "content": f.read()}) # Student submission files.append({ "name": "student_response.txt", "content": submission_get_response(submission).encode(), }) # Script parameters files.append({ "name": "script_parameters.json", "content": submission["xqueue_body"]["grader_payload"].encode(), }) result: dict = epicbox.run("python", "python3 grade.py", files=files, limits=docker_limits) logger.debug("Result: %s", result) grade: dict = {"correct": False, "score": 0, "msg": ""} # Handling result if result["timeout"]: grade["msg"] = "Проверка заняла слишком много времени." elif result["oom_killed"]: grade["msg"] = "Проверка заняла слишком много памяти." else: try: try: grade["score"] = int(result["stdout"].decode().split("\n")[-2]) except ValueError: grade["score"] = float( result["stdout"].decode().split("\n")[-2]) grade["msg"] = result["stderr"].decode() # .split("\n")[-2] + "\n" grade["correct"] = bool(grade["score"]) except ValueError: raise InvalidGraderScriptException( "Grading script returned invalid results: %s", result) return grade