xcpcio 0.58.2__tar.gz

xcpcio-0.58.2/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: xcpcio
+Version: 0.58.2
+Summary: xcpcio python lib
+Author-email: Dup4 <hi@dup4.com>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/xcpcio/xcpcio
+Project-URL: documentation, https://github.com/xcpcio/xcpcio
+Project-URL: repository, https://github.com/xcpcio/xcpcio
+Keywords: xcpcio
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.11.7
+
+# xcpcio-python

xcpcio-0.58.2/README.md

@@ -0,0 +1 @@
+# xcpcio-python

xcpcio-0.58.2/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "xcpcio"
+version = "0.58.2"
+description = "xcpcio python lib"
+readme = "README.md"
+authors = [ { name = "Dup4", email = "hi@dup4.com" } ]
+license = "MIT"
+keywords = [ "xcpcio" ]
+classifiers = [
+  "Topic :: Software Development :: Build Tools",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+requires-python = ">=3.11"
+dependencies = [ "pydantic>=2.11.7", ]
+
+[project.urls]
+homepage = "https://github.com/xcpcio/xcpcio"
+documentation = "https://github.com/xcpcio/xcpcio"
+repository = "https://github.com/xcpcio/xcpcio"
+
+[tool.ruff]
+line-length = 120
+
+[dependency-groups]
+dev = [ "pytest>=8.4.2", "ruff>=0.4.0", ]

xcpcio-0.58.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xcpcio-0.58.2/tests/test_contest.py

@@ -0,0 +1,229 @@
+
+
+from xcpcio import constants
+from xcpcio.types import Color, Contest, ContestOptions, Image
+
+
+class TestContest:
+    """Test cases for Contest Pydantic model"""
+
+    def test_contest_creation_defaults(self):
+        """Test Contest creation with default values"""
+        contest = Contest()
+        
+        assert contest.contest_name == ""
+        assert contest.start_time == 0
+        assert contest.end_time == 0
+        assert contest.frozen_time == 60 * 60  # 1 hour
+        assert contest.unfrozen_time == 0x3F3F3F3F3F3F3F3F
+        assert contest.penalty == 20 * 60  # 20 minutes
+        assert contest.problem_quantity == 0
+        assert contest.problem_id == []
+        assert contest.organization == "School"
+        assert contest.medal is None
+        assert contest.balloon_color is None
+        assert contest.logo is None
+        assert contest.banner is None
+        assert contest.banner_mode is None
+        assert contest.badge is None
+        assert contest.group is None
+        assert contest.tag is None
+        assert contest.board_link is None
+        assert contest.version is None
+        
+        # Check default values
+        assert contest.status_time_display == constants.FULL_STATUS_TIME_DISPLAY
+        assert isinstance(contest.options, ContestOptions)
+
+    def test_contest_creation_with_values(self):
+        """Test Contest creation with provided values"""
+        contest_options = ContestOptions(
+            calculation_of_penalty=constants.CALCULATION_OF_PENALTY_IN_SECONDS,
+            has_reaction_videos=True
+        )
+        
+        contest = Contest(
+            contest_name="ICPC World Finals 2024",
+            start_time=1234567890,
+            end_time=1234567890 + 5 * 60 * 60,  # 5 hours later
+            frozen_time=60 * 60,  # 1 hour before end
+            penalty=20 * 60,  # 20 minutes
+            problem_quantity=12,
+            problem_id=["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"],
+            organization="ICPC",
+            medal="icpc",  # Use Literal value
+            options=contest_options
+        )
+        
+        assert contest.contest_name == "ICPC World Finals 2024"
+        assert contest.start_time == 1234567890
+        assert contest.end_time == 1234567890 + 5 * 60 * 60
+        assert contest.problem_quantity == 12
+        assert len(contest.problem_id) == 12
+        assert contest.problem_id[0] == "A"
+        assert contest.problem_id[-1] == "L"
+        assert contest.organization == "ICPC"
+        assert contest.medal == "icpc"
+        assert contest.options == contest_options
+
+    def test_contest_serialization(self):
+        """Test Contest serialization and deserialization"""
+        contest = Contest(
+            contest_name="Test Contest",
+            start_time=1000000000,
+            end_time=1000000000 + 60 * 60 * 5,
+            problem_quantity=5,
+            problem_id=["A", "B", "C", "D", "E"],
+            organization="Test Org"
+        )
+        
+        # Test model_dump
+        contest_dict = contest.model_dump()
+        assert contest_dict["contest_name"] == "Test Contest"
+        assert contest_dict["start_time"] == 1000000000
+        assert contest_dict["problem_quantity"] == 5
+        assert contest_dict["organization"] == "Test Org"
+        
+        # Test JSON round-trip
+        contest_json = contest.model_dump_json()
+        reconstructed_contest = Contest.model_validate_json(contest_json)
+        assert reconstructed_contest == contest
+
+    def test_contest_with_colors_and_images(self):
+        """Test Contest with balloon colors, logo, and banner"""
+        colors = [
+            Color(color="#fff", background_color="rgba(255, 0, 0, 0.7)"),
+            Color(color="#000", background_color="rgba(0, 255, 0, 0.7)")
+        ]
+        logo = Image(url="https://example.com/logo.png", type="png")
+        banner = Image(url="https://example.com/banner.jpg", type="jpg")
+        
+        contest = Contest(
+            contest_name="Contest with Media",
+            problem_quantity=2,
+            balloon_color=colors,
+            logo=logo,
+            banner=banner,
+            banner_mode="ALL"  # Use correct Literal value
+        )
+        
+        assert len(contest.balloon_color) == 2
+        assert contest.balloon_color[0].color == "#fff"
+        assert contest.balloon_color[1].background_color == "rgba(0, 255, 0, 0.7)"
+        assert contest.logo.url == "https://example.com/logo.png"
+        assert contest.banner.url == "https://example.com/banner.jpg"
+        assert contest.banner_mode == "ALL"
+
+    def test_append_balloon_color(self):
+        """Test append_balloon_color method"""
+        contest = Contest()
+        
+        # Initially no colors
+        assert contest.balloon_color is None
+        
+        # Add first color
+        red_color = Color(color="#fff", background_color="red")
+        contest.append_balloon_color(red_color)
+        
+        assert contest.balloon_color is not None
+        assert len(contest.balloon_color) == 1
+        assert contest.balloon_color[0] == red_color
+        
+        # Add second color
+        blue_color = Color(color="#fff", background_color="blue")
+        contest.append_balloon_color(blue_color)
+        
+        assert len(contest.balloon_color) == 2
+        assert contest.balloon_color[1] == blue_color
+
+    def test_fill_problem_id(self):
+        """Test fill_problem_id method"""
+        contest = Contest(problem_quantity=5)
+        
+        # Initially empty
+        assert contest.problem_id == []
+        
+        # Fill with A-E
+        contest.fill_problem_id()
+        
+        assert len(contest.problem_id) == 5
+        assert contest.problem_id == ["A", "B", "C", "D", "E"]
+        
+        # Test with larger quantity
+        contest.problem_quantity = 10
+        contest.fill_problem_id()
+        
+        assert len(contest.problem_id) == 10
+        assert contest.problem_id == ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
+
+    def test_fill_balloon_color(self):
+        """Test fill_balloon_color method"""
+        contest = Contest(problem_quantity=3)
+        
+        # Initially no colors
+        assert contest.balloon_color is None
+        
+        # Fill with default colors
+        contest.fill_balloon_color()
+        
+        assert contest.balloon_color is not None
+        assert len(contest.balloon_color) == 3
+        assert all(isinstance(color, Color) for color in contest.balloon_color)
+        
+        # Check first few default colors
+        assert contest.balloon_color[0].background_color == "rgba(189, 14, 14, 0.7)"
+        assert contest.balloon_color[0].color == "#fff"
+        assert contest.balloon_color[1].background_color == "rgba(149, 31, 217, 0.7)"
+        assert contest.balloon_color[1].color == "#fff"
+
+    def test_contest_round_trip_serialization(self):
+        """Test complete round-trip serialization with complex data"""
+        # Create a contest with all features
+        contest = Contest(
+            contest_name="Complex Contest",
+            start_time=1234567890,
+            end_time=1234567890 + 5 * 60 * 60,
+            problem_quantity=3,
+            organization="Complex Org",
+            medal="ccpc"  # Use preset instead of dict
+        )
+        
+        # Add problem IDs and colors
+        contest.fill_problem_id()
+        contest.fill_balloon_color()
+        
+        # Add logo
+        contest.logo = Image(url="https://example.com/logo.png")
+        
+        # Test serialization
+        contest_json = contest.model_dump_json()
+        reconstructed_contest = Contest.model_validate_json(contest_json)
+        
+        # Verify all data is preserved
+        assert reconstructed_contest.contest_name == contest.contest_name
+        assert reconstructed_contest.start_time == contest.start_time
+        assert reconstructed_contest.end_time == contest.end_time
+        assert reconstructed_contest.problem_id == contest.problem_id
+        assert reconstructed_contest.medal == contest.medal
+        assert len(reconstructed_contest.balloon_color) == len(contest.balloon_color)
+        assert reconstructed_contest.logo.url == contest.logo.url
+
+    def test_custom_group_and_status_display(self):
+        """Test contest with custom group and status display"""
+        custom_group = {"team_a": "Team A", "team_b": "Team B"}
+        custom_status = {"show_penalty": True, "show_time": False}
+        
+        contest = Contest(
+            group=custom_group,
+            status_time_display=custom_status
+        )
+        
+        # Custom values should override defaults
+        assert contest.group == custom_group
+        assert contest.status_time_display == custom_status
+        
+        # Test serialization preserves custom values
+        contest_json = contest.model_dump_json()
+        reconstructed = Contest.model_validate_json(contest_json)
+        assert reconstructed.group == custom_group
+        assert reconstructed.status_time_display == custom_status

xcpcio-0.58.2/tests/test_submission.py

@@ -0,0 +1,227 @@
+import json
+
+import pytest
+
+from xcpcio import constants
+from xcpcio.types import Reaction, Submission, Submissions
+
+
+class TestSubmission:
+    """Test cases for Submission Pydantic model"""
+
+    def test_submission_creation_defaults(self):
+        """Test Submission creation with default values"""
+        submission = Submission()
+        assert submission.id == ""
+        assert submission.team_id == ""
+        assert submission.problem_id == 0
+        assert submission.timestamp == 0
+        assert submission.status == constants.SUBMISSION_STATUS_UNKNOWN
+        assert submission.time is None
+        assert submission.language is None
+        assert submission.is_ignore is None
+        assert submission.reaction is None
+
+    def test_submission_creation_with_values(self):
+        """Test Submission creation with provided values"""
+        reaction = Reaction(url="https://reaction.com/video.mp4")
+        submission = Submission(
+            id="sub_001",
+            status=constants.SUBMISSION_STATUS_ACCEPTED,
+            team_id="team001",
+            problem_id=1,
+            timestamp=1234567890,
+            time=120,
+            language="Python",
+            is_ignore=False,
+            reaction=reaction,
+        )
+
+        assert submission.id == "sub_001"
+        assert submission.status == constants.SUBMISSION_STATUS_ACCEPTED
+        assert submission.team_id == "team001"
+        assert submission.problem_id == 1
+        assert submission.timestamp == 1234567890
+        assert submission.time == 120
+        assert submission.language == "Python"
+        assert not submission.is_ignore
+        assert submission.reaction == reaction
+        assert submission.reaction.url == "https://reaction.com/video.mp4"
+
+    def test_submission_serialization(self):
+        """Test Submission serialization and deserialization"""
+        submission = Submission(
+            id="sub_002",
+            status=constants.SUBMISSION_STATUS_WRONG_ANSWER,
+            team_id="team002",
+            problem_id=3,
+            timestamp=1234567891,
+            time=300,
+            language="C++",
+        )
+
+        # Test model_dump
+        submission_dict = submission.model_dump()
+        assert submission_dict["id"] == "sub_002"
+        assert submission_dict["status"] == constants.SUBMISSION_STATUS_WRONG_ANSWER
+        assert submission_dict["team_id"] == "team002"
+        assert submission_dict["problem_id"] == 3
+        assert submission_dict["timestamp"] == 1234567891
+        assert submission_dict["time"] == 300
+        assert submission_dict["language"] == "C++"
+        assert submission_dict["is_ignore"] is None
+        assert submission_dict["reaction"] is None
+
+        # Test JSON round-trip
+        submission_json = submission.model_dump_json()
+        reconstructed_submission = Submission.model_validate_json(submission_json)
+        assert reconstructed_submission == submission
+
+    def test_submission_with_reaction_serialization(self):
+        """Test Submission with Reaction serialization"""
+        reaction = Reaction(url="https://example.com/reaction.mp4")
+        submission = Submission(
+            id="sub_003",
+            status=constants.SUBMISSION_STATUS_ACCEPTED,
+            team_id="team003",
+            problem_id=2,
+            timestamp=1234567892,
+            reaction=reaction,
+        )
+
+        # Test model_dump
+        submission_dict = submission.model_dump()
+        assert submission_dict["reaction"]["url"] == "https://example.com/reaction.mp4"
+
+        # Test JSON round-trip
+        submission_json = submission.model_dump_json()
+        reconstructed_submission = Submission.model_validate_json(submission_json)
+        assert reconstructed_submission == submission
+        assert reconstructed_submission.reaction.url == "https://example.com/reaction.mp4"
+
+
+class TestSubmissions:
+    """Test cases for Submissions RootModel"""
+
+    @pytest.fixture
+    def sample_submissions(self) -> Submissions:
+        """Create sample submissions for testing"""
+        return Submissions(
+            [
+                Submission(
+                    id="sub_001",
+                    status=constants.SUBMISSION_STATUS_ACCEPTED,
+                    team_id="team001",
+                    problem_id=1,
+                    timestamp=1234567890,
+                    time=120,
+                    language="Python",
+                ),
+                Submission(
+                    id="sub_002",
+                    status=constants.SUBMISSION_STATUS_WRONG_ANSWER,
+                    team_id="team002",
+                    problem_id=2,
+                    timestamp=1234567891,
+                    time=300,
+                    language="C++",
+                    reaction=Reaction(url="https://reaction.com/video.mp4"),
+                ),
+                Submission(
+                    id="sub_003",
+                    status=constants.SUBMISSION_STATUS_TIME_LIMIT_EXCEEDED,
+                    team_id="team003",
+                    problem_id=1,
+                    timestamp=1234567892,
+                    time=600,
+                    language="Java",
+                ),
+            ]
+        )
+
+    def test_submissions_basic_operations(self, sample_submissions: Submissions):
+        """Test basic Submissions operations"""
+        assert len(sample_submissions.root) == 3
+
+        # Test iteration
+        statuses = [sub.status for sub in sample_submissions.root]
+        assert constants.SUBMISSION_STATUS_ACCEPTED in statuses
+        assert constants.SUBMISSION_STATUS_WRONG_ANSWER in statuses
+        assert constants.SUBMISSION_STATUS_TIME_LIMIT_EXCEEDED in statuses
+
+    def test_submissions_serialization(self, sample_submissions: Submissions):
+        """Test Submissions serialization and deserialization"""
+        # Test JSON serialization
+        submissions_json = sample_submissions.model_dump_json()
+        assert isinstance(submissions_json, str)
+
+        # Verify it's a valid JSON array
+        parsed = json.loads(submissions_json)
+        assert isinstance(parsed, list)
+        assert len(parsed) == 3
+
+        # Check first submission data
+        assert parsed[0]["status"] == constants.SUBMISSION_STATUS_ACCEPTED
+        assert parsed[0]["team_id"] == "team001"
+        assert parsed[0]["problem_id"] == 1
+
+        # Test JSON deserialization
+        reconstructed_submissions = Submissions.model_validate_json(submissions_json)
+        assert len(reconstructed_submissions.root) == 3
+
+        # Verify the data is correct
+        assert reconstructed_submissions.root[0].status == constants.SUBMISSION_STATUS_ACCEPTED
+        assert reconstructed_submissions.root[1].status == constants.SUBMISSION_STATUS_WRONG_ANSWER
+        assert reconstructed_submissions.root[2].status == constants.SUBMISSION_STATUS_TIME_LIMIT_EXCEEDED
+
+        # Check reaction is preserved
+        assert reconstructed_submissions.root[1].reaction.url == "https://reaction.com/video.mp4"
+
+    def test_submissions_round_trip(self, sample_submissions: Submissions):
+        """Test complete round-trip serialization"""
+        # Dict round-trip
+        submissions_dict = sample_submissions.model_dump()
+        reconstructed_from_dict = Submissions.model_validate(submissions_dict)
+        assert len(reconstructed_from_dict.root) == len(sample_submissions.root)
+
+        # JSON round-trip
+        submissions_json = sample_submissions.model_dump_json()
+        reconstructed_from_json = Submissions.model_validate_json(submissions_json)
+        assert len(reconstructed_from_json.root) == len(sample_submissions.root)
+
+    def test_empty_submissions(self):
+        """Test operations with empty Submissions"""
+        empty_submissions = Submissions([])
+
+        assert len(empty_submissions.root) == 0
+
+        # Test serialization
+        submissions_json = empty_submissions.model_dump_json()
+        assert submissions_json == "[]"
+
+        # Test deserialization
+        reconstructed = Submissions.model_validate_json("[]")
+        assert len(reconstructed.root) == 0
+
+    def test_submissions_with_minimal_data(self):
+        """Test Submissions with minimal submission data"""
+        minimal_submissions = Submissions(
+            [
+                Submission(
+                    id="sub_min",
+                    status=constants.SUBMISSION_STATUS_ACCEPTED,
+                    team_id="team001",
+                    problem_id=1,
+                    timestamp=123,
+                ),
+                Submission(),  # All defaults
+            ]
+        )
+
+        # Test serialization
+        submissions_json = minimal_submissions.model_dump_json()
+        reconstructed = Submissions.model_validate_json(submissions_json)
+
+        assert len(reconstructed.root) == 2
+        assert reconstructed.root[0].status == constants.SUBMISSION_STATUS_ACCEPTED
+        assert reconstructed.root[1].status == constants.SUBMISSION_STATUS_UNKNOWN  # Default value

xcpcio-0.58.2/tests/test_team.py

@@ -0,0 +1,238 @@
+import json
+
+import pytest
+
+from xcpcio.types import Team, Teams
+
+
+class TestTeam:
+    """Test cases for the Team dataclass"""
+
+    def test_team_creation(self):
+        """Test basic team creation with default values"""
+        team = Team()
+        assert team.id == ""
+        assert team.name == ""
+        assert team.organization == ""
+        assert team.members is None
+        assert team.coach is None
+        assert team.location is None
+        assert team.group == []
+        assert team.extra == {}
+
+    def test_team_creation_with_values(self):
+        """Test team creation with provided values"""
+        team = Team(
+            id="team001",
+            name="Test Team",
+            organization="Test University",
+            members=["Alice", "Bob", "Charlie"],
+            coach="Dr. Smith",
+            location="Building A",
+        )
+
+        assert team.id == "team001"
+        assert team.name == "Test Team"
+        assert team.organization == "Test University"
+        assert team.members == ["Alice", "Bob", "Charlie"]
+        assert team.coach == "Dr. Smith"
+        assert team.location == "Building A"
+
+    def test_group_management(self):
+        """Test add_group and remove_group methods"""
+        team = Team(id="test", name="Test Team", organization="Test Org")
+
+        # Test adding groups
+        team.add_group("undergraduate")
+        assert "undergraduate" in team.group
+
+        team.add_group("local")
+        assert "local" in team.group
+        assert len(team.group) == 2
+
+        # Test that duplicate groups are not added
+        team.add_group("undergraduate")
+        assert len(team.group) == 2
+
+        # Test removing groups
+        team.remove_group("local")
+        assert "local" not in team.group
+        assert len(team.group) == 1
+
+        # Test removing non-existent group (should not raise error)
+        team.remove_group("nonexistent")
+        assert len(team.group) == 1
+
+
+class TestTeamSerialization:
+    """Test cases for Team serialization and deserialization"""
+
+    @pytest.fixture
+    def sample_team(self) -> Team:
+        """Create a sample team for testing"""
+        return Team(
+            id="team001",
+            name="Alpha Team",
+            organization="University A",
+            members=["Alice", "Bob", "Charlie"],
+            coach="Dr. Smith",
+            location="Building A",
+            group=["undergraduate", "local"],
+            extra={"room": "101", "contact": "alice@test.edu"},
+        )
+
+    def test_model_dump(self, sample_team: Team):
+        """Test Team model_dump method"""
+        team_dict = sample_team.model_dump()
+
+        assert isinstance(team_dict, dict)
+        assert team_dict["id"] == "team001"
+        assert team_dict["name"] == "Alpha Team"
+        assert team_dict["organization"] == "University A"
+        assert team_dict["members"] == ["Alice", "Bob", "Charlie"]
+        assert team_dict["coach"] == "Dr. Smith"
+        assert team_dict["location"] == "Building A"
+        assert team_dict["group"] == ["undergraduate", "local"]
+        assert team_dict["extra"] == {"room": "101", "contact": "alice@test.edu"}
+
+    def test_model_validate(self, sample_team: Team):
+        """Test Team model_validate method"""
+        team_dict = sample_team.model_dump()
+        reconstructed_team = Team.model_validate(team_dict)
+
+        assert reconstructed_team == sample_team
+
+    def test_model_dump_json(self, sample_team: Team):
+        """Test Team model_dump_json method"""
+        team_json = sample_team.model_dump_json()
+
+        assert isinstance(team_json, str)
+        # Verify it's valid JSON
+        parsed = json.loads(team_json)
+        assert parsed["id"] == "team001"
+        assert parsed["name"] == "Alpha Team"
+
+    def test_model_validate_json(self, sample_team: Team):
+        """Test Team model_validate_json method"""
+        team_json = sample_team.model_dump_json()
+        reconstructed_team = Team.model_validate_json(team_json)
+
+        assert reconstructed_team == sample_team
+
+    def test_round_trip_dict(self, sample_team: Team):
+        """Test complete round-trip through dict serialization"""
+        team_dict = sample_team.model_dump()
+        reconstructed_team = Team.model_validate(team_dict)
+
+        assert reconstructed_team == sample_team
+
+    def test_round_trip_json(self, sample_team: Team):
+        """Test complete round-trip through JSON serialization"""
+        team_json = sample_team.model_dump_json()
+        reconstructed_team = Team.model_validate_json(team_json)
+
+        assert reconstructed_team == sample_team
+
+    def test_minimal_team_serialization(self):
+        """Test serialization of team with default/minimal values"""
+        minimal_team = Team()
+
+        # Test dict round-trip
+        team_dict = minimal_team.model_dump()
+        reconstructed_from_dict = Team.model_validate(team_dict)
+        assert reconstructed_from_dict == minimal_team
+
+        # Test JSON round-trip
+        team_json = minimal_team.model_dump_json()
+        reconstructed_from_json = Team.model_validate_json(team_json)
+        assert reconstructed_from_json == minimal_team
+
+
+class TestTeamList:
+    """Test cases for Teams (RootModel) serialization and deserialization"""
+
+    @pytest.fixture
+    def sample_teams(self) -> Teams:
+        """Create a Teams instance for testing"""
+        return Teams(
+            [
+                Team(
+                    id="team001",
+                    name="Alpha Team",
+                    organization="University A",
+                    members=["Alice", "Bob"],
+                    coach="Coach A",
+                ),
+                Team(
+                    id="team002",
+                    name="Beta Team",
+                    organization="University B",
+                    members=["Charlie", "David", "Eve"],
+                    location="Remote",
+                ),
+                Team(
+                    id="team003",
+                    name="Gamma Team",
+                    organization="University C",
+                    group=["graduate", "international"],
+                    extra={"sponsor": "Tech Corp"},
+                ),
+            ]
+        )
+
+    def test_teams_basic_operations(self, sample_teams: Teams):
+        """Test basic Teams operations"""
+        assert len(sample_teams.root) == 3
+
+        # Test iteration
+        team_ids = [team.id for team in sample_teams.root]
+        assert "team001" in team_ids
+        assert "team002" in team_ids
+        assert "team003" in team_ids
+
+    def test_teams_serialization(self, sample_teams: Teams):
+        """Test Teams serialization and deserialization"""
+        # Test JSON serialization
+        teams_json = sample_teams.model_dump_json()
+        assert isinstance(teams_json, str)
+
+        # Verify it's a valid JSON array
+        parsed = json.loads(teams_json)
+        assert isinstance(parsed, list)
+        assert len(parsed) == 3
+
+        # Test JSON deserialization
+        reconstructed_teams = Teams.model_validate_json(teams_json)
+        assert len(reconstructed_teams.root) == 3
+
+        # Verify the data is correct
+        reconstructed_teams.root.sort(key=lambda x: x.id)
+        assert reconstructed_teams.root[0].id == "team001"
+        assert reconstructed_teams.root[1].id == "team002"
+        assert reconstructed_teams.root[2].id == "team003"
+
+    def test_teams_round_trip(self, sample_teams: Teams):
+        """Test complete round-trip serialization"""
+        # Dict round-trip
+        teams_dict = sample_teams.model_dump()
+        reconstructed_from_dict = Teams.model_validate(teams_dict)
+        assert len(reconstructed_from_dict.root) == len(sample_teams.root)
+
+        # JSON round-trip
+        teams_json = sample_teams.model_dump_json()
+        reconstructed_from_json = Teams.model_validate_json(teams_json)
+        assert len(reconstructed_from_json.root) == len(sample_teams.root)
+
+    def test_empty_teams(self):
+        """Test operations with empty Teams"""
+        empty_teams = Teams([])
+
+        assert len(empty_teams.root) == 0
+
+        # Test serialization
+        teams_json = empty_teams.model_dump_json()
+        assert teams_json == "[]"
+
+        # Test deserialization
+        reconstructed = Teams.model_validate_json("[]")
+        assert len(reconstructed.root) == 0

xcpcio-0.58.2/tests/test_types.py

@@ -0,0 +1,135 @@
+from xcpcio import constants
+from xcpcio.types import Color, ContestOptions, Image, Reaction
+
+
+class TestImage:
+    """Test cases for Image Pydantic model"""
+
+    def test_image_creation_empty(self):
+        """Test Image creation with default values"""
+        image = Image()
+        assert image.url is None
+        assert image.base64 is None
+        assert image.preset is None
+
+    def test_image_creation_with_values(self):
+        """Test Image creation with provided values"""
+        image = Image(url="https://example.com/image.png", base64="base64data", preset="ICPC")
+        assert image.url == "https://example.com/image.png"
+        assert image.base64 == "base64data"
+        assert image.preset == "ICPC"
+
+    def test_image_serialization(self):
+        """Test Image serialization and deserialization"""
+        image = Image(url="https://test.com/img.jpg", preset="CCPC")
+
+        # Test model_dump
+        image_dict = image.model_dump()
+        assert image_dict["url"] == "https://test.com/img.jpg"
+        assert image_dict["preset"] == "CCPC"
+        assert image_dict["base64"] is None
+
+        # Test JSON serialization
+        image_json = image.model_dump_json()
+        reconstructed_image = Image.model_validate_json(image_json)
+        assert reconstructed_image == image
+
+
+class TestColor:
+    """Test cases for Color Pydantic model"""
+
+    def test_color_creation(self):
+        """Test Color creation"""
+        color = Color(color="#ffffff", background_color="#000000")
+        assert color.color == "#ffffff"
+        assert color.background_color == "#000000"
+
+    def test_color_serialization(self):
+        """Test Color serialization and deserialization"""
+        color = Color(color="red", background_color="blue")
+
+        # Test model_dump
+        color_dict = color.model_dump()
+        assert color_dict["color"] == "red"
+        assert color_dict["background_color"] == "blue"
+
+        # Test JSON round-trip
+        color_json = color.model_dump_json()
+        reconstructed_color = Color.model_validate_json(color_json)
+        assert reconstructed_color == color
+
+
+class TestContestOptions:
+    """Test cases for ContestOptions Pydantic model"""
+
+    def test_contest_options_empty(self):
+        """Test ContestOptions with default values"""
+        options = ContestOptions()
+        assert options.calculation_of_penalty is None
+        assert options.submission_timestamp_unit is None
+        assert options.has_reaction_videos is None
+        assert options.reaction_video_url_template is None
+
+    def test_contest_options_with_values(self):
+        """Test ContestOptions with provided values"""
+        options = ContestOptions(
+            calculation_of_penalty=constants.CALCULATION_OF_PENALTY_IN_SECONDS,
+            submission_timestamp_unit=constants.TIME_UNIT_MILLISECOND,
+            has_reaction_videos=True,
+            reaction_video_url_template="https://videos.com/{team_id}/{problem_id}",
+        )
+
+        assert options.calculation_of_penalty == constants.CALCULATION_OF_PENALTY_IN_SECONDS
+        assert options.submission_timestamp_unit == constants.TIME_UNIT_MILLISECOND
+        assert options.has_reaction_videos is True
+        assert options.reaction_video_url_template == "https://videos.com/{team_id}/{problem_id}"
+
+    def test_contest_options_serialization(self):
+        """Test ContestOptions serialization"""
+        options = ContestOptions(
+            calculation_of_penalty=constants.CALCULATION_OF_PENALTY_IN_MINUTES, has_reaction_videos=False
+        )
+
+        # Test JSON round-trip
+        options_json = options.model_dump_json()
+        reconstructed_options = ContestOptions.model_validate_json(options_json)
+        assert reconstructed_options == options
+
+
+class TestReaction:
+    """Test cases for Reaction Pydantic model"""
+
+    def test_reaction_empty(self):
+        """Test Reaction with default values"""
+        reaction = Reaction()
+        assert reaction.url is None
+
+    def test_reaction_with_url(self):
+        """Test Reaction with URL"""
+        reaction = Reaction(url="https://reaction.com/video.mp4")
+        assert reaction.url == "https://reaction.com/video.mp4"
+
+    def test_reaction_serialization(self):
+        """Test Reaction serialization"""
+        reaction = Reaction(url="https://test.com/reaction.mp4")
+
+        # Test model_dump
+        reaction_dict = reaction.model_dump()
+        assert reaction_dict["url"] == "https://test.com/reaction.mp4"
+
+        # Test JSON round-trip
+        reaction_json = reaction.model_dump_json()
+        reconstructed_reaction = Reaction.model_validate_json(reaction_json)
+        assert reconstructed_reaction == reaction
+
+    def test_reaction_no_url_serialization(self):
+        """Test Reaction serialization with no URL"""
+        reaction = Reaction()
+
+        reaction_dict = reaction.model_dump()
+        assert reaction_dict["url"] is None
+
+        # Test JSON round-trip
+        reaction_json = reaction.model_dump_json()
+        reconstructed_reaction = Reaction.model_validate_json(reaction_json)
+        assert reconstructed_reaction == reaction

xcpcio-0.58.2/xcpcio/__init__.py

@@ -0,0 +1,5 @@
+from . import constants, types
+
+__version__ = "0.58.2"
+
+__all__ = [constants, types]

xcpcio-0.58.2/xcpcio/constants.py

@@ -0,0 +1,66 @@
+SUBMISSION_STATUS_PENDING = "PENDING"
+SUBMISSION_STATUS_WAITING = "WAITING"
+SUBMISSION_STATUS_PREPARING = "PREPARING"
+SUBMISSION_STATUS_COMPILING = "COMPILING"
+SUBMISSION_STATUS_RUNNING = "RUNNING"
+SUBMISSION_STATUS_JUDGING = "JUDGING"
+SUBMISSION_STATUS_FROZEN = "FROZEN"
+
+SUBMISSION_STATUS_ACCEPTED = "ACCEPTED"
+SUBMISSION_STATUS_CORRECT = "CORRECT"
+SUBMISSION_STATUS_PARTIALLY_CORRECT = "PARTIALLY_CORRECT"
+
+SUBMISSION_STATUS_REJECTED = "REJECTED"
+SUBMISSION_STATUS_WRONG_ANSWER = "WRONG_ANSWER"
+SUBMISSION_STATUS_INCORRECT = "INCORRECT"
+
+SUBMISSION_STATUS_NO_OUTPUT = "NO_OUTPUT"
+
+SUBMISSION_STATUS_COMPILATION_ERROR = "COMPILATION_ERROR"
+SUBMISSION_STATUS_PRESENTATION_ERROR = "PRESENTATION_ERROR"
+
+SUBMISSION_STATUS_RUNTIME_ERROR = "RUNTIME_ERROR"
+SUBMISSION_STATUS_TIME_LIMIT_EXCEEDED = "TIME_LIMIT_EXCEEDED"
+SUBMISSION_STATUS_MEMORY_LIMIT_EXCEEDED = "MEMORY_LIMIT_EXCEEDED"
+SUBMISSION_STATUS_OUTPUT_LIMIT_EXCEEDED = "OUTPUT_LIMIT_EXCEEDED"
+SUBMISSION_STATUS_IDLENESS_LIMIT_EXCEEDED = "IDLENESS_LIMIT_EXCEEDED"
+
+SUBMISSION_STATUS_HACKED = "HACKED"
+
+SUBMISSION_STATUS_JUDGEMENT_FAILED = "JUDGEMENT_FAILED"
+SUBMISSION_STATUS_CONFIGURATION_ERROR = "CONFIGURATION_ERROR"
+SUBMISSION_STATUS_FILE_ERROR = "FILE_ERROR"
+SUBMISSION_STATUS_SYSTEM_ERROR = "SYSTEM_ERROR"
+SUBMISSION_STATUS_CANCELED = "CANCELED"
+SUBMISSION_STATUS_SKIPPED = "SKIPPED"
+
+SUBMISSION_STATUS_SECURITY_VIOLATED = "SECURITY_VIOLATED"
+SUBMISSION_STATUS_DENIAL_OF_JUDGEMENT = "DENIAL_OF_JUDGEMENT"
+
+SUBMISSION_STATUS_UNKNOWN = "UNKNOWN"
+SUBMISSION_STATUS_UNDEFINED = "UNDEFINED"
+
+CALCULATION_OF_PENALTY_IN_MINUTES = "in_minutes"
+CALCULATION_OF_PENALTY_IN_SECONDS = "in_seconds"
+CALCULATION_OF_PENALTY_ACCUMULATE_IN_SECONDS_AND_FINALLY_TO_THE_MINUTE = (
+    "accumulate_in_seconds_and_finally_to_the_minute"
+)
+
+TIME_UNIT_SECOND = "second"
+TIME_UNIT_MILLISECOND = "millisecond"
+TIME_UNIT_MICROSECOND = "microsecond"
+TIME_UNIT_NANOSECOND = "nanosecond"
+
+FULL_STATUS_TIME_DISPLAY = {
+    SUBMISSION_STATUS_CORRECT.lower(): True,
+    SUBMISSION_STATUS_INCORRECT.lower(): True,
+    SUBMISSION_STATUS_PENDING.lower(): True,
+}
+
+TEAM_TYPE_OFFICIAL = "official"
+TEAM_TYPE_UNOFFICIAL = "unofficial"
+TEAM_TYPE_GIRL = "girl"
+
+TEAM_TYPE_ZH_CN_OFFICIAL = "正式队伍"
+TEAM_TYPE_ZH_CN_UNOFFICIAL = "打星队伍"
+TEAM_TYPE_ZH_CN_GIRL = "女队"

xcpcio-0.58.2/xcpcio/types.py

@@ -0,0 +1,204 @@
+from typing import Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, Field, RootModel
+
+from . import constants
+
+CalculationOfPenalty = Literal[
+    constants.CALCULATION_OF_PENALTY_IN_SECONDS,
+    constants.CALCULATION_OF_PENALTY_IN_MINUTES,
+    constants.CALCULATION_OF_PENALTY_ACCUMULATE_IN_SECONDS_AND_FINALLY_TO_THE_MINUTE,
+]
+TimeUnit = Literal[
+    constants.TIME_UNIT_SECOND,
+    constants.TIME_UNIT_MILLISECOND,
+    constants.TIME_UNIT_MICROSECOND,
+    constants.TIME_UNIT_NANOSECOND,
+]
+SubmissionStatus = Literal[
+    constants.SUBMISSION_STATUS_PENDING,
+    constants.SUBMISSION_STATUS_WAITING,
+    constants.SUBMISSION_STATUS_PREPARING,
+    constants.SUBMISSION_STATUS_COMPILING,
+    constants.SUBMISSION_STATUS_RUNNING,
+    constants.SUBMISSION_STATUS_JUDGING,
+    constants.SUBMISSION_STATUS_FROZEN,
+    #
+    constants.SUBMISSION_STATUS_ACCEPTED,
+    constants.SUBMISSION_STATUS_CORRECT,
+    constants.SUBMISSION_STATUS_PARTIALLY_CORRECT,
+    #
+    constants.SUBMISSION_STATUS_REJECTED,
+    constants.SUBMISSION_STATUS_WRONG_ANSWER,
+    constants.SUBMISSION_STATUS_INCORRECT,
+    #
+    constants.SUBMISSION_STATUS_NO_OUTPUT,
+    #
+    constants.SUBMISSION_STATUS_COMPILATION_ERROR,
+    constants.SUBMISSION_STATUS_PRESENTATION_ERROR,
+    #
+    constants.SUBMISSION_STATUS_RUNTIME_ERROR,
+    constants.SUBMISSION_STATUS_TIME_LIMIT_EXCEEDED,
+    constants.SUBMISSION_STATUS_MEMORY_LIMIT_EXCEEDED,
+    constants.SUBMISSION_STATUS_OUTPUT_LIMIT_EXCEEDED,
+    constants.SUBMISSION_STATUS_IDLENESS_LIMIT_EXCEEDED,
+    #
+    constants.SUBMISSION_STATUS_HACKED,
+    #
+    constants.SUBMISSION_STATUS_JUDGEMENT_FAILED,
+    constants.SUBMISSION_STATUS_CONFIGURATION_ERROR,
+    constants.SUBMISSION_STATUS_FILE_ERROR,
+    constants.SUBMISSION_STATUS_SYSTEM_ERROR,
+    constants.SUBMISSION_STATUS_CANCELED,
+    constants.SUBMISSION_STATUS_SKIPPED,
+    #
+    constants.SUBMISSION_STATUS_SECURITY_VIOLATED,
+    constants.SUBMISSION_STATUS_DENIAL_OF_JUDGEMENT,
+    #
+    constants.SUBMISSION_STATUS_UNKNOWN,
+    constants.SUBMISSION_STATUS_UNDEFINED,
+]
+ImagePreset = Literal["ICPC", "CCPC", "HUNAN_CPC"]
+MedalPreset = Literal["ccpc", "icpc"]
+BannerMode = Literal["ONLY_BANNER", "ALL"]
+DateTimeISO8601String = str
+
+
+class Image(BaseModel):
+    url: Optional[str] = None
+    base64: Optional[str] = None
+    type: Optional[Literal["png", "svg", "jpg", "jpeg"]] = None
+    preset: Optional[ImagePreset] = None
+
+
+class Color(BaseModel):
+    color: str
+    background_color: str
+
+
+class Reaction(BaseModel):
+    url: Optional[str] = None
+
+
+class Submission(BaseModel):
+    id: str = ""
+
+    team_id: str = ""
+    problem_id: int = 0
+    timestamp: int = 0  # unit: seconds
+    status: SubmissionStatus = constants.SUBMISSION_STATUS_UNKNOWN
+
+    time: Optional[int] = None
+    language: Optional[str] = None
+
+    is_ignore: Optional[bool] = None
+
+    reaction: Optional[Reaction] = None
+
+
+class Submissions(RootModel[List[Submission]]):
+    root: List[Submission]
+
+
+class Team(BaseModel):
+    id: str = ""
+    name: str = ""
+
+    organization: str = ""
+    group: List[str] = Field(default_factory=list)
+    tag: List[str] = Field(default_factory=list)
+
+    coach: Optional[str] = None
+    members: Optional[List[str]] = None
+
+    badge: Optional[Image] = None
+
+    location: Optional[str] = None
+    icpc_id: Optional[str] = None
+
+    extra: Dict[str, str] = Field(default_factory=dict)
+
+    def add_group(self, group: str):
+        if group not in self.group:
+            self.group.append(group)
+
+    def remove_group(self, group: str):
+        if group in self.group:
+            self.group.remove(group)
+
+
+class Teams(RootModel[List[Team]]):
+    pass
+
+
+class ContestOptions(BaseModel):
+    calculation_of_penalty: Optional[CalculationOfPenalty] = None
+    submission_timestamp_unit: Optional[TimeUnit] = None
+    has_reaction_videos: Optional[bool] = None
+    reaction_video_url_template: Optional[str] = None
+
+
+class Contest(BaseModel):
+    contest_name: str = ""
+
+    start_time: Union[int, DateTimeISO8601String] = 0
+    end_time: Union[int, DateTimeISO8601String] = 0
+    penalty: int = 20 * 60  # unit: seconds
+
+    freeze_time: Optional[Union[int, DateTimeISO8601String]] = None
+    frozen_time: int = 60 * 60  # unit: seconds
+    unfrozen_time: int = 0x3F3F3F3F3F3F3F3F
+
+    problem_quantity: int = 0
+    problem_id: List[str] = Field(default_factory=list)
+
+    organization: str = "School"
+    status_time_display: Optional[Dict[str, bool]] = constants.FULL_STATUS_TIME_DISPLAY
+
+    badge: Optional[str] = None
+    medal: Optional[Union[Dict[str, Dict[str, int]], MedalPreset]] = None
+    balloon_color: Optional[List[Color]] = None
+
+    group: Optional[Dict[str, str]] = None
+    tag: Optional[Dict[str, str]] = None
+
+    logo: Optional[Image] = None
+    banner: Optional[Image] = None
+    banner_mode: Optional[BannerMode] = None
+    board_link: Optional[str] = None
+
+    version: Optional[str] = None
+
+    options: ContestOptions = Field(default_factory=ContestOptions)
+
+    def append_balloon_color(self, color: Color):
+        if self.balloon_color is None:
+            self.balloon_color = []
+        self.balloon_color.append(color)
+        return self
+
+    def fill_problem_id(self):
+        self.problem_id = [chr(ord("A") + i) for i in range(self.problem_quantity)]
+        return self
+
+    def fill_balloon_color(self):
+        default_balloon_color_list = [
+            Color(background_color="rgba(189, 14, 14, 0.7)", color="#fff"),
+            Color(background_color="rgba(149, 31, 217, 0.7)", color="#fff"),
+            Color(background_color="rgba(16, 32, 96, 0.7)", color="#fff"),
+            Color(background_color="rgba(38, 185, 60, 0.7)", color="#000"),
+            Color(background_color="rgba(239, 217, 9, 0.7)", color="#000"),
+            Color(background_color="rgba(243, 88, 20, 0.7)", color="#fff"),
+            Color(background_color="rgba(12, 76, 138, 0.7)", color="#fff"),
+            Color(background_color="rgba(156, 155, 155, 0.7)", color="#000"),
+            Color(background_color="rgba(4, 154, 115, 0.7)", color="#000"),
+            Color(background_color="rgba(159, 19, 236, 0.7)", color="#fff"),
+            Color(background_color="rgba(42, 197, 202, 0.7)", color="#000"),
+            Color(background_color="rgba(142, 56, 54, 0.7)", color="#fff"),
+            Color(background_color="rgba(144, 238, 144, 0.7)", color="#000"),
+            Color(background_color="rgba(77, 57, 0, 0.7)", color="#fff"),
+        ]
+
+        self.balloon_color = default_balloon_color_list[: self.problem_quantity]
+
+        return self

xcpcio-0.58.2/xcpcio.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: xcpcio
+Version: 0.58.2
+Summary: xcpcio python lib
+Author-email: Dup4 <hi@dup4.com>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/xcpcio/xcpcio
+Project-URL: documentation, https://github.com/xcpcio/xcpcio
+Project-URL: repository, https://github.com/xcpcio/xcpcio
+Keywords: xcpcio
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.11.7
+
+# xcpcio-python

xcpcio-0.58.2/xcpcio.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+tests/test_contest.py
+tests/test_submission.py
+tests/test_team.py
+tests/test_types.py
+xcpcio/__init__.py
+xcpcio/constants.py
+xcpcio/types.py
+xcpcio.egg-info/PKG-INFO
+xcpcio.egg-info/SOURCES.txt
+xcpcio.egg-info/dependency_links.txt
+xcpcio.egg-info/requires.txt
+xcpcio.egg-info/top_level.txt

xcpcio-0.58.2/xcpcio.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xcpcio-0.58.2/xcpcio.egg-info/requires.txt

@@ -0,0 +1 @@
+pydantic>=2.11.7

xcpcio-0.58.2/xcpcio.egg-info/top_level.txt

@@ -0,0 +1 @@
+xcpcio