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

xcpcio/ccs/api_server/services/contest_service.py

@@ -5,102 +5,31 @@ 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
+import logging
+from typing import Any, Dict, List, Optional
 
 from fastapi import HTTPException
 
 from xcpcio.__version__ import __version__
+from xcpcio.ccs.base.types import FileAttr
+from xcpcio.ccs.reader.base_ccs_reader import BaseCCSReader
+
+logger = logging.getLogger(__name__)
 
 
 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:
+    def __init__(self, reader_dict: Dict[str, BaseCCSReader]):
+        self.reader_dict = reader_dict
+
+    def _get_reader(self, contest_id: str) -> BaseCCSReader:
+        if contest_id not in self.reader_dict:
             raise HTTPException(status_code=404, detail=f"Contest {contest_id} not found")
+        return self.reader_dict[contest_id]
 
     # 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",
@@ -111,298 +40,155 @@ class ContestService:
             },
         }
 
-    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"]},
-            ],
-        }
+    def get_access(self, contest_id: str) -> Dict[str, Any]:
+        reader = self._get_reader(contest_id)
+        return reader.get_access()
+
+    # Account operations
+    def get_accounts(self, contest_id: str) -> List[Dict[str, Any]]:
+        reader = self._get_reader(contest_id)
+        return reader.get_accounts()
+
+    def get_account(self, contest_id: str, account_id: str) -> Dict[str, Any]:
+        reader = self._get_reader(contest_id)
+        return reader.get_account(account_id)
 
     # Contest operations
     def get_contests(self) -> List[Dict[str, Any]]:
-        """Get all contests"""
-        contest_data = self.load_json_file("contest.json")
-        return [contest_data]
+        return [reader.get_contest() for reader in self.reader_dict.values()]
 
     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")
+        reader = self._get_reader(contest_id)
+        return reader.get_contest()
 
     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")
+        reader = self._get_reader(contest_id)
+        return reader.get_contest_state()
+
+    def get_contest_banner(self, contest_id: str) -> FileAttr:
+        reader = self._get_reader(contest_id)
+        return reader.get_contest_banner()
+
+    def get_contest_problemset(self, contest_id: str) -> FileAttr:
+        reader = self._get_reader(contest_id)
+        return reader.get_contest_problemset()
 
     # 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")
+        reader = self._get_reader(contest_id)
+        return reader.get_problems()
 
     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")
+        reader = self._get_reader(contest_id)
+        return reader.get_problem(problem_id)
 
-    # 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")
+    def get_problem_statement(self, contest_id: str, problem_id: str) -> FileAttr:
+        reader = self._get_reader(contest_id)
+        return reader.get_problem_statement(problem_id)
 
-        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
+    # Team operations
+    def get_teams(self, contest_id: str) -> List[Dict[str, Any]]:
+        reader = self._get_reader(contest_id)
+        return reader.get_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")
+        reader = self._get_reader(contest_id)
+        return reader.get_team(team_id)
+
+    def get_team_photo(self, contest_id: str, team_id: str) -> FileAttr:
+        reader = self._get_reader(contest_id)
+        return reader.get_team_photo(team_id)
 
     # 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")
+        reader = self._get_reader(contest_id)
+        return reader.get_organizations()
 
     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")
+        reader = self._get_reader(contest_id)
+        return reader.get_organization(organization_id)
+
+    def get_organization_logo(self, contest_id: str, organization_id: str) -> FileAttr:
+        reader = self._get_reader(contest_id)
+        return reader.get_organization_logo(organization_id)
 
     # 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")
+        reader = self._get_reader(contest_id)
+        return reader.get_groups()
 
     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")
+        reader = self._get_reader(contest_id)
+        return reader.get_group(group_id)
 
     # 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")
+        reader = self._get_reader(contest_id)
+        return reader.get_languages()
 
     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")
+        reader = self._get_reader(contest_id)
+        return reader.get_language(language_id)
 
     # 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")
+        reader = self._get_reader(contest_id)
+        return reader.get_judgement_types()
 
     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")
+        reader = self._get_reader(contest_id)
+        return reader.get_judgement_type(judgement_type_id)
 
     # 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_submissions(self, contest_id: str) -> List[Dict[str, Any]]:
+        reader = self._get_reader(contest_id)
+        return reader.get_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")
+        reader = self._get_reader(contest_id)
+        return reader.get_submission(submission_id)
+
+    def get_submission_file(self, contest_id: str, submission_id: str) -> FileAttr:
+        reader = self._get_reader(contest_id)
+        return reader.get_submission_file(submission_id)
 
     # 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
+        reader = self._get_reader(contest_id)
+        return reader.get_judgements(submission_id)
 
     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")
+        reader = self._get_reader(contest_id)
+        return reader.get_judgement(judgement_id)
 
     # 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
+        reader = self._get_reader(contest_id)
+        return reader.get_runs(judgement_id)
 
     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")
+        reader = self._get_reader(contest_id)
+        return reader.get_run(run_id)
 
     # 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_clarifications(self, contest_id: str) -> List[Dict[str, Any]]:
+        reader = self._get_reader(contest_id)
+        return reader.get_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")
+        reader = self._get_reader(contest_id)
+        return reader.get_clarification(clarification_id)
 
     # 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")
+        reader = self._get_reader(contest_id)
+        return reader.get_awards()
 
     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")
+        reader = self._get_reader(contest_id)
+        return reader.get_award(award_id)
+
+    # Event Feed operations
+    def get_event_feed(self, contest_id: str, since_token: Optional[str] = None) -> List[Dict[str, Any]]:
+        reader = self._get_reader(contest_id)
+        return reader.get_event_feed(since_token)

xcpcio/ccs/base/__init__.py

@@ -0,0 +1,3 @@
+from . import types
+
+__all__ = [types]

xcpcio/ccs/base/types.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class FileAttr:
+    path: Path
+    media_type: str
+    name: str

xcpcio/ccs/contest_archiver.py

@@ -59,7 +59,6 @@ class ContestArchiver:
 
     # Known endpoints that can be fetched
     KNOWN_ENDPOINTS = [
-        "access",
         "contests",
         "judgement-types",
         "languages",
@@ -80,7 +79,6 @@ class ContestArchiver:
     ]
 
     DOMJUDGE_KNOWN_ENDPOINTS = [
-        "access",
         "contests",
         "judgement-types",
         "languages",
@@ -289,7 +287,7 @@ class ContestArchiver:
 
         data = await self.fetch_json("/")
         if not data:
-            raise RuntimeError("Failed to fetch API information from root endpoint")
+            raise RuntimeError("Failed to fetch API information")
 
         self._api_info = data  # Store API info for later use
 
@@ -401,6 +399,7 @@ class ContestArchiver:
         # Always dump API and contest info
         await self.dump_api_info()
         await self.dump_contest_info()
+        await self.dump_endpoint_single("access")
 
         # Get list of endpoints to dump
         if self._config.endpoints: