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

xcpcio/ccs/api_server/services/contest_service.py

@@ -5,14 +5,14 @@ Business logic layer for Contest API operations.
 Handles file reading, data validation, and business operations.
 """
 
+import bisect
 import json
+from collections import defaultdict
 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"""
@@ -31,26 +31,61 @@ class ContestService:
         # Initialize data indexes for faster lookups
         self._load_indexes()
 
+    def _create_index_by_id(self, data: List[Dict[str, Any]], id_name: str) -> Dict[str, List[Dict]]:
+        res = defaultdict(list)
+        for item in data:
+            res[item[id_name]].append(item)
+        return res
+
     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")
+        self.access = self.load_json_file("access.json")
+
+        self.accounts = self.load_json_file("accounts.json")
+        self.accounts_by_id = {account["id"] for account in self.accounts}
+
+        self.api_info = self.load_json_file("api.json")
+
+        self.awards = self.load_json_file("awards.json")
+        self.awards_by_id = {award["id"] for award in self.awards}
+
+        self.clarifications = self.load_json_file("clarifications.json")
+        self.clarifications_by_id = {clarification["id"] for clarification in self.clarifications}
+
+        self.contest = self.load_json_file("contest.json")
+        self.contest_state = self.load_json_file("state.json")
+
+        self.groups = self.load_json_file("groups.json")
+        self.groups_by_id = {group["id"]: group for group in self.groups}
+
+        self.judgement_types = self.load_json_file("judgement-types.json")
+        self.judgement_types_by_id = {judgement_type["id"] for judgement_type in self.judgement_types}
+
+        self.judgements = self.load_json_file("judgements.json")
+        self.judgements_by_id = {judgement["id"] for judgement in self.judgements}
+        self.judgements_by_submission_id = self._create_index_by_id(self.judgements, "submission_id")
+
+        self.languages = self.load_json_file("languages.json")
+        self.languages_by_id = {language["id"] for language in self.languages}
 
-        # 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}
+        self.organizations = self.load_json_file("organizations.json")
+        self.organizations_by_id = {org["id"]: org for org in self.organizations}
 
-        # 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}
+        self.problems = self.load_json_file("problems.json")
+        self.problems_by_id = {problem["id"]: problem for problem in self.problems}
 
-        # 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}
+        self.runs = self.load_json_file("runs.json")
+        self.runs_by_id = {run["id"] for run in self.runs}
+        self.runs_by_judgement_id = self._create_index_by_id(self.runs, "judgement_id")
 
-        # 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}
+        self.submissions = self.load_json_file("submissions.json")
+        self.submissions_by_id = {submission["id"]: submission for submission in self.submissions}
+
+        self.teams = self.load_json_file("teams.json")
+        self.teams_by_id = {team["id"]: team for team in self.teams}
+
+        self.event_feed = self.load_ndjson_file("event-feed.ndjson")
+        self.event_feed_tokens = [event["token"] for event in self.event_feed]
 
     def load_json_file(self, filepath: str) -> Union[Dict[str, Any], List[Any]]:
         """
@@ -65,6 +100,7 @@ class ContestService:
         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:
@@ -74,6 +110,19 @@ class ContestService:
         except json.JSONDecodeError as e:
             raise HTTPException(status_code=500, detail=f"Invalid JSON in file {filepath}: {e}")
 
+    def load_ndjson_file(self, filepath: str) -> List[Dict[str, Any]]:
+        full_path = self.contest_package_dir / filepath
+        try:
+            data = list()
+            with open(full_path, "r", encoding="utf-8") as f:
+                for line in f.readlines():
+                    data.append(json.loads(line))
+            return data
+        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.
@@ -100,309 +149,177 @@ class ContestService:
 
     # 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"""
+        return self.api_info
+
+    def get_access(self, contest_id: str) -> Dict[str, Any]:
+        self.validate_contest_id(contest_id)
+        return self.access
+
+    # Account operations
+    def get_accounts(self, contest_id: str) -> List[Dict[str, Any]]:
+        self.validate_contest_id(contest_id)
+        return self.accounts
+
+    def get_account(self, contest_id: str, account_id: str) -> Dict[str, Any]:
         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"]},
-            ],
-        }
+        if account_id not in self.accounts_by_id:
+            raise HTTPException(status_code=404, detail=f"Account {account_id} not found")
+        return self.accounts_by_id[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 [self.contest]
 
     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")
+        return self.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")
+        return self.contest_state
 
     # 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")
+        return self.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")
+        if problem_id not in self.problems_by_id:
+            raise HTTPException(status_code=404, detail=f"Problem {problem_id} not found")
+        return self.problems_by_id[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"""
+    def get_teams(self, contest_id: str) -> List[Dict[str, Any]]:
         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
+        return self.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")
+        if team_id not in self.teams_by_id:
+            raise HTTPException(status_code=404, detail=f"Team {team_id} not found")
+        return self.teams_by_id[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")
+        return self.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")
+        if organization_id not in self.organizations_by_id:
+            raise HTTPException(status_code=404, detail=f"Organization {organization_id} not found")
+        return self.organizations_by_id[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")
+        return self.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")
+        if group_id not in self.groups_by_id:
+            raise HTTPException(status_code=404, detail=f"Group {group_id} not found")
+        return self.groups_by_id[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")
+        return self.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")
+        if language_id not in self.languages_by_id:
+            raise HTTPException(status_code=404, detail=f"Language {language_id} not found")
+        return self.languages_by_id[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")
+        return self.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")
+        if judgement_type_id not in self.judgement_types_by_id:
+            raise HTTPException(status_code=404, detail=f"Judgement type {judgement_type_id} not found")
+        return self.judgement_types_by_id[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"""
+    def get_submissions(self, contest_id: str) -> List[Dict[str, Any]]:
         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
+        return self.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")
+        if submission_id not in self.submissions_by_id:
+            raise HTTPException(status_code=404, detail=f"Submission {submission_id} not found")
+        return self.submissions_by_id[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]
+        if submission_id is not None:
+            if submission_id not in self.judgements_by_submission_id:
+                raise HTTPException(status_code=404, detail=f"Submission id not found: {submission_id}")
+            return self.judgements_by_submission_id[submission_id]
 
-        return judgements
+        return self.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")
+        if judgement_id not in self.judgements_by_id:
+            raise HTTPException(status_code=404, detail=f"Judgement {judgement_id} not found")
+        return self.judgements_by_id[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]
+        if judgement_id is not None:
+            if judgement_id not in self.runs_by_judgement_id:
+                raise HTTPException(status_code=404, detail=f"Judgement id not found: {judgement_id}")
+            return self.runs_by_judgement_id[judgement_id]
 
-        return runs
+        return self.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")
+        if run_id not in self.runs_by_id:
+            raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
+        return self.runs_by_id[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
+        return self.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")
+        if clarification_id not in self.clarifications_by_id:
+            raise HTTPException(status_code=404, detail=f"Clarification {clarification_id} not found")
+        return self.clarifications_by_id[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")
+        return self.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")
+        if award_id not in self.awards_by_id:
+            raise HTTPException(status_code=404, detail=f"Award {award_id} not found")
+        return self.awards_by_id[award_id]
+
+    # Event Feed operations
+    def get_event_feed(self, contest_id: str, since_token: Optional[str] = None) -> List[Dict[str, Any]]:
+        self.validate_contest_id(contest_id)
+
+        if since_token is None:
+            return self.event_feed
+
+        idx = bisect.bisect_left(self.event_feed_tokens, since_token)
+        return self.event_feed[idx:]

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:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xcpcio
-Version: 0.63.6
+Version: 0.63.7
 Summary: xcpcio python lib
 Project-URL: homepage, https://github.com/xcpcio/xcpcio
 Project-URL: documentation, https://github.com/xcpcio/xcpcio

xcpcio-0.63.7.dist-info/RECORD

@@ -0,0 +1,34 @@
+xcpcio/__init__.py,sha256=kjd6itqBRSQ-OT83qUJXHt81KQQDRUtaIuykzfaWXLM,121
+xcpcio/__version__.py,sha256=95oCDxj_oHcOcxQzEfotvdWgY-p_3xsHZ2AaFTYVdR4,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=ICogyPzKfFRoO7J5D2Eu-3JwIirC3etMev7hyTjn4z8,16198
+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=uz65H4L5Wzef7QPi5PsLQM1xbMdG6FoZ0Np0y039_2k,1537
+xcpcio/ccs/api_server/routes/access.py,sha256=O-RGLmgLNBQ-ccu8rlHOgonTjl02fYOdi3VTsUa-T0w,434
+xcpcio/ccs/api_server/routes/accounts.py,sha256=nAwiIz-y4fGmqHBniMuQifk9jVt4i9YPZWBB7w40q5Q,994
+xcpcio/ccs/api_server/routes/awards.py,sha256=gBPSFlDj6PM6Poys6JbO7VMsfCljKz6QrTjKEqQcS8w,957
+xcpcio/ccs/api_server/routes/clarifications.py,sha256=vvMNMvQkZTOn1VJ8C5U86gpIkN3yNrxBll1VMTJjzQg,1046
+xcpcio/ccs/api_server/routes/contests.py,sha256=o-A5wMDy5UC9wM71K3ruMmP4p4lSoU9B3XmDGPV0M7g,4203
+xcpcio/ccs/api_server/routes/general.py,sha256=xLH-sqyeC4dSd6SUYpjg-w-1ZtmSqZAgIupoVOyYwD4,763
+xcpcio/ccs/api_server/routes/groups.py,sha256=kWKFFty2iWckMN-j6G3NbgMVKCPQ478_mYKrYsHXgMA,949
+xcpcio/ccs/api_server/routes/judgement_types.py,sha256=S3Dt0VYjntVBQBvLYhJGcDNSy7O8Zh7b7NSfrronZSU,1057
+xcpcio/ccs/api_server/routes/judgements.py,sha256=3w0LHYbZazli_v587l98U23r5PuolRs_vtbNLMwgjTU,1127
+xcpcio/ccs/api_server/routes/languages.py,sha256=2BYqTaSBWx0E5XlaTjofElLb7z4HTsVs3rrozdyqz0s,985
+xcpcio/ccs/api_server/routes/organizations.py,sha256=608tPsK2bCUmqSalEFysC1zQf3FDDIeweT6PLLrOyLg,2515
+xcpcio/ccs/api_server/routes/problems.py,sha256=2YFw_ODw-6L015UgpL1p-lLItgCgnqDamni6_9Qmbdk,2458
+xcpcio/ccs/api_server/routes/runs.py,sha256=1L6fo1KPcDeKwOEkTxCwEetmyfNKY_Z0uxATqBJftIs,1046
+xcpcio/ccs/api_server/routes/submissions.py,sha256=UKgDt9yv45Hfpr8P_8-2Po0jF4HvzG87zgkcb1YIKVc,2542
+xcpcio/ccs/api_server/routes/teams.py,sha256=9nWz0tvMnccCNEzSN9DY-ZJtxlgaka9YSPe_5Gykbl8,2282
+xcpcio/ccs/api_server/services/__init__.py,sha256=WQLNrLVomhtICl8HlFYaCoRewIHVZfUiiwrSBUOOWDg,171
+xcpcio/ccs/api_server/services/contest_service.py,sha256=rMbAm7HVw5dHMTwp1tLAP0QhlCKlEMWQ65LZLZzjbfg,13210
+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.7.dist-info/METADATA,sha256=oWlZ8fA8EO1Ly_wvo8JUlxbeDmlV7PVKPKum4ydxzDk,1079
+xcpcio-0.63.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xcpcio-0.63.7.dist-info/entry_points.txt,sha256=qvzh8oDJxIHqTN-rg2lRN6xR99AqxbWnlAQI7uzDibI,59
+xcpcio-0.63.7.dist-info/RECORD,,

xcpcio-0.63.6.dist-info/RECORD

@@ -1,33 +0,0 @@
-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,,