petlja-api 0.0.1__tar.gz

petlja_api-0.0.1/.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

petlja_api-0.0.1/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "python.testing.pytestArgs": [
+        "."
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true,
+    "[python]": {
+        "editor.defaultFormatter": "ms-python.autopep8"
+    },
+    "python.formatting.provider": "none"
+}

petlja_api-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Pavle Sekešan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

petlja_api-0.0.1/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.3
+Name: petlja_api
+Version: 0.0.1
+Summary: A python library for interacting with the petlja.org API
+Project-URL: Homepage, https://github.com/PavleSekesan/petlja_api
+Author-email: Pavle Sekešan <pavlesekesan@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.7
+Requires-Dist: beautifulsoup4==4.12.2
+Requires-Dist: requests==2.31.0
+Description-Content-Type: text/markdown
+
+# petlja_api
+
+A python library for interacting with the [petlja.org](https://petlja.org/) API.
+
+## Installation
+```
+pip install petlja_api
+```
+
+## Basic usage
+
+```py
+import petlja_api as petlja
+
+session = petlja.login()
+
+# Create problem
+prob_id = petlja.create_problem(session, name="My Problem", alias="my-prob")
+petlja.upload_testcases(session, prob_id, "my-prob/testcases.zip")
+petlja.upload_statement(session, prob_id, "my-prob/statement.md")
+
+# Create competition
+comp_id = petlja.create_competition(session, name="My Competition", alias="my-comp")
+petlja.add_problem(session, comp_id, prob_id)
+
+# Upload solution
+petlja.score = submit(session, prob_id, "my-prob/sol.cpp", comp_id)
+```

petlja_api-0.0.1/README.md

@@ -0,0 +1,28 @@
+# petlja_api
+
+A python library for interacting with the [petlja.org](https://petlja.org/) API.
+
+## Installation
+```
+pip install petlja_api
+```
+
+## Basic usage
+
+```py
+import petlja_api as petlja
+
+session = petlja.login()
+
+# Create problem
+prob_id = petlja.create_problem(session, name="My Problem", alias="my-prob")
+petlja.upload_testcases(session, prob_id, "my-prob/testcases.zip")
+petlja.upload_statement(session, prob_id, "my-prob/statement.md")
+
+# Create competition
+comp_id = petlja.create_competition(session, name="My Competition", alias="my-comp")
+petlja.add_problem(session, comp_id, prob_id)
+
+# Upload solution
+petlja.score = submit(session, prob_id, "my-prob/sol.cpp", comp_id)
+```

petlja_api-0.0.1/examples/petljatest/README.md

@@ -0,0 +1,55 @@
+# petljatest
+
+Automatically create a competition, add its problems and test all of their solutions on [arena.petlja.org](https://arena.petlja.org/)
+
+## Usage
+
+Directory structure should be [petljapub](https://pypi.org/project/petljapub/) compatible
+
+```
+00_competition/
+├── 01_problem1
+│   ├── problem1.cpp
+│   ├── problem1.py
+│   ├── problem1-sol.md
+│   ├── problem1-st.md
+│   ├── problem1-tgen.cpp
+│   └── scoring.yaml
+├── 02_problem2
+│   ├── problem2.cpp
+│   ├── problem2.cs
+│   ├── problem2.py
+│   ├── problem2-scoring.yaml
+│   ├── problem2-sol.md
+│   ├── problem2-st.md
+│   └── problem2-tgen.cpp
+├── ...
+```
+
+Run script from top-level competition directory
+
+```
+$ cd 00_competition/
+$ python3 petljatest.py
+Petlja username: testacc
+Petlja password: 
+```
+
+Example output:
+
+```
+Created competition 00_example_competition
+Found problem 01_problem1
+Uploaded testcases for problem 01_problem1
+Uploaded statement for problem 01_problem1
+Added problem 01_problem1 to competition 00_example_competition
+Submitted solution problem1.py for problem 01_problem1
+Score: 10
+Submitted solution problem1.cs for problem 01_problem1
+Score: 0
+Submitted solution problem1.cpp for problem 01_problem1
+Score: 0
+Found problem 02_problem2
+...
+```
+

petlja_api-0.0.1/examples/petljatest/petljatest.py

@@ -0,0 +1,96 @@
+from pathlib import Path
+import petlja_api as petlja
+import re
+import subprocess
+
+
+def is_for_testing(source_path):
+    is_code = source_path.suffix in petlja.submit.LANGUAGE_IDS
+    is_tgen = source_path.stem.endswith("tgen")
+    return is_code and not is_tgen
+
+
+def remove_metadata(st_path):
+    cleaned = Path(st_path.parent, st_path.stem + "-cleaned.md")
+    is_metadata = False
+    lines = open(st_path, encoding="utf-8").readlines()
+    with open(cleaned, "w", encoding="utf-8") as cleaned_file:
+        for line in lines:
+            if line.startswith("---"):
+                is_metadata = not is_metadata
+                continue
+            if not is_metadata:
+                cleaned_file.write(line)
+    return cleaned
+
+
+def alias_from_name(name):
+    alias = re.sub(r"[^a-zA-Z0-9]", "", name).lower()
+    return alias
+
+
+def open_comp(comp_name):
+    comp_alias = alias_from_name(comp_name)
+    try:
+        comp_id = petlja.create_competition(session, comp_name, comp_alias)
+        print(f"Created competition {comp_name}")
+    except ValueError:
+        comp_id = petlja.get_competition_id(session, comp_alias)
+        print(f"Found competition {comp_name}")
+    return comp_id
+
+
+def open_prob(prob_name):
+    prob_alias = alias_from_name(prob_name)
+    try:
+        prob_id = petlja.create_problem(session, prob_name, prob_alias)
+        print(f"Created problem {prob_name}")
+    except ValueError:
+        prob_id = petlja.get_problem_id(session, prob_alias)
+        print(f"Found problem {prob_name}")
+    return prob_id
+
+
+session = petlja.login()
+
+comp_path = Path.cwd()
+comp_name = comp_path.name
+comp_id = open_comp(comp_name)
+
+for problem_path in comp_path.iterdir():
+    if problem_path.is_dir():
+        problem_name = problem_path.name
+        problem_id = open_prob(problem_name)
+
+        subprocess.run(
+            ["petljapub", "tests-zip"], cwd=problem_path,
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+        )
+        testcases_path = problem_path.joinpath("_build/testcases.zip")
+        petlja.upload_testcases(session, problem_id, testcases_path)
+        print(f"Uploaded testcases for problem {problem_name}")
+
+        statement_path = next(problem_path.glob("*-st.md"))
+        cleaned_statement_path = remove_metadata(statement_path)
+        petlja.upload_statement(session, problem_id, cleaned_statement_path)
+        cleaned_statement_path.unlink()
+        print(f"Uploaded statement for problem {problem_name}")
+
+        petlja.add_problem(session, comp_id, problem_id)
+        print(f"Added problem {problem_name} to competition {comp_name}")
+
+        for solution_path in problem_path.iterdir():
+            if not is_for_testing(solution_path):
+                continue
+
+            solution_name = solution_path.name
+            language = solution_path.suffix
+            petlja.add_language(session, comp_id, language)
+            score = petlja.submit_solution(
+                session,
+                comp_id,
+                problem_id,
+                solution_path,
+            )
+            print(f"Submitted solution {solution_name} for problem {problem_name}")
+            print(f"Score: {score}")

petlja_api-0.0.1/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "petlja_api"
+version = "0.0.1"
+authors = [
+  { name="Pavle Sekešan", email="pavlesekesan@gmail.com" },
+]
+description = "A python library for interacting with the petlja.org API"
+readme = "README.md"
+requires-python = ">=3.7"
+dependencies = [
+    "beautifulsoup4==4.12.2",
+    "requests==2.31.0"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/PavleSekesan/petlja_api"

petlja_api-0.0.1/src/petlja_api/__init__.py

@@ -0,0 +1,4 @@
+from .auth import login
+from .competition import create_competition, get_competition_id, get_added_problem_ids, add_problem, upload_scoring, add_language
+from .problem import get_problem_id, get_problem_name, create_problem, upload_testcases, upload_statement
+from .submit import submit_solution

petlja_api-0.0.1/src/petlja_api/auth.py

@@ -0,0 +1,48 @@
+from getpass import getpass
+
+import requests
+from bs4 import BeautifulSoup
+
+from .urls import ARENA_URL
+
+
+def _get_credentials():
+    username = input("Petlja username: ")
+    password = getpass("Petlja password: ")
+    return username, password
+
+
+def get_csrf_token(page):
+    soup = BeautifulSoup(page, "html.parser")
+    csrf_token = soup.find("input", {"name": "__RequestVerificationToken"}).get("value")
+    return csrf_token
+
+
+def login(username=None, password=None):
+    if username is None or password is None:
+        username, password = _get_credentials()
+
+    session = requests.Session()
+    mainpage = session.get(ARENA_URL)
+    csrf_token = get_csrf_token(mainpage.text)
+    login_res = session.post(
+        f"{ARENA_URL}/sr-Latn-RS/Account/Login",
+        data={
+            "LoginViewModel.UserNameOrEmail": username,
+            "LoginViewModel.Password": password,
+            "__RequestVerificationToken": csrf_token,
+            "LoginViewModel.RememberMe": "false",
+        },
+        allow_redirects=False,
+    )
+
+    if login_res.status_code == 302:
+        jwt = session.cookies["PetljaCookie"]
+        session.headers.update({"Authorization": f"Bearer {jwt}"})
+        return session
+    elif login_res.status_code == 200:
+        raise PermissionError("Wrong username or password")
+    else:
+        raise RuntimeError(
+            f"Unknown error: login failed with status code {login_res.status_code}"
+        )

petlja_api-0.0.1/src/petlja_api/competition.py

@@ -0,0 +1,131 @@
+import json
+import re
+from datetime import datetime
+
+from bs4 import BeautifulSoup
+
+from .auth import get_csrf_token
+from .problem import get_problem_name
+from .urls import ARENA_URL, CPANEL_URL, PETLJA_URL
+from .submit import LANGUAGE_IDS
+
+
+def get_competition_id(session, alias):
+    page = session.get(f"{ARENA_URL}/competition/{alias}")
+    if (
+        page.status_code == 404
+        or 'error' in page.url
+    ):
+        raise ValueError(f"Competition with alias {alias} does not exist")
+
+    soup = BeautifulSoup(page.text, "html.parser")
+    competition_id = soup.find("button", attrs={"id": "ciRun"})["data-competition-id"]
+    return competition_id
+
+
+def get_added_problem_ids(session, competition_id):
+    page = session.get(f"{CPANEL_URL}/CompetitionTasks/{competition_id}")
+    soup = BeautifulSoup(page.text, "html.parser")
+    # Get object viewModel from inline script in html which contains data about added problems
+    # FIXME regex hack, should be replaced with a proper parser
+    regex = re.compile(r"var viewModel=({.*?});\n")
+    match = regex.search(soup.prettify()).group(1)
+    # Can be parsed as json since it is a javascript object
+    data = json.loads(match)
+    problem_ids = [str(problem["problemId"]) for problem in data["problems"]]
+    return problem_ids
+
+
+def create_competition(
+    session, name, alias=None, description=None, start_date=None, end_date=None
+):
+    if alias is None:
+        alias = ""
+    if description is None:
+        description = ""
+    if start_date is None:
+        start_date = datetime.now()
+    if end_date is None:
+        end_date = ""
+
+    regex = re.compile(r"^[a-z0-9-]+$")
+    if not regex.match(alias):
+        raise NameError(
+            f"Invalid alias {alias}: must contain only lowercase alphanumeric characters and dashes"
+        )
+
+    url = f"{CPANEL_URL}/CreateCompetition"
+    page = session.get(url)
+    csrf_token = get_csrf_token(page.text)
+    resp = session.post(
+        url,
+        data={
+            "Name": name,
+            "Alias": alias,
+            "Description": description,
+            "StartDate": start_date,
+            "EndDate": end_date,
+            "HasNotEndDate": [True, False],  # Not sure what this field does
+            "__RequestVerificationToken": csrf_token,
+        },
+        allow_redirects=False,
+    )
+
+    if resp.status_code == 302:
+        header_loc = resp.headers["Location"]  # /cpanel/CompetitionSettings/:comp_id
+        comp_id = header_loc.split("/")[-1]
+        return comp_id
+    elif resp.status_code == 200:
+        raise ValueError("Competition alias already exists")
+    else:
+        raise RuntimeError(f"Unknown error: {resp.status_code}")
+
+
+def add_problem(session, competition_id, problem_id):
+    already_added = get_added_problem_ids(session, competition_id)
+    if problem_id in already_added:
+        return
+
+    url = f"{PETLJA_URL}/api/dashboard/competitions/problems/add"
+    problem_name = get_problem_name(session, problem_id)
+    resp = session.post(
+        url,
+        json={
+            "competitionId": competition_id,
+            "problemId": problem_id,
+            "name": problem_name,
+            # "sortOrder": 0, # Seems to be optional
+        },
+    )
+
+    # TODO: Check for errors
+
+
+def upload_scoring(session, competition_id, problem_id, scoring_path):
+    url = f"{PETLJA_URL}/api/dashboard/competitions/problems/addGraderHints"
+    with open(scoring_path) as scoring_file:
+        scoring = scoring_file.read()
+    resp = session.post(
+        url,
+        json={
+            "competitionId": competition_id,
+            "problemId": problem_id,
+            "hintsYML": scoring,
+            "testCaseCount": 100,  # FIXME Count number of testcases from scoring file
+        },
+    )
+
+    errors = resp.json()["errors"]
+    if errors:
+        raise ValueError(f"Error uploading scoring, petlja response: {errors[0]}")
+
+def add_language(session, competition_id, extension):
+    url = f'{PETLJA_URL}/api/dashboard/competitions/programmingLanguages/add'
+    res = session.post(
+        url,
+        json={
+            "competitionId": competition_id,
+            "languageId": LANGUAGE_IDS[extension]
+        }
+    )
+    # TODO Check for errors

petlja_api-0.0.1/src/petlja_api/problem.py

@@ -0,0 +1,98 @@
+from bs4 import BeautifulSoup
+
+from .auth import get_csrf_token
+from .urls import CPANEL_URL, PROBLEMS_URL
+
+
+def get_problem_id(session, alias):
+    page = session.get(f"{PROBLEMS_URL}/{alias}")
+    if page.status_code == 404:
+        raise ValueError(f"Problem with alias {alias} does not exist")
+
+    soup = BeautifulSoup(page.text, "html.parser")
+    problem_id = soup.find("button", attrs={"class": "btn-solution-submit"})[
+        "data-problem-id"
+    ]
+    return problem_id
+
+
+def get_problem_name(session, problem_id):
+    page = session.get(f"{CPANEL_URL}/EditProblem/{problem_id}")
+    if page.status_code == 404:
+        raise ValueError(f"Problem with id {problem_id} does not exist")
+
+    soup = BeautifulSoup(page.text, "html.parser")
+    problem_name = soup.find("input", attrs={"id": "Problem_Name"})["value"]
+    return problem_name
+
+
+def create_problem(session, name, alias):
+    if not alias or not alias.isalnum() or not alias.islower():
+        raise NameError(
+            f"Invalid problem alias {alias}: must be alphanumeric and lowercase"
+        )
+
+    create_problem_page = session.get(f"{CPANEL_URL}/CreateTask")
+    csrf_token = get_csrf_token(create_problem_page.text)
+    resp = session.post(
+        f"{CPANEL_URL}/CreateTask",
+        data={
+            "Name": name,
+            "UniqueId": alias,
+            "Type": "0",
+            "__RequestVerificationToken": csrf_token,
+        },
+        allow_redirects=False
+    )
+    if resp.status_code == 302:
+        return get_problem_id(session, alias)
+    elif resp.status_code == 200:
+        raise ValueError("Problem alias already exists")
+    else:
+        raise RuntimeError(
+            "Unknown error while creating problem (status code {resp.status_code})"
+        )
+
+
+def check_testcase_upload(page):
+    soup = BeautifulSoup(page.text, "html.parser")
+    error = soup.find("div", attrs={"class": "validation-summary-errors"})
+    if error:
+        errmsg = f"Testcase upload failed: {error.text.strip()}"
+        if error.text.strip() == "UserIdNotFound":
+            errmsg += " (Is the zip file in the correct format?)"
+        raise ValueError(errmsg)
+
+
+def upload_testcases(session, problem_id, testcases_path):
+    page = session.get(f"{CPANEL_URL}/EditProblem/{problem_id}?tab=testcases")
+    csrf_token = get_csrf_token(page.text)
+    with open(testcases_path, "rb") as zipfile:
+        resp = session.post(
+            f"{CPANEL_URL}/EditProblem/{problem_id}",
+            files={"TestCases": zipfile},
+            data={
+                "PostAction": "EditTestCases",
+                "__RequestVerificationToken": csrf_token,
+            },
+        )
+    # Have to scrape the response page to check for errors
+    # because the response is 302 even if there is an error
+    check_testcase_upload(resp)
+
+
+def upload_statement(session, problem_id, statement_path):
+    page = session.get(f"{CPANEL_URL}/EditProblem/{problem_id}?tab=statement")
+    csrf_token = get_csrf_token(page.text)
+    with open(statement_path, encoding="utf-8") as statement:
+        resp = session.post(
+            f"{CPANEL_URL}/EditProblem/{problem_id}",
+            data={
+                "Problem.ProblemStatementMD": statement.read(),
+                "PostAction": "EditStatement",
+                "Problem.MDSupported": "true",
+                "__RequestVerificationToken": csrf_token,
+            },
+            allow_redirects=False,
+        )
+    # TODO: check for errors

petlja_api-0.0.1/src/petlja_api/submit.py

@@ -0,0 +1,54 @@
+from .urls import ARENA_URL
+import time
+
+# Weird Petlja API language IDs
+LANGUAGE_IDS = {
+    ".c": 10,
+    ".cs": 1,
+    ".cpp": 2,
+    ".java": 3,
+    ".m": 7,
+    ".pas": 4,
+    ".py": 9,
+}
+
+TIMEOUT = 30
+
+
+def submit_solution(session, competition_id, problem_id, source_path):
+    with open(source_path) as source_file:
+        source = source_file.read()
+
+    extension = source_path.suffix
+    submit_res = session.post(
+        f"{ARENA_URL}/api/competition/submit-competition-problem",
+        json={
+            "competitionId": competition_id,
+            "problemId": problem_id,
+            "source": source,
+            "languageId": LANGUAGE_IDS[extension],
+        },
+    )
+    success = submit_res.json()["succeeded"]
+    if not success:
+        error = submit_res.json()["errors"][0]["description"]
+        raise Exception(error)
+    submission_id = submit_res.json()["value"]
+    # Polling the server every x seconds
+    # Better solution may exist
+    tries = 0
+    while tries < TIMEOUT:
+        submission_data = session.post(
+            f"{ARENA_URL}/api/competition/submissions",
+            json={
+                "competitionId": competition_id,
+                "idStamp": submission_id,
+                "loadNew": True,
+            },
+        )
+        score = submission_data.json()["value"]["item1"][0]["score"]
+        if score != '-':
+            return score
+        time.sleep(1)
+
+    raise TimeoutError

petlja_api-0.0.1/src/petlja_api/urls.py

@@ -0,0 +1,4 @@
+ARENA_URL = "https://arena.petlja.org"
+PETLJA_URL = "https://petlja.org"
+CPANEL_URL = f"{PETLJA_URL}/sr-Latn-RS/cpanel"
+PROBLEMS_URL = f"{PETLJA_URL}/sr-Latn-RS/problems"

petlja_api-0.0.1/tests/test_modules.py

@@ -0,0 +1,236 @@
+import os
+import random
+
+import pytest
+import requests
+import petlja_api as petlja
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+@pytest.fixture
+def sess():
+    return petlja.login(os.environ['PETLJA_USER'], os.environ['PETLJA_PASS'])
+
+
+@pytest.fixture
+def created_prob(sess):
+    uid = random.randint(1000, 9999)
+    alias = f"testprob{uid}"
+    pid = petlja.create_problem(sess, "Test zadatak", alias)
+    return pid, alias
+
+
+@pytest.fixture
+def empty_comp(sess):
+    uid = random.randint(1000, 9999)
+    alias = f"testcomp{uid}"
+    cid = petlja.create_competition(sess, "Test takmicenje", alias)
+    return cid, alias
+
+
+@pytest.fixture
+def comp_with_problems(sess, empty_comp, created_prob, scoring, testcases):
+    cid, alias = empty_comp
+    pid, _ = created_prob
+    petlja.add_problem(sess, cid, pid)
+    petlja.upload_testcases(sess, pid, testcases)
+    petlja.upload_scoring(sess, cid, pid, scoring)
+    return cid, alias
+
+
+@pytest.fixture
+def src_ok(tmp_path):
+    src = """
+    #include <iostream>
+    using namespace std;
+
+    int main()
+    {
+        int a, b; cin >> a >> b;
+        cout << 2 * (a + b) << endl;
+    }
+    """
+    path = tmp_path / "trening_ok.cpp"
+    path.write_text(src)
+    return path
+
+
+@pytest.fixture
+def src_wa(tmp_path):
+    src = """
+    #include <iostream>
+    using namespace std;
+
+    int main()
+    {
+        return 0;
+    }
+    """
+    path = tmp_path / "trening_wa.cpp"
+    path.write_text(src)
+    return path
+
+
+@pytest.fixture
+def src_py(tmp_path):
+    src = """
+    a = int(input())
+    b = int(input())
+    print(2 * (a + b))
+    """
+    path = tmp_path / "trening.py"
+    path.write_text(src)
+    return path
+
+
+@pytest.fixture
+def statement(tmp_path):
+    st = """
+    За низ ћемо рећи да је **уравнотежен** ако је збир његових елемената једнак његовој дужини (броју елемената).
+
+    Дат је низ $a$ дужине $n$, чији су елементи једноцифрени бројеви. Одредити колико он садржи уравнотежених сегмената (поднизова са узастопним елементима).
+
+    ## Улаз
+
+    У првом реду стандардног улаза је број $n$ $(1 \leq n \leq 10^5)$, а у другом $n$ ненегативних једноцифрених бројева, раздвојених по једним размаком.
+
+    ## Излаз
+
+    На стандардни излаз исписати тражени број.
+
+    ## Пример
+
+    ### Улаз
+
+    ~~~
+    5
+    0 3 0 0 2
+    ~~~
+
+    ### Излаз
+
+    ~~~
+    4
+    ~~~
+
+    *Објашњење*: Тражени сегменти су $[0 3 0]$, $[3 0 0]$, $[0 2]$ и $[0 3 0 0 2]$.
+
+    """
+    path = tmp_path / "tekst-st.md"
+    path.write_text(st)
+    return path
+
+
+@pytest.fixture
+def testcases():
+    return "tests/data/testcases.zip"
+
+
+@pytest.fixture
+def scoring(tmp_path):
+    yaml = """
+    type: testcase
+    score_total: 100
+    score_overrides:
+    - {name: 1, score: 10}
+    - {name: 2, score: 10}
+    - {name: 3, score: 10}
+    - {name: 4, score: 10}
+    - {name: 5, score: 10}
+    - {name: 6, score: 10}
+    - {name: 7, score: 10}
+    - {name: 8, score: 10}
+    - {name: 9, score: 10}
+    - {name: 10, score: 10}
+    public: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    """
+    scoring_path = tmp_path / "scoring.yaml"
+    scoring_path.write_text(yaml)
+    return scoring_path
+
+
+def test_login_success(sess):
+    assert sess is not None
+
+
+def test_login_failed():
+    with pytest.raises(PermissionError):
+        petlja.login("wrongusername", "wrongpass")
+
+
+def test_submit_ok(sess, comp_with_problems, src_ok):
+    cid, _ = comp_with_problems
+    pid = petlja.get_added_problem_ids(sess, cid)[0]
+    score = petlja.submit_solution(sess, cid, pid, src_ok)
+    assert int(score) > 0
+
+
+def test_submit_wa(sess, comp_with_problems, src_wa):
+    cid, _ = comp_with_problems
+    pid = petlja.get_added_problem_ids(sess, cid)[0]
+    score = petlja.submit_solution(sess, cid, pid, src_wa)
+    assert score == "0"
+
+
+def test_create_problem(created_prob):
+    _, alias = created_prob
+    res = requests.get(f"https://petlja.org/problems/{alias}")
+    assert res.status_code == 200
+
+
+def test_create_already_existing_prob(sess):
+    with pytest.raises(ValueError):
+        petlja.create_problem(sess, "Postojeci problem", "osdrz23odbijanje")
+
+
+def test_upload_testcases(sess, created_prob, testcases):
+    id, _ = created_prob
+    petlja.upload_testcases(sess, id, testcases)
+
+
+def test_upload_statement(sess, created_prob, statement):
+    id, _ = created_prob
+    petlja.upload_statement(sess, id, statement)
+
+
+def test_upload_scoring(sess, comp_with_problems, scoring):
+    cid, _ = comp_with_problems
+    pid = petlja.get_added_problem_ids(sess, cid)[0]
+    petlja.upload_scoring(sess, cid, pid, scoring)
+
+
+def test_get_competition_id(sess, empty_comp):
+    cid, alias = empty_comp
+    assert petlja.get_competition_id(sess, alias) == cid
+
+
+def test_get_competition_id_nonexistent(sess):
+    with pytest.raises(ValueError):
+        petlja.get_competition_id(sess, 'qurvoqireouqh')
+
+
+def test_submit_unallowed_lang(sess, comp_with_problems, created_prob, src_py):
+    cid, _ = comp_with_problems
+    pid, _ = created_prob
+    with pytest.raises(Exception):
+        petlja.submit_solution(sess, cid, pid, src_py)
+
+
+# Testing TLE is slow
+
+# def test_submit_tle(sess, cid, pid, tmp_path):
+#     src = """
+#     #include <iostream>
+#     using namespace std;
+
+#     int main()
+#     {
+#         int a, b; cin >> a >> b;
+#         while(true) {}
+#     }
+#     """
+#     src_path = tmp_path / "trening_tle.cpp"
+#     score = _submit_src_file(sess, cid, pid, src, src_path)
+#     assert score == "0"