예제 #1
0
 def __init__(self, work_dir, allowed_languages=None):
     self.work_dir = work_dir
     if allowed_languages is None:
         self.languages = Language.languages()
     else:
         self.languages = [
             Language.from_name(name) for name in allowed_languages
         ]
예제 #2
0
    def run(self):
        contest = Contest.from_name(self.args.contest)
        if contest is None:
            print(f"No contest named {self.args.contest}!", file=sys.stderr)
            exit(1)

        try:
            Language.from_name(self.args.language)
        except ValueError:
            print(
                f"Language {self.args.language} is not currently supported by TuringArena!",
                file=sys.stderr)
            print(
                f"Currently available languages: {', '.join(lang.name for lang in Language.languages())}"
            )
            exit(1)

        contest.add_language(self.args.language)
예제 #3
0
def run_server(driver_connection, source_path, interface_path, downward_tee,
               upward_tee):
    program = Program(source_path=source_path, interface_path=interface_path)
    language = Language.from_source_path(program.source_path)
    interface = load_interface(program.interface_path)

    with ExitStack() as stack:
        temp_dir = stack.enter_context(TemporaryDirectory())

        runner = language.ProgramRunner(
            program=program,
            language=language,
            interface=interface,
            temp_dir=temp_dir,
        )

        connection = stack.enter_context(runner.run_in_process())

        sandbox_tee = SandboxTee(
            downward_tee=stack.enter_context(open(downward_tee, "w")),
            upward_tee=stack.enter_context(open(upward_tee, "w")),
        )

        stack.callback(lambda: connection.manager.get_status(
            kill_reason="still running after communication end", ))

        context = Executor(
            bindings={},
            phase=None,
            process=connection.manager,
            request_lookahead=None,
            driver_connection=driver_connection,
            sandbox_connection=connection,
            sandbox_tee=sandbox_tee,
        )

        try:
            try:
                context.execute(interface)
            except InterfaceExitReached:
                pass
            context.report_ready()
            request = context.next_request()
            assert False, f"driver was not explicitly stopped, got {request}"
        except CommunicationError as e:
            logging.debug(f"communication error", exc_info=True)
            context.send_driver_state(DriverState.ERROR)  # error
            info = connection.manager.get_status(
                kill_reason="communication error")
            message, = e.args
            context.send_driver_upward(f"{message} (process {info.error})")
        except DriverStop:
            context.send_driver_state(DriverState.READY)  # ok, no errors
예제 #4
0
    def run(self):
        contest = Contest.from_name(self.args.contest)
        if contest is None:
            print(f"No contest named {self.args.contest}!", file=sys.stderr)
            exit(1)

        languages = [
            Language.from_name(lang) for lang in contest.allowed_languages
        ]
        print(
            tabulate(((lang.name, lang.extension) for lang in languages),
                     headers=("Name", "Extension")))
예제 #5
0
def define_algorithm(interface_text: str, source_text: str, language_name: str = "C++") -> Program:
    language = Language.from_name(language_name)

    with ExitStack() as stack:
        tmp_dir = stack.enter_context(TemporaryDirectory())

        source_path = os.path.join(tmp_dir, f"source{language.extension}")
        interface_path = os.path.join(tmp_dir, "interface.txt")

        with open(interface_path, "w") as f:
            print(interface_text, file=f)

        with open(source_path, "w") as f:
            print(source_text, file=f)

        yield Program(
            source_path=source_path,
            interface_path=interface_path,
        )
예제 #6
0
def evaluate(current_user, problem, contest):
    submitted_file = request.files["source"]

    ext = os.path.splitext(submitted_file.filename)[1]

    allowed_extensions = [
        Language.from_name(lang).extension
        for lang in contest.allowed_languages
    ]
    if ext not in allowed_extensions:
        raise RuntimeError(
            f"Unsupported file extension {ext}: please select another file!")

    submission = Submission.new(current_user, problem, contest,
                                submitted_file.filename)

    os.makedirs(os.path.split(submission.path)[0], exist_ok=True)
    submitted_file.save(submission.path)

    threading.Thread(target=evaluate_thread,
                     args=(problem, submission)).start()

    return redirect(
        url_for("submission.submission_view", submission_id=submission.id))
예제 #7
0
from turingarena.driver.language import Language

disabled_language = Language(
    name="javascript",
    extension=".js",
    ProgramRunner=None,
    Generator=None,
    supported_for_evaluator=False,
)
예제 #8
0
from turingarena.driver.language import Language

from .generator import JavaCodeGen
from .runner import JavaProgramRunner

language = Language(
    name="Java",
    extension=".java",
    ProgramRunner=JavaProgramRunner,
    Generator=JavaCodeGen,
    supported_for_evaluator=False,
)
예제 #9
0
from turingarena.driver.language import Language

from .generator import RustCodeGen
from .runner import RustProgramRunner

language = Language(
    name="Rust",
    extension=".rs",
    ProgramRunner=RustProgramRunner,
    Generator=RustCodeGen,
    supported_for_evaluator=False,
)
예제 #10
0
from turingarena.driver.language import Language

from .generator import GoCodeGen
from .runner import GoProgramRunner

disabled_language = Language(
    name="Go",
    extension=".go",
    ProgramRunner=GoProgramRunner,
    Generator=GoCodeGen,
    supported_for_evaluator=False,
)
예제 #11
0
 def language(self):
     try:
         return Language.from_extension(self.extension)
     except UnknownFileExtension:
         return None
예제 #12
0
from turingarena.driver.language import Language

from .generator import CppCodeGen
from .runner import CppProgramRunner

language = Language(
    name="C++",
    extension=".cpp",
    ProgramRunner=CppProgramRunner,
    Generator=CppCodeGen,
    supported_for_evaluator=True,
)
예제 #13
0
from turingarena.driver.language import Language
from .generator import BashCodeGen
from .runner import BashProgramRunner

disabled_language = Language(
    name="Bash",
    extension=".sh",
    ProgramRunner=BashProgramRunner,
    Generator=BashCodeGen,
    supported_for_evaluator=False,
)
예제 #14
0
from turingarena.driver.language import Language

from .generator import CCodeGen
from .runner import CProgramRunner

language = Language(
    name="C",
    extension=".c",
    ProgramRunner=CProgramRunner,
    Generator=CCodeGen,
    supported_for_evaluator=False,
)
예제 #15
0
from turingarena.driver.language import Language
from turingarena.driver.languages.python.generator import PythonCodeGen

from .generator import PythonCodeGen
from .runner import PythonProgramRunner

language = Language(
    name="Python",
    extension=".py",
    ProgramRunner=PythonProgramRunner,
    Generator=PythonCodeGen,
    supported_for_evaluator=True,
)
예제 #16
0
from turingarena.driver.language import Language

from .generator import RubyCodeGen
from .runner import RubyProgramRunner

language = Language(
    name="Ruby",
    extension=".rb",
    ProgramRunner=RubyProgramRunner,
    Generator=RubyCodeGen,
    supported_for_evaluator=True,
)