示例#1
0
def create_problem():
    """ Input data contains the key value pair, which is passed to the api in order
    to create the problemID"""
    client = ProblemsClientV4(problem_accessToken, problem_endpoint)
    data = request.get_json()
    output = client.problems.create(data['name'],
                                    masterjudge_id=1001,
                                    body=data['body'])
    time.sleep(0.5)
    connection = mysql.connector.connect(host=database_auth['DB Host'],
                                         user=database_auth['DB Username'],
                                         port=3306,
                                         passwd=database_auth['DB Password'],
                                         db=database_auth['Database'])
    cursor = connection.cursor()
    Created_Date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    level = data['level']
    response = client.problems.get(output['id'])
    val = (response['id'], response['code'],
           response['name'], response['shortBody'], response['body'],
           json.dumps(response['type']), response['interactive'],
           json.dumps(response['masterjudge']['id']),
           json.dumps(response['testcases']),
           json.dumps(response['lastModified']),
           json.dumps(response['permissions']), Created_Date, level)
    sql_query = "INSERT INTO sphere_engine_problem_details (id,code,name,shortBody,body,type,interactive,masterjudge,testcases,lastModified, permissions,Created_Date,level) VALUES (%s, %s, %s, %s, %s, %s, %s,%s,%s,%s,%s,%s,%s)"
    cursor.execute(sql_query, val)
    connection.commit()
    connection.close()
    return jsonify(output)
示例#2
0
def testing(request, test_case_id):
    try:
        b = Test.objects.get(test_case_id=test_case_id)
    except:
        raise Http404("Завдання не знайдені")

    test_time = b.test_case.case_duration * 60

    accessToken = '82c0c5507c39a743ef533af852e97b11'
    endpoint = 'd32fffd4.problems.sphere-engine.com'

    client = ProblemsClientV4(accessToken, endpoint)

    problemId = b.sphere_id

    try:
        response = client.problems.get(problemId)
    except SphereEngineException as e:
        if e.code == 401:
            print('Invalid access token')
        elif e.code == 403:
            print('Access to the problem is forbidden')
        elif e.code == 404:
            print('Problem does not exist')

    return render(request, 'test/test.html', {'test_case': b, 'subjects_list': subjects_list, 'response': response, 'test_time': test_time})
示例#3
0
def create_testcases():
    client = ProblemsClientV4(problem_accessToken, problem_endpoint)
    test_data = request.get_json()
    response = client.problems.createTestcase(test_data['id'],
                                              test_data['input_file'],
                                              test_data['output_file'],
                                              test_data['timelimit'],
                                              test_data['judgeId'])
    time.sleep(0.5)
    """ Submission of test cases into the database """
    connection = mysql.connector.connect(host=database_auth['DB Host'],
                                         user=database_auth['DB Username'],
                                         port=3306,
                                         passwd=database_auth['DB Password'],
                                         db=database_auth['Database'])
    cursor = connection.cursor()
    cursor.execute("""select problem_id from sphere_engine_testcase;""")
    list_probids = cursor.fetchall()
    problemids = [str(list_probids[i][0]) for i in range(len(list_probids))]
    lang = list(test_data['check_file'].keys())[0]
    if str(test_data['id']) not in problemids:
        sql_query = """INSERT INTO sphere_engine_testcase (number,problem_id,input_file,output_file,created_date,timelimit,judgeId,check_file) VALUES (%s,%s,%s,%s,%s,%s,%s,%s);"""
        val = (response['number'], test_data['id'], test_data['input_file'],
               test_data['output_file'], datetime.now().strftime('%Y-%m-%d'),
               test_data['timelimit'], test_data['judgeId'],
               json.dumps(test_data['check_file']))
        cursor.execute(sql_query, val)
        connection.commit()
    else:
        cursor.execute("SET SQL_SAFE_UPDATES=0")
        connection.commit()
        """ get the available check_file dictionary from the database"""
        cursor.execute(
            """Select check_file from sphere_engine_testcase where problem_id = {}"""
            .format(test_data['id']))
        check_file_dictionary = eval(cursor.fetchall()[0][0])
        if lang in check_file_dictionary:
            check_file_dictionary[lang] = test_data['check_file'][lang]
        else:
            check_file_dictionary[lang] = test_data['check_file'][lang]
        sql_query = """INSERT INTO sphere_engine_testcase (number,problem_id,input_file,output_file,created_date,timelimit,judgeId,check_file) VALUES (%s,%s,%s,%s,%s,%s,%s,%s);"""
        val = (response['number'], test_data['id'], test_data['input_file'],
               test_data['output_file'], datetime.now().strftime('%Y-%m-%d'),
               test_data['timelimit'], test_data['judgeId'],
               str(json.dumps(check_file_dictionary)))
        cursor.execute(sql_query, val)
        connection.commit()
    cursor.close()
    connection.close()
    metadata = response
    metadata.update(test_data)
    return jsonify(metadata)
示例#4
0
def update_problem():
    client = ProblemsClientV4(problem_accessToken, problem_endpoint)
    data = request.get_json()
    response = client.problems.update(data['id'], data['name'], 1001,
                                      data['body'], data['interactive'])
    # update the same in local database.
    connection = mysql.connector.connect(host=database_auth['DB Host'],
                                         user=database_auth['DB Username'],
                                         port=3306,
                                         passwd=database_auth['DB Password'],
                                         db=database_auth['Database'])
    cursor = connection.cursor()
    cursor.execute("SET SQL_SAFE_UPDATES=0")
    connection.commit()

    response = client.problems.get(data['id'])
    list_sphere_keys = list(response.keys())
    values = (response['id'], response['code'], response['name'],
              response['shortBody'], response['body'],
              json.dumps(response['type']), response['interactive'],
              json.dumps(response['masterjudge']['id']),
              json.dumps(response['testcases']),
              json.dumps(response['lastModified']),
              json.dumps(response['permissions']))
    """ update the fields in the database on the basis of incoming data from sphere engine"""
    for i in range(len(list_sphere_keys)):
        cursor.execute(
            """UPDATE sphere_engine_problem_details SET {}=%s where id=%s;""".
            format(list_sphere_keys[i]), (
                values[i],
                data['id'],
            ))
        connection.commit()
    cursor.close()
    connection.close()
    return jsonify({
        "Data Updated in the database": "True",
        'newproblemName': response['name']
    })
示例#5
0
"""
Example presents error handling for submissions.createWithTarSource() API method
"""
from sphere_engine import ProblemsClientV4
from sphere_engine.exceptions import SphereEngineException

# define access parameters
accessToken = '<access_token>'
endpoint = '<endpoint>'

# initialization
client = ProblemsClientV4(accessToken, endpoint)

# API usage
problemId = 42
tarSource = '<tar_source>'
compiler = 11  # C language

try:
    response = client.submissions.createWithTarSource(problemId, tarSource,
                                                      compiler)
    # response['id'] stores the ID of the created submission
except SphereEngineException as e:
    if e.code == 401:
        print('Invalid access token')
    elif e.code == 402:
        print('Unable to create submission')
    elif e.code == 400:
        print('Error code: ' + str(e.error_code) +
              ', details available in the message: ' + str(e))
示例#6
0
 def setUp(self):
     self.client = ProblemsClientV4('access-token', 'endpoint')
示例#7
0
def update_testcase():
    client = ProblemsClientV4(problem_accessToken, problem_endpoint)
    data = request.get_json()
    key_list = list(data.keys())
    list_all_params = [
        'id', 'number', 'input_file', 'output_file', 'timelimit', 'judgeId',
        'active', 'check_file'
    ]
    diff_list = list(set(list_all_params) - set(key_list))
    """ Assign each element in diff_list as None"""
    val = {}
    for i in range(len(data)):
        val[key_list[i]] = data[key_list[i]]

    optional_params = {}
    for i in range(len(diff_list)):
        optional_params[diff_list[i]] = None

    val.update(optional_params)

    response = client.problems.updateTestcase(val['id'], val['number'],
                                              val['input_file'],
                                              val['output_file'],
                                              val['timelimit'], val['judgeId'],
                                              val['active'])
    # update the same in local database.
    connection = mysql.connector.connect(host=database_auth['DB Host'],
                                         user=database_auth['DB Username'],
                                         port=3306,
                                         passwd=database_auth['DB Password'],
                                         db=database_auth['Database'])
    cursor = connection.cursor()
    cursor.execute('set innodb_lock_wait_timeout=10000')
    connection.commit()
    cursor.execute("SET SQL_SAFE_UPDATES=0")
    connection.commit()
    """ get the latest updated testcases of the problemId"""
    url = "https://{}/api/v4/problems/{}/testcases?access_token={}".format(
        problem_auth['endpoint'], data['id'], problem_auth['token'])
    testcases = requests.get(url).json()
    numbers = [
        testcases['items'][i]['number'] for i in range(len(testcases['items']))
    ]
    active = [
        testcases['items'][i]['active'] for i in range(len(testcases['items']))
    ]
    judge_id = [
        testcases['items'][i]['judge'] for i in range(len(testcases['items']))
    ]
    testcase_dict = {'number': numbers, 'active': active, 'judge_id': judge_id}
    key_list_excl_id = key_list[1:]

    ## check if the check file is passed or not?
    if 'check_file' in key_list_excl_id:
        #data['check_file'] =json.dumps(data['check_file'])
        cursor.execute(
            """select check_file from sphere_engine_testcase where problem_id= {}"""
            .format((data['id'])))
        check_file_dict = eval(cursor.fetchall()[0][0])
        check_file_dict.update(data['check_file'])
        cursor.execute(
            """update sphere_engine_testcase set check_file=%s where problem_id=%s""",
            (json.dumps(check_file_dict), data['id']))
        connection.commit()
        cursor.execute(
            """update sphere_engine_testcase SET test_case_dict=%s where problem_id=%s""",
            (str(json.dumps(testcase_dict)), data['id']))
        connection.commit()

    else:
        for i in range(len(key_list_excl_id)):
            if key_list_excl_id[i] in ['number', 'active']:
                cursor.execute(
                    """update sphere_engine_testcase set test_case_dict=%s where problem_id=%s""",
                    (str(json.dumps(testcase_dict)), data['id']))
                connection.commit()
            else:
                cursor.execute(
                    """update sphere_engine_testcase set {}=%s where problem_id=%s"""
                    .format(key_list_excl_id[i]),
                    (data[key_list_excl_id[i]], data['id']))
                connection.commit()

    connection.close()
    cursor.close()
    return jsonify({'Updated': True})
示例#8
0
def get_result():
    client = ProblemsClientV4(problem_accessToken, problem_endpoint)
    connection = mysql.connector.connect(host=database_auth['DB Host'],
                                         user=database_auth['DB Username'],
                                         port=3306,
                                         passwd=database_auth['DB Password'],
                                         db=database_auth['Database'])
    cursor = connection.cursor()
    query_parameters = request.args
    candidatename = query_parameters.get('userName')
    problem_name = query_parameters.get('problemName')
    cursor.execute(
        """select id from sphere_engine_problem_details where name=%s; """,
        (problem_name, ))
    problem_id = cursor.fetchall()[0][0]
    cursor.execute(
        """select id from sphere_engine_submissionid where candidatename=%s and problemId=%s; """,
        (
            candidatename,
            problem_id,
        ))
    submission = cursor.fetchall()
    # Instantiate dict to store the values from the json
    result = {}
    string_id = [str(submission[i][0]) for i in range(len(submission))]
    for i in range(len(submission)):
        try:
            response = client.submissions.get(int(submission[i][0]))
            result[string_id[i]] = response
        except SphereEngineException as e:
            if e.code == 401:
                result = 'Invalid access token'
            elif e.code == 403:
                result = 'Access to the submission is forbidden'
            elif e.code == 404:
                result = 'Submission does not exist'
    # Store the data if and only if the Submission id is not in databse
    time.sleep(5.0)
    ids = [submission[i][0] for i in range(len(submission))]
    # match submission id with result table in databse
    cursor.execute(
        """select submissionid from result_sphere_engine where candidateName=%s and problem_name=%s""",
        (
            candidatename,
            problem_name,
        ))
    result_db_ids = cursor.fetchall()
    result_db_ids = [result_db_ids[i][0] for i in range(len(result_db_ids))]
    for ID in ids:
        if ID in result_db_ids:
            None
        else:
            """ Result Insertion into DB"""
            cursor = connection.cursor()
            sql_query = """show columns from result_sphere_engine;"""
            cursor.execute(sql_query)
            column_keys = cursor.fetchall()
            columns = [column_keys[i][0] for i in range(len(column_keys) - 1)]
            list_result_keys = list(result.keys())
            place_holder = ['%s' for i in range(len(columns))]
            for i in range(len(list_result_keys)):
                sql_query = """INSERT INTO result_sphere_engine ({}) VALUES({});""".format(
                    ",".join(columns), ",".join(place_holder))
                val = (
                    list_result_keys[i],
                    result[list_result_keys[i]]['compiler']['id'],
                    result[list_result_keys[i]]['compiler']['version']['name'],
                    result[list_result_keys[i]]['executing'],
                    result[list_result_keys[i]]['problem']['code'],
                    result[list_result_keys[i]]['problem']['id'],
                    result[list_result_keys[i]]['problem']['name'],
                    json.dumps(result[list_result_keys[i]]['result']),
                    result[list_result_keys[i]]['result']['status']['name'],
                    candidatename)
                cursor.execute(sql_query, val)
                connection.commit()

    connection.close()
    return jsonify(result)
示例#9
0
def submission_id():
    client = ProblemsClientV4(problem_accessToken, problem_endpoint)
    submission_data = request.get_json()
    source = submission_data['source']
    lang = submission_data['language']
    problem_name = submission_data['problem_name']
    candidate_name = submission_data['candidate_name']
    connection = mysql.connector.connect(host=database_auth['DB Host'],
                                         user=database_auth['DB Username'],
                                         port=3306,
                                         passwd=database_auth['DB Password'],
                                         db=database_auth['Database'])
    cursor = connection.cursor()
    try:
        cursor.execute(
            """select compilerID from sphere_engine_languages where language=%s""",
            (lang, ))
        compilerID = cursor.fetchall()[0][0]
    except IndexError:
        cursor.execute("""select language from sphere_engine_languages;""")
        all_lang = cursor.fetchall()
        response = Response(
            json.dumps(
                "Please enter the correct language. Avalialable languages are {}"
                .format(all_lang)))
        response.status_code = 400

    cursor.execute(
        """select id from sphere_engine_problem_details where name = %s;""",
        (problem_name, ))
    problem_id = cursor.fetchone()[0]
    """get the required pckgs for the checkfile for specific language"""
    cursor.execute(
        """select required_pckgs from sphere_engine_testcase where problem_id=%s;""",
        (problem_id, ))
    required_pckgs = cursor.fetchall()[0][0]
    required_pckgs = eval(required_pckgs)
    # get required package for specific language
    try:
        opening_statement = required_pckgs[lang]
    except KeyError:
        opening_statement = "\n"
    """ get the checker file specfic to the compiler and the problemId"""
    cursor.execute(
        """select check_file from sphere_engine_testcase where problem_id=%s;""",
        (problem_id, ))
    check_file_all = eval(cursor.fetchall()[0][0])
    try:
        check_file = check_file_all[lang]
        """ Send the file to the compiler"""
        submission_file = opening_statement + source + check_file
    except KeyError:
        None
    """ Submission file """
    try:
        try:
            response = client.submissions.create(problem_id, submission_file,
                                                 compilerID)
            """ Database Insertion of Submission Ids"""
            sql_query = """INSERT INTO sphere_engine_submissionid (id,language,sourcefile,problemId,candidatename) VALUES(%s, %s,%s,%s,%s);"""
            val = (response['id'], lang, source, problem_id, candidate_name)
            response = json.dumps({"submissionId": response['id']})
            cursor.execute(sql_query, val)
            connection.commit()
        except NameError:
            None
    except SphereEngineException as e:
        if e.code == 401:
            response = 'Invalid access token'
        elif e.code == 402:
            response = 'Unable to create submission'
        elif e.code == 400:
            response = 'Error code: ' + str(
                e.error_code) + ', details available in the message: ' + str(e)
    connection.close()
    cursor.close()
    return response
示例#10
0
                        'Content-Type', 'Authorization', 'Origin',
                        'X-Requested-With', 'Accept'
                    ],
                    "methods": ['GET', 'POST', 'PUT', 'PATCH', 'DELETE']
                }
            })
problem_auth = {
    'endpoint': 'b47c8916.problems.sphere-engine.com',
    'token': '4c1e602f25ea827d81f3f84dbdbd9527'
}

# define access parameters
problem_accessToken = problem_auth['token']
problem_endpoint = problem_auth['endpoint']

client = ProblemsClientV4(problem_accessToken, problem_endpoint)

### Compiler API
compiler_auth = {
    "endpoint": "b47c8916.compilers.sphere-engine.com",
    "token": "6fc402f585b35ef7accf61facc636af0"
}

# define access parameters
compiler_accessToken = compiler_auth["token"]
compiler_endpoint = compiler_auth["endpoint"]

compiler_client = CompilersClientV4(compiler_accessToken, compiler_endpoint)

# Problem API initialization
try: