polygon-api 1.1.0a2__tar.gz → 1.1.0a3__tar.gz

{polygon_api-1.1.0a2 → polygon_api-1.1.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polygon_api
-Version: 1.1.0a2
+Version: 1.1.0a3
 Summary: Python wrapper for Polygon API (polygon.codeforces.com)
 Home-page: https://github.com/citxx/polygon-py
 Author: Artem Tabolin

polygon_api-1.1.0a3/polygon_api/__init__.py

@@ -0,0 +1,30 @@
+from .api import (
+    Polygon,
+    Problem,
+    ProblemInfo,
+    Test,
+    ManualTest,
+    GeneratedTest,
+    TestGroup,
+    Statement,
+    Package,
+    Solution,
+    File,
+    ResourceAdvancedProperties,
+    ValidatorTest,
+    CheckerTest,
+    PolygonRequestFailedException,
+    HTTPRequestFailedException,
+    PointsPolicy,
+    FeedbackPolicy,
+    FileType,
+    SolutionTag,
+    Stage,
+    Asset,
+    PackageState,
+    PackageType,
+    ValidatorTestVerdict,
+    CheckerTestVerdict
+)
+
+__version__ = "1.1.0"

{polygon_api-1.1.0a2 → polygon_api-1.1.0a3}/polygon_api/api.py

@@ -4,9 +4,25 @@ import random
 import requests
 import string
 import time
+from collections.abc import Iterable
 from enum import Enum
 
 
+def _comma_separated(value):
+    """
+    Formats a value for an API parameter accepting a comma-separated list.
+
+    A string is passed through unchanged, any other iterable is joined with
+    commas, and anything else is stringified. None is returned as is, so that
+    Request omits the parameter altogether.
+    """
+    if value is None or isinstance(value, str):
+        return value
+    if isinstance(value, Iterable):
+        return ",".join(map(str, value))
+    return str(value)
+
+
 class Polygon:
     """
     """
@@ -26,7 +42,12 @@ class Polygon:
     _PROBLEM_CREATE = 'problem.create'
     _PROBLEM_CHECKER = 'problem.checker'
     _PROBLEM_VALIDATOR = 'problem.validator'
+    _PROBLEM_EXTRA_VALIDATORS = 'problem.extraValidators'
     _PROBLEM_INTERACTOR = 'problem.interactor'
+    _PROBLEM_VALIDATOR_TESTS = 'problem.validatorTests'
+    _PROBLEM_SAVE_VALIDATOR_TEST = 'problem.saveValidatorTest'
+    _PROBLEM_CHECKER_TESTS = 'problem.checkerTests'
+    _PROBLEM_SAVE_CHECKER_TEST = 'problem.saveCheckerTest'
     _PROBLEM_FILES = 'problem.files'
     _PROBLEM_SOLUTIONS = 'problem.solutions'
     _PROBLEM_VIEW_FILE = 'problem.viewFile'
@@ -43,9 +64,9 @@ class Polygon:
     _PROBLEM_EDIT_SOLUTION_EXTRA_TAGS = 'problem.editSolutionExtraTags'
     _PROBLEM_SAVE_SCRIPT = 'problem.saveScript'
     _PROBLEM_SAVE_TEST = 'problem.saveTest'
+    _PROBLEM_SET_TEST_GROUP = 'problem.setTestGroup'
     _PROBLEM_ENABLE_GROUPS = 'problem.enableGroups'
     _PROBLEM_ENABLE_POINTS = 'problem.enablePoints'
-    _PROBLEM_SET_TEST_GROUP = 'problem.setTestGroup'
     _PROBLEM_VIEW_TEST_GROUP = 'problem.viewTestGroup'
     _PROBLEM_SAVE_TEST_GROUP = 'problem.saveTestGroup'
     _PROBLEM_VIEW_TAGS = 'problem.viewTags'
@@ -54,9 +75,9 @@ class Polygon:
     _PROBLEM_SAVE_GENERAL_DESCRIPTION = 'problem.saveGeneralDescription'
     _PROBLEM_VIEW_GENERAL_TUTORIAL = 'problem.viewGeneralTutorial'
     _PROBLEM_SAVE_GENERAL_TUTORIAL = 'problem.saveGeneralTutorial'
-    _PROBLEM_BUILD_PACKAGE = 'problem.buildPackage'
     _PROBLEM_PACKAGES = 'problem.packages'
     _PROBLEM_PACKAGE = 'problem.package'
+    _PROBLEM_BUILD_PACKAGE = 'problem.buildPackage'
 
     def __init__(self, api_url, api_key, api_secret):
         self.request_config = RequestConfig(api_url, api_key, api_secret)
@@ -287,44 +308,6 @@ class Polygon:
         )
         return response.result
 
-    def problem_set_test_group(self, problem_id, testset, test_group, test_index=None, test_indices=None):
-        """
-        """
-        if isinstance(test_indices, list):
-            test_indices = ",".join(map(str, test_indices))
-        response = self._request_ok_or_raise(
-            self._PROBLEM_SET_TEST_GROUP,
-            args={
-                'problemId': problem_id,
-                'testset': testset,
-                'testGroup': test_group,
-                'testIndex': test_index,
-                'testIndices': test_indices,
-            },
-        )
-        return response.result
-
-    def problem_script(self, problem_id, testset):
-        response = self._request_ok_or_raise(
-            self._PROBLEM_SCRIPT,
-            args={
-                'problemId': problem_id,
-                'testset': testset,
-            },
-        )
-        return response.result
-
-    def problem_save_script(self, problem_id, testset, source):
-        response = self._request_ok_or_raise(
-            self._PROBLEM_SAVE_SCRIPT,
-            args={
-                'problemId': problem_id,
-                'testset': testset,
-                'source': source,
-            }
-        )
-        return response.result
-
     def problem_save_test(self, problem_id, testset, test_index, test_input, test_group=None, test_points=None,
                           test_description=None, test_use_in_statements=None, test_input_for_statements=None,
                           test_output_for_statements=None, verify_input_output_for_statements=None,
@@ -350,6 +333,26 @@ class Polygon:
         )
         return response.result
 
+    def problem_set_test_group(self, problem_id, testset, test_group, test_index=None, test_indices=None):
+        if test_index is None and test_indices is None:
+            raise ValueError("Either test_index or test_indices must be specified")
+        if test_index is not None and test_indices is not None:
+            raise ValueError("Only one of test_index or test_indices must be specified")
+
+        test_indices = _comma_separated(test_indices)
+
+        response = self._request_ok_or_raise(
+            self._PROBLEM_SET_TEST_GROUP,
+            args={
+                'problemId': problem_id,
+                'testset': testset,
+                'testGroup': test_group,
+                'testIndex': test_index,
+                'testIndices': test_indices,
+            }
+        )
+        return response.result
+
     def problem_solutions(self, problem_id):
         response = self._request_ok_or_raise(
             self._PROBLEM_SOLUTIONS,
@@ -379,34 +382,52 @@ class Polygon:
         )
         return [Test.from_json(self, problem_id, testset, js) for js in response.result]
 
-    def problem_test_input(self, problem_id, testset, test_index):
-        response = self._request_raw(
+    def problem_script(self, problem_id, testset):
+        """
+        Returns test generation script
+        """
+        response = self._request_text(
+            self._PROBLEM_SCRIPT,
+            args={
+                'problemId': problem_id,
+                'testset': testset,
+            }
+        )
+        return response
+
+    def problem_test_input(self, problem_id, testset, test_index, binary=False):
+        """
+        Returns generated test input, as bytes if binary is true
+        """
+        response = self._request_body(
             self._PROBLEM_TEST_INPUT,
             args={
                 'problemId': problem_id,
                 'testset': testset,
                 'testIndex': test_index,
-            }
+            },
+            binary=binary
         )
         return response
 
-    def problem_test_answer(self, problem_id, testset, test_index):
-        response = self._request_raw(
+    def problem_test_answer(self, problem_id, testset, test_index, binary=False):
+        """
+        Returns generated test answer, as bytes if binary is true
+        """
+        response = self._request_body(
             self._PROBLEM_TEST_ANSWER,
             args={
                 'problemId': problem_id,
                 'testset': testset,
                 'testIndex': test_index,
-            }
+            },
+            binary=binary
         )
         return response
 
     def problem_save_test_group(self, problem_id, testset, group, points_policy=None, feedback_policy=None,
                                 dependencies=None):
-        if isinstance(dependencies, list):
-            dependencies = ",".join(map(str, dependencies))
-        elif dependencies is not None:
-            dependencies = str(dependencies)
+        dependencies = _comma_separated(dependencies)
         if points_policy is not None and not isinstance(points_policy, PointsPolicy):
             raise ValueError(
                 "Expected PointsPolicy instance for points_policy argument, but %s found" % type(points_policy))
@@ -426,34 +447,37 @@ class Polygon:
         )
         return response.result
 
-    def problem_view_test_group(self, testset, group):
+    def problem_view_test_group(self, problem_id, testset, group=None):
         response = self._request_ok_or_raise(
             self._PROBLEM_VIEW_TEST_GROUP,
             args={
+                'problemId': problem_id,
                 'testset': testset,
                 'group': group,
             },
         )
-        return TestGroup.from_json(response.result)
+        return [TestGroup.from_json(js) for js in response.result]
 
-    def problem_view_file(self, problem_id, type, name):
-        response = self._request_raw(
+    def problem_view_file(self, problem_id, type, name, binary=False):
+        response = self._request_body(
             self._PROBLEM_VIEW_FILE,
             args={
                 'problemId': problem_id,
                 'type': type,
                 'name': name
-            }
+            },
+            binary=binary
         )
         return response
 
-    def problem_view_solution(self, problem_id, name):
-        response = self._request_raw(
+    def problem_view_solution(self, problem_id, name, binary=False):
+        response = self._request_body(
             self._PROBLEM_VIEW_SOLUTION,
             args={
                 'problemId': problem_id,
                 'name': name
-            }
+            },
+            binary=binary
         )
         return response
 
@@ -479,7 +503,7 @@ class Polygon:
         )
         return response.result
 
-    def problem_save_solution(self, problem_id, name, file, source_type, tag, check_existing=None):
+    def problem_save_solution(self, problem_id, name, file, tag, source_type=None, check_existing=None):
         response = self._request_ok_or_raise(
             self._PROBLEM_SAVE_SOLUTION,
             args={
@@ -493,6 +517,39 @@ class Polygon:
         )
         return response.result
 
+    def problem_save_script(self, problem_id, testset, source):
+        """
+        Edit test generation script
+        """
+        response = self._request_ok_or_raise(
+            self._PROBLEM_SAVE_SCRIPT,
+            args={
+                'problemId': problem_id,
+                'testset': testset,
+                'source': source,
+            }
+        )
+        return response.result
+
+    def problem_edit_solution_extra_tags(self, problem_id, remove, name, testset=None, test_group=None, tag=None):
+        if (testset is None) == (test_group is None):
+            raise ValueError("Exactly one of testset or test_group must be specified")
+        if tag is not None and not isinstance(tag, SolutionTag):
+            raise ValueError(
+                "Expected SolutionTag instance for tag argument, but %s found" % type(tag))
+        response = self._request_ok_or_raise(
+            self._PROBLEM_EDIT_SOLUTION_EXTRA_TAGS,
+            args={
+                'problemId': problem_id,
+                'remove': remove,
+                'name': name,
+                'testset': testset,
+                'testGroup': test_group,
+                'tag': tag,
+            }
+        )
+        return response.result
+
     def problem_checker(self, problem_id):
         response = self._request_ok_or_raise(
             self._PROBLEM_CHECKER,
@@ -512,6 +569,34 @@ class Polygon:
         )
         return response.result
 
+    def problem_checker_tests(self, problem_id):
+        response = self._request_ok_or_raise(
+            self._PROBLEM_CHECKER_TESTS,
+            args={
+                'problemId': problem_id,
+            },
+        )
+        return [CheckerTest.from_json(js) for js in response.result]
+
+    def problem_save_checker_test(self, problem_id, test_index, test_input=None, test_output=None,
+                                  test_answer=None, test_verdict=None, check_existing=None):
+        if test_verdict is not None and not isinstance(test_verdict, CheckerTestVerdict):
+            raise ValueError(
+                "Expected CheckerTestVerdict instance for test_verdict argument, but %s found" % type(test_verdict))
+        response = self._request_ok_or_raise(
+            self._PROBLEM_SAVE_CHECKER_TEST,
+            args={
+                'problemId': problem_id,
+                'testIndex': test_index,
+                'testInput': test_input,
+                'testOutput': test_output,
+                'testAnswer': test_answer,
+                'testVerdict': test_verdict,
+                'checkExisting': check_existing,
+            },
+        )
+        return response.result
+
     def problem_validator(self, problem_id):
         response = self._request_ok_or_raise(
             self._PROBLEM_VALIDATOR,
@@ -531,6 +616,43 @@ class Polygon:
         )
         return response.result
 
+    def problem_extra_validators(self, problem_id):
+        response = self._request_ok_or_raise(
+            self._PROBLEM_EXTRA_VALIDATORS,
+            args={
+                'problemId': problem_id,
+            },
+        )
+        return response.result
+
+    def problem_validator_tests(self, problem_id):
+        response = self._request_ok_or_raise(
+            self._PROBLEM_VALIDATOR_TESTS,
+            args={
+                'problemId': problem_id,
+            },
+        )
+        return [ValidatorTest.from_json(js) for js in response.result]
+
+    def problem_save_validator_test(self, problem_id, test_index, test_input=None, test_verdict=None,
+                                    test_group=None, testset=None, check_existing=None):
+        if test_verdict is not None and not isinstance(test_verdict, ValidatorTestVerdict):
+            raise ValueError(
+                "Expected ValidatorTestVerdict instance for test_verdict argument, but %s found" % type(test_verdict))
+        response = self._request_ok_or_raise(
+            self._PROBLEM_SAVE_VALIDATOR_TEST,
+            args={
+                'problemId': problem_id,
+                'testIndex': test_index,
+                'testInput': test_input,
+                'testVerdict': test_verdict,
+                'testGroup': test_group,
+                'testset': testset,
+                'checkExisting': check_existing,
+            },
+        )
+        return response.result
+
     def problem_interactor(self, problem_id):
         response = self._request_ok_or_raise(
             self._PROBLEM_INTERACTOR,
@@ -551,13 +673,14 @@ class Polygon:
         return response.result
 
     def problem_packages(self, problem_id):
+        """
+        Returns list of packages
+        """
         response = self._request_ok_or_raise(
             self._PROBLEM_PACKAGES,
-            args={
-                'problemId': problem_id,
-            },
+            args={'problemId': problem_id},
         )
-        return [Package.from_json(package) for package in response.result]
+        return [Package.from_json(js) for js in response.result]
 
     def problem_package(self, problem_id, package_id, type=None):
         return self._request_raw(
@@ -569,14 +692,17 @@ class Polygon:
             },
         )
 
-    def problem_build_package(self, problem_id, full, verify):
+    def problem_build_package(self, problem_id, verify, full):
+        """
+        Start building a package
+        """
         response = self._request_ok_or_raise(
             self._PROBLEM_BUILD_PACKAGE,
             args={
                 'problemId': problem_id,
-                'full': full,
                 'verify': verify,
-            },
+                'full': full,
+            }
         )
         return response.result
 
@@ -602,10 +728,19 @@ class Polygon:
         request = Request(self.request_config, method_name, args)
         return request.issue()
 
+    def _request_text(self, method_name, args=None):
+        request = Request(self.request_config, method_name, args)
+        return request.issue_text()
+
     def _request_raw(self, method_name, args=None):
         request = Request(self.request_config, method_name, args)
         return request.issue_raw()
 
+    def _request_body(self, method_name, args=None, binary=False):
+        if binary:
+            return self._request_raw(method_name, args)
+        return self._request_text(method_name, args)
+
 
 class Problem:
     """
@@ -706,15 +841,6 @@ class Problem:
     def enable_points(self, enable):
         return self._polygon.problem_enable_points(self.id, enable)
 
-    def set_test_group(self, testset, test_group, test_index=None, test_indices=None):
-        return self._polygon.problem_set_test_group(self.id, testset, test_group, test_index, test_indices)
-
-    def script(self, testset):
-        return self._polygon.problem_script(self.id, testset)
-
-    def save_script(self, testset, source):
-        return self._polygon.problem_save_script(self.id, testset, source)
-
     def save_test(self, testset, test_index, test_input, test_group=None, test_points=None, test_description=None,
                   test_use_in_statements=None, test_input_for_statements=None, test_output_for_statements=None,
                   verify_input_output_for_statements=None, check_existing=None):
@@ -723,34 +849,34 @@ class Problem:
                                                test_output_for_statements, verify_input_output_for_statements,
                                                check_existing)
 
+    def set_test_group(self, testset, test_group, test_index=None, test_indices=None):
+        return self._polygon.problem_set_test_group(self.id, testset, test_group, test_index, test_indices)
+
     def tests(self, testset, no_inputs=None):
         return self._polygon.problem_tests(self.id, testset, no_inputs)
 
-    def test_input(self, testset, test_index):
-        return self._polygon.problem_test_input(self.id, testset, test_index)
-
-    def test_answer(self, testset, test_index):
-        return self._polygon.problem_test_answer(self.id, testset, test_index)
-
     def save_test_group(self, testset, group, points_policy=None, feedback_policy=None, dependencies=None):
         return self._polygon.problem_save_test_group(self.id, testset, group,
                                                      points_policy, feedback_policy, dependencies)
 
-    def view_test_group(self, testset, group):
-        return self._polygon.problem_view_test_group(testset, group)
+    def view_test_group(self, testset, group=None):
+        return self._polygon.problem_view_test_group(self.id, testset, group)
 
-    def view_file(self, type, name):
-        return self._polygon.problem_view_file(self.id, type, name)
+    def view_file(self, type, name, binary=False):
+        return self._polygon.problem_view_file(self.id, type, name, binary)
 
-    def view_solution(self, name):
-        return self._polygon.problem_view_solution(self.id, name)
+    def view_solution(self, name, binary=False):
+        return self._polygon.problem_view_solution(self.id, name, binary)
 
     def save_file(self, type, name, file, source_type=None, resource_advanced_properties=None, check_existing=None):
         return self._polygon.problem_save_file(self.id, type, name, file, source_type,
                                                resource_advanced_properties, check_existing)
 
-    def save_solution(self, name, file, source_type, tag, check_existing=None):
-        return self._polygon.problem_save_solution(self.id, name, file, source_type, tag, check_existing)
+    def save_solution(self, name, file, tag, source_type=None, check_existing=None):
+        return self._polygon.problem_save_solution(self.id, name, file, tag, source_type, check_existing)
+
+    def edit_solution_extra_tags(self, remove, name, testset=None, test_group=None, tag=None):
+        return self._polygon.problem_edit_solution_extra_tags(self.id, remove, name, testset, test_group, tag)
 
     def checker(self):
         return self._polygon.problem_checker(self.id)
@@ -758,12 +884,31 @@ class Problem:
     def set_checker(self, checker):
         return self._polygon.problem_set_checker(self.id, checker)
 
+    def checker_tests(self):
+        return self._polygon.problem_checker_tests(self.id)
+
+    def save_checker_test(self, test_index, test_input=None, test_output=None,
+                          test_answer=None, test_verdict=None, check_existing=None):
+        return self._polygon.problem_save_checker_test(self.id, test_index, test_input, test_output,
+                                                       test_answer, test_verdict, check_existing)
+
     def validator(self):
         return self._polygon.problem_validator(self.id)
 
     def set_validator(self, validator):
         return self._polygon.problem_set_validator(self.id, validator)
 
+    def validator_tests(self):
+        return self._polygon.problem_validator_tests(self.id)
+
+    def save_validator_test(self, test_index, test_input=None, test_verdict=None,
+                            test_group=None, testset=None, check_existing=None):
+        return self._polygon.problem_save_validator_test(self.id, test_index, test_input, test_verdict,
+                                                         test_group, testset, check_existing)
+
+    def extra_validators(self):
+        return self._polygon.problem_extra_validators(self.id)
+
     def interactor(self):
         return self._polygon.problem_interactor(self.id)
 
@@ -785,14 +930,26 @@ class Problem:
     def files_aux(self):
         return self.files()[FileType.AUX]
 
+    def script(self, testset):
+        return self._polygon.problem_script(self.id, testset)
+
+    def test_input(self, testset, test_index, binary=False):
+        return self._polygon.problem_test_input(self.id, testset, test_index, binary)
+
+    def test_answer(self, testset, test_index, binary=False):
+        return self._polygon.problem_test_answer(self.id, testset, test_index, binary)
+
+    def save_script(self, testset, source):
+        return self._polygon.problem_save_script(self.id, testset, source)
+
     def packages(self):
         return self._polygon.problem_packages(self.id)
 
-    def package(self, packageId, type=None):
-        return self._polygon.problem_package(self.id, packageId, type)
+    def package(self, package_id, type=None):
+        return self._polygon.problem_package(self.id, package_id, type)
 
-    def build_package(self, full, verify):
-        return self._polygon.problem_build_package(self.id, full, verify)
+    def build_package(self, verify, full):
+        return self._polygon.problem_build_package(self.id, verify, full)
 
 
 class ProblemInfo:
@@ -991,6 +1148,37 @@ class Statement:
         self.tutorial = tutorial
 
 
+class Package:
+    """
+    Object: representing Polygon package
+    """
+    _ID = "id"
+    _REVISION = "revision"
+    _CREATION_TIME_SECONDS = "creationTimeSeconds"
+    _STATE = "state"
+    _COMMENT = "comment"
+    _TYPE = "type"
+
+    @classmethod
+    def from_json(cls, package_json):
+        return cls(
+            id=package_json[Package._ID],
+            revision=package_json[Package._REVISION],
+            creation_time_seconds=package_json[Package._CREATION_TIME_SECONDS],
+            state=PackageState[package_json[Package._STATE]],
+            comment=package_json[Package._COMMENT],
+            type=PackageType[package_json[Package._TYPE].upper()]
+        )
+
+    def __init__(self, id, revision, creation_time_seconds, state, comment, type):
+        self.id = id
+        self.revision = revision
+        self.creation_time_seconds = creation_time_seconds
+        self.state = state
+        self.comment = comment
+        self.type = type
+
+
 class Solution:
     """
     Object: representing Polygon problem solution
@@ -1048,37 +1236,6 @@ class File:
         self.resource_advanced_properties = resource_advanced_properties
 
 
-class Package:
-    """
-    Object: representing Polygon package
-    """
-    _ID = "id"
-    _REVISION = "revision"
-    _CREATION_TIME_SECONDS = "creationTimeSeconds"
-    _STATE = "state"
-    _COMMENT = "comment"
-    _TYPE = "type"
-
-    @classmethod
-    def from_json(cls, file_json):
-        return cls(
-            id=file_json[Package._ID],
-            revision=file_json[Package._REVISION],
-            creation_time_seconds=file_json[Package._CREATION_TIME_SECONDS],
-            state=file_json[Package._STATE],
-            comment=file_json[Package._COMMENT],
-            type=file_json.get(Package._TYPE, None)
-        )
-
-    def __init__(self, id, revision, creation_time_seconds, state, comment, type):
-        self.id = id
-        self.revision = revision
-        self.creation_time_seconds = creation_time_seconds
-        self.state = state
-        self.comment = comment
-        self.type = type
-
-
 class ResourceAdvancedProperties:
     """
     """
@@ -1106,6 +1263,62 @@ class ResourceAdvancedProperties:
 ResourceAdvancedProperties.DELETE = ResourceAdvancedProperties(for_types="")
 
 
+class ValidatorTest:
+    """
+    Object: representing Polygon validator test
+    """
+    _INDEX = "index"
+    _INPUT = "input"
+    _EXPECTED_VERDICT = "expectedVerdict"
+    _TESTSET = "testset"
+    _GROUP = "group"
+
+    @classmethod
+    def from_json(cls, validator_test_json):
+        return cls(
+            index=validator_test_json[ValidatorTest._INDEX],
+            input=validator_test_json[ValidatorTest._INPUT],
+            expected_verdict=ValidatorTestVerdict[validator_test_json[ValidatorTest._EXPECTED_VERDICT]],
+            testset=validator_test_json.get(ValidatorTest._TESTSET, None),
+            group=validator_test_json.get(ValidatorTest._GROUP, None),
+        )
+
+    def __init__(self, index, input, expected_verdict, testset=None, group=None):
+        self.index = index
+        self.input = input
+        self.expected_verdict = expected_verdict
+        self.testset = testset
+        self.group = group
+
+
+class CheckerTest:
+    """
+    Object: representing Polygon checker test
+    """
+    _INDEX = "index"
+    _INPUT = "input"
+    _OUTPUT = "output"
+    _ANSWER = "answer"
+    _EXPECTED_VERDICT = "expectedVerdict"
+
+    @classmethod
+    def from_json(cls, checker_test_json):
+        return cls(
+            index=checker_test_json[CheckerTest._INDEX],
+            input=checker_test_json[CheckerTest._INPUT],
+            output=checker_test_json[CheckerTest._OUTPUT],
+            answer=checker_test_json[CheckerTest._ANSWER],
+            expected_verdict=CheckerTestVerdict[checker_test_json[CheckerTest._EXPECTED_VERDICT]],
+        )
+
+    def __init__(self, index, input, output, answer, expected_verdict):
+        self.index = index
+        self.input = input
+        self.output = output
+        self.answer = answer
+        self.expected_verdict = expected_verdict
+
+
 class Request:
     """
     Request to Polygon API.
@@ -1150,15 +1363,25 @@ class Request:
     def issue(self):
         """Issues request and returns parsed JSON response"""
 
-        response_raw = self.issue_raw()
+        response_text = self.issue_text()
         try:
-            response_json = json.loads(response_raw)
+            response_json = json.loads(response_text)
         except json.decoder.JSONDecodeError as exc:
             raise HTTPRequestFailedException(f'Method {self.method_name} has not returned a valid JSON.') from exc
         return Response(response_json)
 
+    def issue_text(self):
+        """Issues request and returns the response body as text (useful e.g. for scripts and tests)"""
+
+        return self._issue().text
+
     def issue_raw(self):
-        """Issues request and returns raw response (useful e.g. for files)"""
+        """Issues request and returns the response body as bytes (useful e.g. for packages)"""
+
+        return self._issue().content
+
+    def _issue(self):
+        """Issues request and returns the requests.Response as is"""
 
         args = list(self.args)
         args.append(('apiKey', self.config.api_key))
@@ -1172,7 +1395,7 @@ class Request:
                 response.raise_for_status()
             except requests.exceptions.HTTPError as exc:
                 raise HTTPRequestFailedException(f'Method {self.method_name} returned HTTP code {response.status_code}') from exc
-        return response.content
+        return response
 
     def get_api_signature(self, args, api_secret):
         rand_bit = Request._value_to_utf8_bytes(''.join(
@@ -1295,3 +1518,40 @@ class Stage(Enum):
 
     def __str__(self):
         return self.name
+
+
+class PackageState(Enum):
+    PENDING = 0
+    RUNNING = 1
+    READY = 2
+    FAILED = 3
+
+    def __str__(self):
+        return self.name
+
+
+class PackageType(Enum):
+    STANDARD = 0
+    LINUX = 1
+    WINDOWS = 2
+
+    def __str__(self):
+        return self.name.lower()
+
+
+class ValidatorTestVerdict(Enum):
+    VALID = 0
+    INVALID = 1
+
+    def __str__(self):
+        return self.name
+
+
+class CheckerTestVerdict(Enum):
+    OK = 0
+    WRONG_ANSWER = 1
+    CRASHED = 2
+    PRESENTATION_ERROR = 3
+
+    def __str__(self):
+        return self.name

{polygon_api-1.1.0a2 → polygon_api-1.1.0a3}/polygon_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polygon_api
-Version: 1.1.0a2
+Version: 1.1.0a3
 Summary: Python wrapper for Polygon API (polygon.codeforces.com)
 Home-page: https://github.com/citxx/polygon-py
 Author: Artem Tabolin

{polygon_api-1.1.0a2 → polygon_api-1.1.0a3}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="polygon_api",
-    version="1.1.0a2",
+    version="1.1.0a3",
     author="Artem Tabolin",
     author_email="artemtab@gmail.com",
     description="Python wrapper for Polygon API (polygon.codeforces.com)",

polygon_api-1.1.0a2/polygon_api/__init__.py

@@ -1,16 +0,0 @@
-from .api import (
-    Polygon,
-    Problem,
-    ProblemInfo,
-    Statement,
-    ResourceAdvancedProperties,
-    PolygonRequestFailedException,
-    PointsPolicy,
-    FeedbackPolicy,
-    FileType,
-    SolutionTag,
-    Stage,
-    Asset,
-)
-
-__version__ = "1.1.0a2"