xcpcio 0.67.0__py3-none-any.whl → 0.74.0__py3-none-any.whl

xcpcio/__version__.py

@@ -1,4 +1,4 @@
 # This file is auto-generated by Hatchling. As such, do not:
 #   - modify
 #   - track in version control e.g. be sure to add to .gitignore
-__version__ = VERSION = '0.67.0'
+__version__ = VERSION = '0.74.0'

xcpcio/api/__init__.py

@@ -1,5 +1,6 @@
 from .client import ApiClient
 from .models import (
+    FileData,
     HTTPValidationError,
     UploadBoardDataReq,
     UploadBoardDataResp,
@@ -8,6 +9,7 @@ from .models import (
 
 __all__ = [
     ApiClient,
+    FileData,
     HTTPValidationError,
     UploadBoardDataReq,
     UploadBoardDataResp,

xcpcio/api/client.py

@@ -2,7 +2,7 @@ from typing import Any, Dict, Optional
 
 import aiohttp
 
-from .models import UploadBoardDataReq, UploadBoardDataResp
+from .models import FileData, UploadBoardDataReq, UploadBoardDataResp
 
 
 class ApiClient:
@@ -51,7 +51,7 @@ class ApiClient:
         config: Optional[str] = None,
         teams: Optional[str] = None,
         submissions: Optional[str] = None,
-        extra_files: Optional[Dict[str, str]] = None,
+        extra_files: Optional[Dict[str, FileData]] = None,
     ) -> UploadBoardDataResp:
         await self._ensure_session()
         await self._ensure_token()

xcpcio/api/models.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Literal, Optional, Union
 
 from pydantic import BaseModel, Field
 
@@ -13,13 +13,24 @@ class HTTPValidationError(BaseModel):
     detail: Optional[List[ValidationError]] = Field(None, title="Detail")
 
 
+class FileData(BaseModel):
+    content: str = Field(..., title="Content")
+    encoding: Optional[Literal["base64"]] = Field(None, title="Encoding")
+    checksum: Optional[str] = Field(None, title="Checksum")
+
+
 class UploadBoardDataReq(BaseModel):
     token: str = Field(..., title="Token")
     config: Optional[str] = Field(None, title="Config")
     teams: Optional[str] = Field(None, title="Teams")
     submissions: Optional[str] = Field(None, title="Submissions")
-    extra_files: Optional[Dict[str, str]] = Field(None, title="Extra Files")
+    extra_files: Optional[Dict[str, FileData]] = Field(None, title="Extra Files")
+
+
+class FileValidationResult(BaseModel):
+    checksum_valid: bool = Field(..., title="Checksum Valid")
+    message: Optional[str] = Field(None, title="Message")
 
 
 class UploadBoardDataResp(BaseModel):
-    pass
+    file_validations: Dict[str, FileValidationResult] = Field(default_factory=dict, title="File Validations")

xcpcio/app/clics_uploader.py

@@ -0,0 +1,103 @@
+import asyncio
+import logging
+from pathlib import Path
+from typing import Optional
+
+import click
+
+from xcpcio import __version__
+from xcpcio.clics.clics_api_client import APICredentials
+from xcpcio.clics.contest_uploader import ContestUploader, UploaderConfig
+
+
+def setup_logging(level: str = "INFO"):
+    logging.basicConfig(
+        level=getattr(logging, level.upper()),
+        format="%(asctime)s [%(name)s] %(filename)s:%(lineno)d %(levelname)s: %(message)s",
+    )
+
+
+@click.command()
+@click.version_option(__version__)
+@click.option("--base-url", required=True, help="Base URL of the CLICS API (e.g., https://domjudge/api)")
+@click.option("--contest-id", required=True, help="Contest ID to fetch")
+@click.option("--username", "-u", required=True, help="HTTP Basic Auth username for CLICS API")
+@click.option("--password", "-p", required=True, help="HTTP Basic Auth password for CLICS API")
+@click.option("--xcpcio-api-url", default="https://api.xcpcio.com", help="XCPCIO API URL")
+@click.option("--xcpcio-api-token", required=True, help="XCPCIO API token")
+@click.option(
+    "--cache-dir", type=click.Path(path_type=Path), help="Directory for checksum cache files (default: ~/.xcpcio/)"
+)
+@click.option("--timeout", default=30, type=int, help="Request timeout in seconds")
+@click.option("--max-concurrent", default=10, type=int, help="Max concurrent requests for CLICS API")
+@click.option("--interval", default=5, type=int, help="Polling interval in seconds")
+@click.option(
+    "--log-level",
+    default="INFO",
+    type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR"], case_sensitive=False),
+    help="Log level",
+)
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose logging (same as --log-level DEBUG)")
+def main(
+    base_url: str,
+    contest_id: str,
+    username: str,
+    password: str,
+    xcpcio_api_url: str,
+    xcpcio_api_token: str,
+    cache_dir: Optional[Path],
+    timeout: int,
+    max_concurrent: int,
+    interval: int,
+    log_level: str,
+    verbose: bool,
+):
+    """
+    Upload CLICS Contest API data to XCPCIO with polling support.
+
+    This tool fetches contest data from a CLICS API and uploads raw JSON data to the xcpcio board-admin service.
+    It continuously polls every 5 seconds and uses SHA256 checksums to avoid uploading unchanged files.
+
+    Examples:
+
+        clics-uploader --base-url https://domjudge/api --contest-id contest123 -u admin -p secret --xcpcio-api-token YOUR_TOKEN
+    """
+
+    if verbose:
+        log_level = "DEBUG"
+
+    setup_logging(log_level)
+
+    credentials = APICredentials(username=username, password=password)
+    config = UploaderConfig(
+        clics_base_url=base_url.rstrip("/"),
+        contest_id=contest_id,
+        clics_credentials=credentials,
+        xcpcio_api_url=xcpcio_api_url,
+        xcpcio_api_token=xcpcio_api_token,
+        cache_dir=cache_dir,
+        timeout=timeout,
+        max_concurrent=max_concurrent,
+        poll_interval=interval,
+        version=__version__,
+    )
+
+    click.echo(f"Fetching contest '{contest_id}' from {base_url}")
+    click.echo(f"Uploading to XCPCIO: {xcpcio_api_url}")
+
+    async def run():
+        async with ContestUploader(config) as uploader:
+            await uploader.run_loop()
+
+    try:
+        asyncio.run(run())
+    except KeyboardInterrupt:
+        click.echo(click.style("\nClics Uploader stopped by user", fg="yellow"), err=True)
+        raise click.Abort()
+    except Exception as e:
+        click.echo(click.style(f"Error: {e}", fg="red"), err=True)
+        raise click.ClickException(str(e))
+
+
+if __name__ == "__main__":
+    main()

xcpcio/clics/clics_api_client.py

@@ -168,6 +168,42 @@ class ClicsApiClient:
                 logger.error(f"Failed to download {file_url} after retries: {e}")
                 return False
 
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=1, max=10),
+        retry=retry_if_exception_type((asyncio.TimeoutError, aiohttp.ClientError)),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+        reraise=True,
+    )
+    async def _fetch_file_content_internal(self, file_url: str, override_timeout: Optional[int] = None) -> bytes:
+        """Internal method to fetch file content as bytes with retry logic"""
+        logger.info(f"Fetching file content from {file_url}")
+        timeout = aiohttp.ClientTimeout(total=override_timeout or self._config.timeout)
+        async with self._session.get(file_url, timeout=timeout) as response:
+            if response.status != 200:
+                raise aiohttp.ClientResponseError(
+                    request_info=response.request_info, history=response.history, status=response.status
+                )
+
+            content = await response.read()
+            logger.debug(f"Fetched {len(content)} bytes from {file_url}")
+            return content
+
+    async def fetch_file_content(self, file_url: Optional[str], override_timeout: Optional[int] = None) -> Optional[bytes]:
+        """Fetch file content as bytes from URL"""
+        if not file_url:
+            return None
+
+        if not file_url.startswith(("http://", "https://")):
+            file_url = self._build_url(file_url)
+
+        async with self._semaphore:
+            try:
+                return await self._fetch_file_content_internal(file_url, override_timeout)
+            except Exception as e:
+                logger.error(f"Failed to fetch file content from {file_url} after retries: {e}")
+                return None
+
     async def fetch_api_info(self) -> Optional[Dict[str, Any]]:
         """Fetch API root endpoint information and parse provider details"""
         data = await self.fetch_json("/")

xcpcio/clics/contest_archiver.py

@@ -91,6 +91,7 @@ class ContestArchiver:
         "runs",
         "clarifications",
         "awards",
+        "scoreboard",
     ]
 
     def __init__(self, config: ArchiveConfig):

xcpcio/clics/contest_uploader.py

@@ -0,0 +1,304 @@
+import asyncio
+import hashlib
+import json
+import logging
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional
+
+from pydantic import BaseModel
+
+from xcpcio.api.client import ApiClient
+from xcpcio.api.models import FileData, UploadBoardDataResp
+from xcpcio.clics.clics_api_client import APICredentials, ClicsApiClient, ClicsApiConfig
+
+logger = logging.getLogger(__name__)
+
+
+class FileChecksumEntry(BaseModel):
+    checksum: str
+    updated_at: str
+
+
+class FileChecksumCacheData(BaseModel):
+    checksums: Dict[str, FileChecksumEntry]
+    updated_at: str
+
+
+class FileChecksumCache:
+    def __init__(
+        self, cache_dir: Optional[Path] = None, contest_id: Optional[str] = None, version: Optional[str] = None
+    ):
+        if cache_dir:
+            cache_dir = Path(cache_dir)
+        else:
+            cache_dir = Path.home() / ".xcpcio"
+
+        cache_dir.mkdir(parents=True, exist_ok=True)
+
+        if contest_id:
+            self.cache_file = cache_dir / f"clics_uploader_{contest_id}.json"
+        else:
+            self.cache_file = cache_dir / "clics_uploader_cache.json"
+
+        self.version_file = cache_dir / "version"
+        self.version = version
+        self.checksums: Dict[str, FileChecksumEntry] = {}
+        self._load_cache()
+
+    def _load_version(self) -> Optional[str]:
+        if self.version_file.exists():
+            try:
+                with open(self.version_file, "r") as f:
+                    return f.read().strip()
+            except Exception as e:
+                logger.warning(f"Failed to read version file: {e}")
+        return None
+
+    def _save_version(self):
+        if not self.version:
+            return
+        try:
+            with open(self.version_file, "w") as f:
+                f.write(self.version)
+        except Exception as e:
+            logger.warning(f"Failed to save version file: {e}")
+
+    def _load_cache(self):
+        cached_version = self._load_version()
+        if cached_version != self.version:
+            logger.info(f"Cache version mismatch (cached: {cached_version}, current: {self.version}), clearing cache")
+            self.checksums = {}
+            return
+
+        if self.cache_file.exists():
+            try:
+                with open(self.cache_file, "r") as f:
+                    data = json.load(f)
+
+                cache_data = FileChecksumCacheData.model_validate(data)
+                self.checksums = cache_data.checksums
+                logger.debug(f"Loaded cache with {len(self.checksums)} entries")
+            except Exception as e:
+                logger.warning(f"Failed to load cache: {e}")
+                self.checksums = {}
+
+    def _save_cache(self):
+        try:
+            self.cache_file.parent.mkdir(parents=True, exist_ok=True)
+            cache_data = FileChecksumCacheData(
+                checksums=self.checksums,
+                updated_at=datetime.now().isoformat(),
+            )
+            with open(self.cache_file, "w") as f:
+                json.dump(cache_data.model_dump(), f, indent=2)
+            self._save_version()
+            logger.debug(f"Saved cache with {len(self.checksums)} entries")
+        except Exception as e:
+            logger.warning(f"Failed to save cache: {e}")
+
+    def calculate_checksum(self, content: str) -> str:
+        return hashlib.sha256(content.encode("utf-8")).hexdigest()
+
+    def has_changed(self, key: str, content: str) -> bool:
+        checksum = self.calculate_checksum(content)
+        old_entry = self.checksums.get(key)
+        return not old_entry or old_entry.checksum != checksum
+
+    def update_checksum(self, key: str, content: str):
+        checksum = self.calculate_checksum(content)
+        self.checksums[key] = FileChecksumEntry(
+            checksum=checksum,
+            updated_at=datetime.now().isoformat(),
+        )
+
+    def save(self):
+        self._save_cache()
+
+
+@dataclass
+class UploaderConfig:
+    clics_base_url: str
+    contest_id: str
+    clics_credentials: APICredentials
+    xcpcio_api_url: str
+    xcpcio_api_token: str
+    cache_dir: Optional[Path] = None
+    timeout: int = 30
+    max_concurrent: int = 10
+    poll_interval: int = 5
+    version: Optional[str] = None
+
+    def to_clics_api_config(self) -> ClicsApiConfig:
+        return ClicsApiConfig(
+            base_url=self.clics_base_url,
+            credentials=self.clics_credentials,
+            timeout=self.timeout,
+            max_concurrent=self.max_concurrent,
+        )
+
+
+class ContestUploader:
+    ENDPOINTS_TO_FETCH = (
+        "access",
+        "accounts",
+        "awards",
+        "groups",
+        "judgement-types",
+        "judgements",
+        "languages",
+        "organizations",
+        "problems",
+        "state",
+        "submissions",
+        "teams",
+    )
+
+    def __init__(self, config: UploaderConfig):
+        self._config = config
+        self._clics_client = ClicsApiClient(config.to_clics_api_config())
+        self._api_client = ApiClient(
+            base_url=config.xcpcio_api_url,
+            token=config.xcpcio_api_token,
+            timeout=config.timeout,
+        )
+        self._cache = FileChecksumCache(
+            cache_dir=config.cache_dir,
+            contest_id=config.contest_id,
+            version=config.version,
+        )
+
+    async def __aenter__(self):
+        await self._clics_client.__aenter__()
+        await self._api_client.__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self._clics_client.__aexit__(exc_type, exc_val, exc_tb)
+        await self._api_client.__aexit__(exc_type, exc_val, exc_tb)
+
+    def _process_file_validations(
+        self, file_map: Dict[str, FileData], file_keys: list[str], response: UploadBoardDataResp
+    ):
+        for file_key in file_keys:
+            if file_key in file_map:
+                validation = response.file_validations.get(file_key)
+                if validation:
+                    if validation.checksum_valid:
+                        self._cache.update_checksum(file_key, file_map[file_key].content)
+                    else:
+                        logger.warning(f"File checksum validation failed for {file_key}: {validation.message}")
+                else:
+                    logger.warning(f"No validation result for {file_key}, will retry on next poll")
+
+    async def _fetch_api_data(
+        self,
+        api_files: Dict[str, FileData],
+        changed_api_files: list[str],
+        unchanged_files: list[str],
+    ):
+        api_data = await self._clics_client.fetch_api_info()
+        if api_data:
+            filename = "api.json"
+            content = json.dumps(api_data, ensure_ascii=False)
+
+            if self._cache.has_changed(filename, content):
+                checksum = self._cache.calculate_checksum(content)
+                api_files[filename] = FileData(content=content, checksum=checksum)
+                changed_api_files.append(filename)
+            else:
+                unchanged_files.append(filename)
+
+    async def _fetch_contest_data(
+        self,
+    ) -> tuple[Dict[str, FileData], list[str], list[str]]:
+        api_files = {}
+        changed_api_files = []
+        unchanged_files = []
+
+        contest_data = await self._clics_client.fetch_json(f"contests/{self._config.contest_id}")
+        if contest_data:
+            filename = "contest.json"
+            content = json.dumps(contest_data, ensure_ascii=False)
+
+            if self._cache.has_changed(filename, content):
+                checksum = self._cache.calculate_checksum(content)
+                api_files[filename] = FileData(content=content, checksum=checksum)
+                changed_api_files.append(filename)
+            else:
+                unchanged_files.append(filename)
+
+        return api_files, changed_api_files, unchanged_files
+
+    async def _fetch_endpoint_data(
+        self,
+        api_files: Dict[str, FileData],
+        changed_api_files: list[str],
+        unchanged_files: list[str],
+    ):
+        for endpoint in self.ENDPOINTS_TO_FETCH:
+            data = await self._clics_client.fetch_json(f"contests/{self._config.contest_id}/{endpoint}")
+            if data is not None:
+                filename = f"{endpoint}.json"
+                content = json.dumps(data, ensure_ascii=False)
+
+                if self._cache.has_changed(filename, content):
+                    checksum = self._cache.calculate_checksum(content)
+                    api_files[filename] = FileData(content=content, checksum=checksum)
+                    changed_api_files.append(filename)
+                else:
+                    unchanged_files.append(filename)
+
+    async def _upload_api_files(
+        self, api_files: Dict[str, FileData], changed_api_files: list[str]
+    ) -> Optional[UploadBoardDataResp]:
+        if not api_files:
+            return None
+
+        logger.info(f"Uploading {len(api_files)} API file(s) to XCPCIO...")
+        response = await self._api_client.upload_board_data(extra_files=api_files)
+        logger.info(f"API upload successful! ({len(api_files)} files)")
+
+        self._process_file_validations(api_files, changed_api_files, response)
+        self._cache.save()
+        return response
+
+    async def fetch_and_upload(self) -> Optional[Dict]:
+        api_files, changed_api_files, unchanged_files = ({}, [], [])
+
+        await self._fetch_api_data(api_files, changed_api_files, unchanged_files)
+
+        contest_files, contest_changed, contest_unchanged = await self._fetch_contest_data()
+        api_files.update(contest_files)
+        changed_api_files.extend(contest_changed)
+        unchanged_files.extend(contest_unchanged)
+
+        await self._fetch_endpoint_data(api_files, changed_api_files, unchanged_files)
+
+        if changed_api_files:
+            logger.info(f"Changed API files ({len(changed_api_files)}): {', '.join(changed_api_files)}")
+        if unchanged_files:
+            logger.debug(f"Unchanged files ({len(unchanged_files)}): {', '.join(unchanged_files)}")
+
+        if not api_files:
+            logger.info("No changed files to upload")
+            return None
+
+        response = await self._upload_api_files(api_files, changed_api_files)
+
+        logger.info(f"All uploads completed! ({len(api_files)} files)")
+        return response.model_dump() if response else None
+
+    async def run_loop(self):
+        iteration = 0
+        while True:
+            iteration += 1
+            try:
+                logger.info(f"[Iteration #{iteration}] Starting fetch and upload...")
+                await self.fetch_and_upload()
+            except Exception as e:
+                logger.exception(f"Error during fetch and upload: {e}", exc_info=True)
+
+            logger.info(f"Waiting {self._config.poll_interval} seconds until next poll...")
+            await asyncio.sleep(self._config.poll_interval)

xcpcio/clics/reader/contest_package_reader.py

@@ -27,17 +27,26 @@ class ContestPackageReader(BaseContestReader):
             res[item[id_name]].append(item)
         return res
 
-    def _load_json_file(self, filepath: str) -> Union[Dict[str, Any], List[Any]]:
+    def _load_json_file(
+        self,
+        filepath: str,
+        default_value: Optional[Union[Dict[str, Any], List[Any]]] = None,
+    ) -> Union[Dict[str, Any], List[Any]]:
         full_path = self.contest_package_dir / filepath
         try:
             with open(full_path, "r", encoding="utf-8") as f:
                 return json.load(f)
         except FileNotFoundError:
+            if default_value is not None:
+                logger.warning(f"File not found, will load default value. [full_path={full_path}]")
+                return default_value
             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 _load_ndjson_file(self, filepath: str) -> List[Dict[str, Any]]:
+    def _load_ndjson_file(
+        self, filepath: str, default_value: Optional[List[Dict[str, Any]]] = None
+    ) -> List[Dict[str, Any]]:
         full_path = self.contest_package_dir / filepath
         try:
             data = list()
@@ -46,60 +55,63 @@ class ContestPackageReader(BaseContestReader):
                     data.append(json.loads(line))
             return data
         except FileNotFoundError:
+            if default_value is not None:
+                logger.warning(f"File not found, will load default value. [full_path={full_path}]")
+                return default_value
             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 _load_indexes(self) -> None:
-        self.access = self._load_json_file("access.json")
+        self.access = self._load_json_file("access.json", default_value={})
 
-        self.accounts = self._load_json_file("accounts.json")
+        self.accounts = self._load_json_file("accounts.json", default_value=[])
         self.accounts_by_id = {account["id"]: account for account in self.accounts}
 
-        self.api_info = self._load_json_file("api.json")
+        self.api_info = self._load_json_file("api.json", default_value={})
 
-        self.awards = self._load_json_file("awards.json")
+        self.awards = self._load_json_file("awards.json", default_value=[])
         self.awards_by_id = {award["id"]: award for award in self.awards}
 
-        self.clarifications = self._load_json_file("clarifications.json")
+        self.clarifications = self._load_json_file("clarifications.json", default_value=[])
         self.clarifications_by_id = {clarification["id"]: clarification for clarification in self.clarifications}
 
-        self.contest = self._load_json_file("contest.json")
-        self.contest_state = self._load_json_file("state.json")
+        self.contest = self._load_json_file("contest.json", default_value={})
+        self.contest_state = self._load_json_file("state.json", default_value={})
 
-        self.groups = self._load_json_file("groups.json")
+        self.groups = self._load_json_file("groups.json", default_value=[])
         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 = self._load_json_file("judgement-types.json", default_value=[])
         self.judgement_types_by_id = {judgement_type["id"]: judgement_type for judgement_type in self.judgement_types}
 
-        self.judgements = self._load_json_file("judgements.json")
+        self.judgements = self._load_json_file("judgements.json", default_value=[])
         self.judgements_by_id = {judgement["id"]: judgement 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 = self._load_json_file("languages.json", default_value=[])
         self.languages_by_id = {language["id"]: language for language in self.languages}
 
-        self.organizations = self._load_json_file("organizations.json")
+        self.organizations = self._load_json_file("organizations.json", default_value=[])
         self.organizations_by_id = {org["id"]: org for org in self.organizations}
 
-        self.problems = self._load_json_file("problems.json")
+        self.problems = self._load_json_file("problems.json", default_value=[])
         self.problems_by_id = {problem["id"]: problem for problem in self.problems}
 
-        self.runs = self._load_json_file("runs.json")
+        self.runs = self._load_json_file("runs.json", default_value=[])
         self.runs_by_id = {run["id"]: run for run in self.runs}
         self.runs_by_judgement_id = self._create_index_by_id(self.runs, "judgement_id")
 
-        self.submissions = self._load_json_file("submissions.json")
+        self.submissions = self._load_json_file("submissions.json", default_value=[])
         self.submissions_by_id = {submission["id"]: submission for submission in self.submissions}
 
-        self.teams = self._load_json_file("teams.json")
+        self.teams = self._load_json_file("teams.json", default_value=[])
         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 = self._load_ndjson_file("event-feed.ndjson", default_value=[])
         self.event_feed_tokens = [event["token"] for event in self.event_feed]
 
-        self.contest_id = self.contest["id"]
+        self.contest_id = self.contest.get("id", "")
 
     def _get_file_attr(self, expected_href: str, base_path: Path, files: List[Dict]) -> FileAttr:
         for file in files:

xcpcio/types.py

@@ -63,6 +63,7 @@ MedalPreset = Literal["ccpc", "icpc"]
 BannerMode = Literal["ONLY_BANNER", "ALL"]
 Lang = Literal["en", "zh-CN"]
 DateTimeISO8601String = str
+UrlString = str
 
 
 class I18NStringSet(BaseModel):
@@ -87,6 +88,21 @@ class Image(BaseModel):
     height: Optional[int] = None
 
 
+class DataItem(BaseModel):
+    url: UrlString
+    version: Optional[str] = None
+
+
+class Organization(BaseModel):
+    id: str
+    name: Text
+
+    logo: Optional[Image] = None
+
+
+Organizations = List[Organization]
+
+
 class BalloonColor(BaseModel):
     color: str
     background_color: str
@@ -146,6 +162,8 @@ class Team(BaseModel):
     name: Text = ""
 
     organization: str = ""
+    organization_id: Optional[str] = None
+
     group: List[str] = Field(default_factory=list)
     tag: Optional[List[str]] = None
 
@@ -219,7 +237,9 @@ class Contest(BaseModel):
 
     options: Optional[ContestOptions] = None
 
-    unfrozen_time: int = Field(default=0x3F3F3F3F3F3F3F3F, exclude=True)
+    organizations: Optional[Union[DataItem, Organizations]] = None
+
+    thaw_time: int = Field(default=0x3F3F3F3F3F3F3F3F, exclude=True)
 
     def append_balloon_color(self, color: BalloonColor):
         if self.balloon_color is None:

{xcpcio-0.67.0.dist-info → xcpcio-0.74.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xcpcio
-Version: 0.67.0
+Version: 0.74.0
 Summary: xcpcio python lib
 Project-URL: homepage, https://github.com/xcpcio/xcpcio
 Project-URL: documentation, https://github.com/xcpcio/xcpcio
@@ -79,7 +79,7 @@ uv run pytest tests/test_types.py
 
 For detailed documentation, visit:
 
-- [CCS Utility Guide](https://xcpcio.com/guide/ccs-utility)
+- [Clics Utility Guide](https://xcpcio.com/guide/clics-utility)
 
 ## License
 

{xcpcio-0.67.0.dist-info → xcpcio-0.74.0.dist-info}/RECORD

@@ -1,15 +1,17 @@
 xcpcio/__init__.py,sha256=NB6wpVr5JUrOx2vLIQSVtYuCz0d7kNFE39TSQlvoENk,125
-xcpcio/__version__.py,sha256=5CKkAAFaIZS44pisp_qVWM6m0g3YZRokot4QAn8lQfk,172
+xcpcio/__version__.py,sha256=bqW3xNfcKZLCjzET76nCOrvRVs1ULNTmgQNmTC__WlI,172
 xcpcio/constants.py,sha256=MjpAgNXiBlUsx1S09m7JNT-nekNDR-aE6ggvGL3fg0I,2297
-xcpcio/types.py,sha256=GElkg8wz2BloN6PzyjvLrrd2h7Lm5itaaNnZv3hVQ-U,7591
-xcpcio/api/__init__.py,sha256=B9gLdAlR3FD7070cvAC5wAwMy3iV63I8hh4mUrnrKpk,274
-xcpcio/api/client.py,sha256=BuzH8DbJYudJ-Kne-2XziLW__B_7iEqElJ4n2SGZCoY,2374
-xcpcio/api/models.py,sha256=_dChApnIHVNN3hEL7mR5zonq8IUcxW_h7z1kUz6reSs,772
+xcpcio/types.py,sha256=CLhRp_HaVbK9YK8yNOHDNDIis8XOAo5BWz5lZS-qbvw,7927
+xcpcio/api/__init__.py,sha256=fFRUU0d_cUG-uzG2rLgirqRng8Z3UoV5ZCkBiYuXdu0,302
+xcpcio/api/client.py,sha256=TEcf3tjLu537HHhyBBVHlQ3fFL7_abjG3IrQtp39oks,2389
+xcpcio/api/models.py,sha256=DBS9TjtPSX32TpwO3gYnnGo7RFHLHrxYpRIAhxCHmLs,1258
 xcpcio/app/clics_archiver.py,sha256=wd7zkbq2oyWfkS09w0f3KBr32F2yCcTMx36H5HFMgRg,7995
 xcpcio/app/clics_server.py,sha256=-zUixNf08yICT2sry23h72ZrEm6NPb30bH5AHCXZlBM,4623
+xcpcio/app/clics_uploader.py,sha256=Hw2buDX7lO8kghcxmLLv3P-F4uO73BDBPctmVTb7GEw,3592
 xcpcio/clics/__init__.py,sha256=coTZiqxzXesn2SYmI2ZCsDZW6XaFi_6p-PFozZ4dfl4,150
-xcpcio/clics/clics_api_client.py,sha256=jQiOYPNZlYs_cOmQIbp-QovWVMYcmT1yo-33SWoyAn0,7966
-xcpcio/clics/contest_archiver.py,sha256=66a4YTqHqSoHMe7dFTXo4OrdK40AUnavo0ICSd9UNGo,9911
+xcpcio/clics/clics_api_client.py,sha256=N6mYlou6eTrQYiUKxE4fdwCClCt9DrmVyKQmpc53iaY,9670
+xcpcio/clics/contest_archiver.py,sha256=9q3qB4hOPfd4ttaG78cQ7sg7vWkumO_KUZpqwYlHDlM,9933
+xcpcio/clics/contest_uploader.py,sha256=eGvPnFkxpCGVl43hoi2_6fBXR3c4jj3Td-R4i9wHt1M,10849
 xcpcio/clics/api_server/__init__.py,sha256=ASvVJ_ibGkXFDSNmy05eb9gESXRS8hjYHCrBecSnaS0,174
 xcpcio/clics/api_server/app.py,sha256=dYvkxaR8PjkDIHbSX8YyU3TvPud93Dg29k6midylakE,979
 xcpcio/clics/api_server/dependencies.py,sha256=2Zhom6vUnAOikr9bh-_kXYCc3g6JGXReVuQX7Ok90r4,1444
@@ -38,9 +40,9 @@ xcpcio/clics/model/__init__.py,sha256=cZE1q5JY-iHDEKZpsx0UZaMhH-23H4oAHaYOkW7dZ5
 xcpcio/clics/model/model_2023_06/__init__.py,sha256=VzBaFcAwYw9G18p0Lh7rNPrvchyaYx_jgw6YE4W1yNg,168
 xcpcio/clics/model/model_2023_06/model.py,sha256=bVMDWpJTwPSpz1fHPxWrWerxCBIboH3LKVZpIZGQ2pY,15287
 xcpcio/clics/reader/__init__.py,sha256=Nfi78X8J1tJPh7WeSRPLMRUprlS2JYelYJHW4DfyJ7U,162
-xcpcio/clics/reader/contest_package_reader.py,sha256=xalN6sR8qTjwiBtass9De9FlQqprctvZsiTpVphRtCc,14252
+xcpcio/clics/reader/contest_package_reader.py,sha256=W9pNAl6Za1LXG_OjDYj-szVPXczeHBUhL-ajOApL7BU,15089
 xcpcio/clics/reader/interface.py,sha256=lK2JXU1n8GJ4PecXnfFBijMaCVLYk404e4QwV_Ti2Hk,3918
-xcpcio-0.67.0.dist-info/METADATA,sha256=Ps4CzUOSNLn-DULqV4DwDdIzUMBu7-B-FQytB1lpfDo,2233
-xcpcio-0.67.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xcpcio-0.67.0.dist-info/entry_points.txt,sha256=JYkvmmxKFWv0EBU6Ys65XsjkOO02KGlzASau0GX9TQ8,110
-xcpcio-0.67.0.dist-info/RECORD,,
+xcpcio-0.74.0.dist-info/METADATA,sha256=OTxJWftLDzlvdKzbx0TAISCLxyxoUs0RcF0a1s5g3js,2237
+xcpcio-0.74.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xcpcio-0.74.0.dist-info/entry_points.txt,sha256=KxviS5TVXlZ9KqS9UNMx3nI15xhEGvkTq86RaPhUhs4,158
+xcpcio-0.74.0.dist-info/RECORD,,

{xcpcio-0.67.0.dist-info → xcpcio-0.74.0.dist-info}/entry_points.txt

@@ -1,3 +1,4 @@
 [console_scripts]
 clics-archiver = xcpcio.app.clics_archiver:main
 clics-server = xcpcio.app.clics_server:main
+clics-uploader = xcpcio.app.clics_uploader:main