xcpcio 0.63.5__py3-none-any.whl → 0.63.6__py3-none-any.whl

xcpcio/ccs/api_server/services/contest_service.py

@@ -0,0 +1,408 @@
+"""
+Contest Service
+
+Business logic layer for Contest API operations.
+Handles file reading, data validation, and business operations.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from fastapi import HTTPException
+
+from xcpcio.__version__ import __version__
+
+
+class ContestService:
+    """Service class for contest-related operations"""
+
+    def __init__(self, contest_package_dir: Path):
+        """
+        Initialize the contest service.
+
+        Args:
+            contest_package_dir: Path to the contest package directory
+        """
+        self.contest_package_dir = contest_package_dir
+        if not self.contest_package_dir.exists():
+            raise ValueError(f"Contest package directory does not exist: {contest_package_dir}")
+
+        # Initialize data indexes for faster lookups
+        self._load_indexes()
+
+    def _load_indexes(self) -> None:
+        """Load and index commonly accessed data for faster lookups"""
+        # Load contest data
+        self.contest_data = self.load_json_file("contest.json")
+
+        # Load organizations and create index
+        organizations_data = self.load_json_file("organizations.json")
+        self.organizations_by_id = {org["id"]: org for org in organizations_data}
+
+        # Load teams and create index
+        teams_data = self.load_json_file("teams.json")
+        self.teams_by_id = {team["id"]: team for team in teams_data}
+
+        # Load problems and create index
+        problems_data = self.load_json_file("problems.json")
+        self.problems_by_id = {problem["id"]: problem for problem in problems_data}
+
+        # Load submissions and create index
+        submissions_data = self.load_json_file("submissions.json")
+        self.submissions_by_id = {submission["id"]: submission for submission in submissions_data}
+
+    def load_json_file(self, filepath: str) -> Union[Dict[str, Any], List[Any]]:
+        """
+        Load JSON data from contest package directory.
+
+        Args:
+            filepath: Relative path to JSON file within contest package
+
+        Returns:
+            Parsed JSON data
+
+        Raises:
+            HTTPException: If file not found or invalid JSON
+        """
+        full_path = self.contest_package_dir / filepath
+        try:
+            with open(full_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except FileNotFoundError:
+            raise HTTPException(status_code=404, detail=f"File not found: {filepath}")
+        except json.JSONDecodeError as e:
+            raise HTTPException(status_code=500, detail=f"Invalid JSON in file {filepath}: {e}")
+
+    def get_contest_id(self) -> str:
+        """
+        Get contest ID from contest.json.
+
+        Returns:
+            Contest ID string
+        """
+        contest_data = self.load_json_file("contest.json")
+        return contest_data.get("id", "unknown")
+
+    def validate_contest_id(self, contest_id: str) -> None:
+        """
+        Validate that the provided contest ID matches the expected one.
+
+        Args:
+            contest_id: Contest ID to validate
+
+        Raises:
+            HTTPException: If contest ID doesn't match
+        """
+        expected_id = self.get_contest_id()
+        if contest_id != expected_id:
+            raise HTTPException(status_code=404, detail=f"Contest {contest_id} not found")
+
+    # API Information
+    def get_api_info(self) -> Dict[str, Any]:
+        """Get API information"""
+        return {
+            "version": "2023-06",
+            "version_url": "https://ccs-specs.icpc.io/2023-06/contest_api",
+            "name": "XCPCIO",
+            "provider": {
+                "name": "XCPCIO",
+                "version": __version__,
+            },
+        }
+
+    def get_access_info(self, contest_id: str) -> Dict[str, Any]:
+        """Get access information for current client"""
+        self.validate_contest_id(contest_id)
+        return {
+            "capabilities": [],
+            "endpoints": [
+                {
+                    "type": "contest",
+                    "properties": [
+                        "id",
+                        "name",
+                        "formal_name",
+                        "start_time",
+                        "duration",
+                        "scoreboard_type",
+                        "penalty_time",
+                    ],
+                },
+                {
+                    "type": "problems",
+                    "properties": ["id", "label", "name", "ordinal", "color", "rgb", "time_limit", "test_data_count"],
+                },
+                {"type": "teams", "properties": ["id", "name", "label", "organization_id", "group_ids", "hidden"]},
+                {"type": "organizations", "properties": ["id", "name", "formal_name"]},
+                {"type": "groups", "properties": ["id", "name"]},
+                {"type": "judgement-types", "properties": ["id", "name", "penalty", "solved"]},
+                {"type": "languages", "properties": ["id", "name", "extensions"]},
+                {
+                    "type": "state",
+                    "properties": ["started", "ended", "frozen", "thawed", "finalized", "end_of_updates"],
+                },
+                {
+                    "type": "submissions",
+                    "properties": ["id", "team_id", "problem_id", "language_id", "time", "contest_time"],
+                },
+                {
+                    "type": "judgements",
+                    "properties": ["id", "submission_id", "judgement_type_id", "start_time", "start_contest_time"],
+                },
+                {
+                    "type": "runs",
+                    "properties": [
+                        "id",
+                        "judgement_id",
+                        "ordinal",
+                        "judgement_type_id",
+                        "time",
+                        "contest_time",
+                        "run_time",
+                    ],
+                },
+                {
+                    "type": "clarifications",
+                    "properties": ["id", "from_team_id", "to_team_id", "problem_id", "text", "time", "contest_time"],
+                },
+                {"type": "awards", "properties": ["id", "citation", "team_ids"]},
+            ],
+        }
+
+    # Contest operations
+    def get_contests(self) -> List[Dict[str, Any]]:
+        """Get all contests"""
+        contest_data = self.load_json_file("contest.json")
+        return [contest_data]
+
+    def get_contest(self, contest_id: str) -> Dict[str, Any]:
+        """Get specific contest"""
+        self.validate_contest_id(contest_id)
+        return self.load_json_file("contest.json")
+
+    def get_contest_state(self, contest_id: str) -> Dict[str, Any]:
+        """Get contest state"""
+        self.validate_contest_id(contest_id)
+        return self.load_json_file("state.json")
+
+    # Problem operations
+    def get_problems(self, contest_id: str) -> List[Dict[str, Any]]:
+        """Get all problems"""
+        self.validate_contest_id(contest_id)
+        return self.load_json_file("problems.json")
+
+    def get_problem(self, contest_id: str, problem_id: str) -> Dict[str, Any]:
+        """Get specific problem"""
+        self.validate_contest_id(contest_id)
+        problems = self.load_json_file("problems.json")
+        for problem in problems:
+            if problem["id"] == problem_id:
+                return problem
+        raise HTTPException(status_code=404, detail=f"Problem {problem_id} not found")
+
+    # Team operations
+    def get_teams(self, contest_id: str, group_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Get all teams, optionally filtered by group"""
+        self.validate_contest_id(contest_id)
+        teams = self.load_json_file("teams.json")
+
+        if group_id:
+            filtered_teams = []
+            for team in teams:
+                if group_id in team.get("group_ids", []):
+                    filtered_teams.append(team)
+            return filtered_teams
+
+        return teams
+
+    def get_team(self, contest_id: str, team_id: str) -> Dict[str, Any]:
+        """Get specific team"""
+        self.validate_contest_id(contest_id)
+        teams = self.load_json_file("teams.json")
+        for team in teams:
+            if team["id"] == team_id:
+                return team
+        raise HTTPException(status_code=404, detail=f"Team {team_id} not found")
+
+    # Organization operations
+    def get_organizations(self, contest_id: str) -> List[Dict[str, Any]]:
+        """Get all organizations"""
+        self.validate_contest_id(contest_id)
+        return self.load_json_file("organizations.json")
+
+    def get_organization(self, contest_id: str, organization_id: str) -> Dict[str, Any]:
+        """Get specific organization"""
+        self.validate_contest_id(contest_id)
+        organizations = self.load_json_file("organizations.json")
+        for org in organizations:
+            if org["id"] == organization_id:
+                return org
+        raise HTTPException(status_code=404, detail=f"Organization {organization_id} not found")
+
+    # Group operations
+    def get_groups(self, contest_id: str) -> List[Dict[str, Any]]:
+        """Get all groups"""
+        self.validate_contest_id(contest_id)
+        return self.load_json_file("groups.json")
+
+    def get_group(self, contest_id: str, group_id: str) -> Dict[str, Any]:
+        """Get specific group"""
+        self.validate_contest_id(contest_id)
+        groups = self.load_json_file("groups.json")
+        for group in groups:
+            if group["id"] == group_id:
+                return group
+        raise HTTPException(status_code=404, detail=f"Group {group_id} not found")
+
+    # Language operations
+    def get_languages(self, contest_id: str) -> List[Dict[str, Any]]:
+        """Get all languages"""
+        self.validate_contest_id(contest_id)
+        return self.load_json_file("languages.json")
+
+    def get_language(self, contest_id: str, language_id: str) -> Dict[str, Any]:
+        """Get specific language"""
+        self.validate_contest_id(contest_id)
+        languages = self.load_json_file("languages.json")
+        for lang in languages:
+            if lang["id"] == language_id:
+                return lang
+        raise HTTPException(status_code=404, detail=f"Language {language_id} not found")
+
+    # Judgement type operations
+    def get_judgement_types(self, contest_id: str) -> List[Dict[str, Any]]:
+        """Get all judgement types"""
+        self.validate_contest_id(contest_id)
+        return self.load_json_file("judgement-types.json")
+
+    def get_judgement_type(self, contest_id: str, judgement_type_id: str) -> Dict[str, Any]:
+        """Get specific judgement type"""
+        self.validate_contest_id(contest_id)
+        judgement_types = self.load_json_file("judgement-types.json")
+        for jt in judgement_types:
+            if jt["id"] == judgement_type_id:
+                return jt
+        raise HTTPException(status_code=404, detail=f"Judgement type {judgement_type_id} not found")
+
+    # Submission operations
+    def get_submissions(
+        self, contest_id: str, team_id: Optional[str] = None, problem_id: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """Get all submissions, optionally filtered"""
+        self.validate_contest_id(contest_id)
+        submissions = self.load_json_file("submissions.json")
+
+        # Apply filters
+        if team_id:
+            submissions = [s for s in submissions if s.get("team_id") == team_id]
+        if problem_id:
+            submissions = [s for s in submissions if s.get("problem_id") == problem_id]
+
+        return submissions
+
+    def get_submission(self, contest_id: str, submission_id: str) -> Dict[str, Any]:
+        """Get specific submission"""
+        self.validate_contest_id(contest_id)
+        submissions = self.load_json_file("submissions.json")
+        for submission in submissions:
+            if submission["id"] == submission_id:
+                return submission
+        raise HTTPException(status_code=404, detail=f"Submission {submission_id} not found")
+
+    # Judgement operations
+    def get_judgements(self, contest_id: str, submission_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Get all judgements, optionally filtered by submission"""
+        self.validate_contest_id(contest_id)
+        judgements = self.load_json_file("judgements.json")
+
+        if submission_id:
+            judgements = [j for j in judgements if j.get("submission_id") == submission_id]
+
+        return judgements
+
+    def get_judgement(self, contest_id: str, judgement_id: str) -> Dict[str, Any]:
+        """Get specific judgement"""
+        self.validate_contest_id(contest_id)
+        judgements = self.load_json_file("judgements.json")
+        for judgement in judgements:
+            if judgement["id"] == judgement_id:
+                return judgement
+        raise HTTPException(status_code=404, detail=f"Judgement {judgement_id} not found")
+
+    # Run operations
+    def get_runs(self, contest_id: str, judgement_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Get all runs, optionally filtered by judgement"""
+        self.validate_contest_id(contest_id)
+        runs = self.load_json_file("runs.json")
+
+        if judgement_id:
+            runs = [r for r in runs if r.get("judgement_id") == judgement_id]
+
+        return runs
+
+    def get_run(self, contest_id: str, run_id: str) -> Dict[str, Any]:
+        """Get specific run"""
+        self.validate_contest_id(contest_id)
+        runs = self.load_json_file("runs.json")
+        for run in runs:
+            if run["id"] == run_id:
+                return run
+        raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
+
+    # Clarification operations
+    def get_clarifications(
+        self,
+        contest_id: str,
+        from_team_id: Optional[str] = None,
+        to_team_id: Optional[str] = None,
+        problem_id: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """Get all clarifications, optionally filtered"""
+        self.validate_contest_id(contest_id)
+        clarifications = self.load_json_file("clarifications.json")
+
+        # Apply filters (empty string means null)
+        if from_team_id is not None:
+            if from_team_id == "":
+                clarifications = [c for c in clarifications if c.get("from_team_id") is None]
+            else:
+                clarifications = [c for c in clarifications if c.get("from_team_id") == from_team_id]
+
+        if to_team_id is not None:
+            if to_team_id == "":
+                clarifications = [c for c in clarifications if c.get("to_team_id") is None]
+            else:
+                clarifications = [c for c in clarifications if c.get("to_team_id") == to_team_id]
+
+        if problem_id is not None:
+            if problem_id == "":
+                clarifications = [c for c in clarifications if c.get("problem_id") is None]
+            else:
+                clarifications = [c for c in clarifications if c.get("problem_id") == problem_id]
+
+        return clarifications
+
+    def get_clarification(self, contest_id: str, clarification_id: str) -> Dict[str, Any]:
+        """Get specific clarification"""
+        self.validate_contest_id(contest_id)
+        clarifications = self.load_json_file("clarifications.json")
+        for clarification in clarifications:
+            if clarification["id"] == clarification_id:
+                return clarification
+        raise HTTPException(status_code=404, detail=f"Clarification {clarification_id} not found")
+
+    # Award operations
+    def get_awards(self, contest_id: str) -> List[Dict[str, Any]]:
+        """Get all awards"""
+        self.validate_contest_id(contest_id)
+        return self.load_json_file("awards.json")
+
+    def get_award(self, contest_id: str, award_id: str) -> Dict[str, Any]:
+        """Get specific award"""
+        self.validate_contest_id(contest_id)
+        awards = self.load_json_file("awards.json")
+        for award in awards:
+            if award["id"] == award_id:
+                return award
+        raise HTTPException(status_code=404, detail=f"Award {award_id} not found")

{xcpcio-0.63.5.dist-info → xcpcio-0.63.6.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: xcpcio
-Version: 0.63.5
+Version: 0.63.6
 Summary: xcpcio python lib
 Project-URL: homepage, https://github.com/xcpcio/xcpcio
 Project-URL: documentation, https://github.com/xcpcio/xcpcio
 Project-URL: repository, https://github.com/xcpcio/xcpcio
 Author-email: Dup4 <hi@dup4.com>
+Maintainer-email: Dup4 <hi@dup4.com>, cubercsl <hi@cubercsl.site>
 License-Expression: MIT
 Keywords: xcpcio
 Classifier: Programming Language :: Python :: 3
@@ -18,10 +19,12 @@ Requires-Python: >=3.11
 Requires-Dist: aiofiles>=23.0.0
 Requires-Dist: aiohttp>=3.8.0
 Requires-Dist: click>=8.0.0
+Requires-Dist: fastapi>=0.117.1
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: semver>=3.0.0
 Requires-Dist: tenacity>=8.0.0
+Requires-Dist: uvicorn>=0.36.0
 Description-Content-Type: text/markdown
 
 # xcpcio-python

xcpcio-0.63.6.dist-info/RECORD

@@ -0,0 +1,33 @@
+xcpcio/__init__.py,sha256=kjd6itqBRSQ-OT83qUJXHt81KQQDRUtaIuykzfaWXLM,121
+xcpcio/__version__.py,sha256=rmZgql2iMibrRXQ70oij5TmONsjXyGZIxE3EUzW1_1E,172
+xcpcio/constants.py,sha256=MjpAgNXiBlUsx1S09m7JNT-nekNDR-aE6ggvGL3fg0I,2297
+xcpcio/types.py,sha256=AkYby2haJgxwtozlgaPMG2ryAZdvsSc3sH-p6qXcM4g,6575
+xcpcio/ccs/__init__.py,sha256=LSoKFblEuSoIVBYcUxOFF8fn2bH2R6kSg9xNrBfzC0g,99
+xcpcio/ccs/contest_archiver.py,sha256=FKpUn1IGfa-UNf63OJ5eff7rxOEqXCvFYRLsvkMbUJc,16203
+xcpcio/ccs/api_server/__init__.py,sha256=ASvVJ_ibGkXFDSNmy05eb9gESXRS8hjYHCrBecSnaS0,174
+xcpcio/ccs/api_server/dependencies.py,sha256=5nosGVwY-3Mq7eK9C5ZOMEJFozzzw_kLlpCraFbJ9wY,1225
+xcpcio/ccs/api_server/server.py,sha256=3gft3MqDXvKWug5UCLhdV681bcQMRrewDkwQ7qSPtRU,2598
+xcpcio/ccs/api_server/routes/__init__.py,sha256=imTyDjc9Md3OIr7GniHi3i1vmfzSTKppuUjVREtd8b4,1461
+xcpcio/ccs/api_server/routes/access.py,sha256=8f21NmvVLaFopb5q4MnifOHbhadDZuNHr0BIYc9nmqY,579
+xcpcio/ccs/api_server/routes/awards.py,sha256=uj56ty2k7N5KXfQuWTvvTXSa7HO29CUfEhO8S85hlM0,1069
+xcpcio/ccs/api_server/routes/clarifications.py,sha256=JX7FNbv_4mRdpuV0aSzGwjjmW-4SwTbmAOlm51MNpf4,1644
+xcpcio/ccs/api_server/routes/contests.py,sha256=bJeMaGegei59rD-5YE0ptYcNsPdJqc73KnntRpShzZk,2560
+xcpcio/ccs/api_server/routes/general.py,sha256=9WsnjlomsU13vvozOVHSRIzgReuLGzPln3xwDb8i-gY,933
+xcpcio/ccs/api_server/routes/groups.py,sha256=8hOT_2rz329M_7hcfggRxLU-g8aV2xp6w3aMYlfOPNs,1087
+xcpcio/ccs/api_server/routes/judgement_types.py,sha256=pMOFBQ1LqKhCTLNBGzopCOEmTnWsuVg67dTuItJaCsM,1268
+xcpcio/ccs/api_server/routes/judgements.py,sha256=9GMaEkD8erhqaSItlZQdLzKz-1XL7MD2SQinnD_CZFg,1339
+xcpcio/ccs/api_server/routes/languages.py,sha256=DUNRd3q_Hm5F8-3nCiAMpqqxzG_9zcU5_N8ACefqjOE,1176
+xcpcio/ccs/api_server/routes/organizations.py,sha256=fWnKTCmxd3c1leYsRuJHuuTs0CZr-l_-Jl-8_wY_Ojk,2889
+xcpcio/ccs/api_server/routes/problems.py,sha256=0Ba3fz09UfTGYmYYYJYFGmIpgIvJaa1Fg-5pcLcxEMY,2774
+xcpcio/ccs/api_server/routes/runs.py,sha256=uBPeM5ChI3LxR__pBSyDxsbcE4NyL6eKVdvF4TEOk5g,1248
+xcpcio/ccs/api_server/routes/submissions.py,sha256=81-KbQLUKCqgGE-aCTO7-Pg2QyTJc_Mu_Ys8N0oF1tU,3161
+xcpcio/ccs/api_server/routes/teams.py,sha256=y_aJykzgewmOQtXOJe2s0s7DQmnKjD3805Q5VTcdlIQ,2725
+xcpcio/ccs/api_server/services/__init__.py,sha256=WQLNrLVomhtICl8HlFYaCoRewIHVZfUiiwrSBUOOWDg,171
+xcpcio/ccs/api_server/services/contest_service.py,sha256=EbSDrkVg18Th9kAuYAin4InHCOI7hWkkDJR1u1xlEtk,16186
+xcpcio/ccs/model/__init__.py,sha256=cZE1q5JY-iHDEKZpsx0UZaMhH-23H4oAHaYOkW7dZ5s,43
+xcpcio/ccs/model/model_2023_06/__init__.py,sha256=OmDQZqmigBpL64LXk5lIOGoQ3Uqis8-2z6qQpOO5aJc,167
+xcpcio/ccs/model/model_2023_06/model.py,sha256=bVMDWpJTwPSpz1fHPxWrWerxCBIboH3LKVZpIZGQ2pY,15287
+xcpcio-0.63.6.dist-info/METADATA,sha256=uEBCmgoTkMCCrO-zLZGdzDjhYb9n51mabFs4lwEV0II,1079
+xcpcio-0.63.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xcpcio-0.63.6.dist-info/entry_points.txt,sha256=qvzh8oDJxIHqTN-rg2lRN6xR99AqxbWnlAQI7uzDibI,59
+xcpcio-0.63.6.dist-info/RECORD,,

xcpcio-0.63.5.dist-info/RECORD

@@ -1,13 +0,0 @@
-xcpcio/__init__.py,sha256=kjd6itqBRSQ-OT83qUJXHt81KQQDRUtaIuykzfaWXLM,121
-xcpcio/__version__.py,sha256=0Inh2IrO1TDWHZQNNWZG7RQoT8GKZUEeRoZnIhcVdWI,23
-xcpcio/constants.py,sha256=MjpAgNXiBlUsx1S09m7JNT-nekNDR-aE6ggvGL3fg0I,2297
-xcpcio/types.py,sha256=AkYby2haJgxwtozlgaPMG2ryAZdvsSc3sH-p6qXcM4g,6575
-xcpcio/ccs/__init__.py,sha256=qjkSo9lS8dJyNqiGljCnbS1cr7J8jj72pqcCzf_v0Ig,75
-xcpcio/ccs/contest_archiver.py,sha256=FKpUn1IGfa-UNf63OJ5eff7rxOEqXCvFYRLsvkMbUJc,16203
-xcpcio/ccs/model/__init__.py,sha256=cZE1q5JY-iHDEKZpsx0UZaMhH-23H4oAHaYOkW7dZ5s,43
-xcpcio/ccs/model/model_2023_06/__init__.py,sha256=OmDQZqmigBpL64LXk5lIOGoQ3Uqis8-2z6qQpOO5aJc,167
-xcpcio/ccs/model/model_2023_06/model.py,sha256=bVMDWpJTwPSpz1fHPxWrWerxCBIboH3LKVZpIZGQ2pY,15287
-xcpcio-0.63.5.dist-info/METADATA,sha256=KK0d6SVxSWCkNyD-6fYSO5GZnV2L9dT8FA_hE7o2hp0,950
-xcpcio-0.63.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xcpcio-0.63.5.dist-info/entry_points.txt,sha256=qvzh8oDJxIHqTN-rg2lRN6xR99AqxbWnlAQI7uzDibI,59
-xcpcio-0.63.5.dist-info/RECORD,,