xcpcio 0.63.6__tar.gz → 0.64.0__tar.gz

{xcpcio-0.63.6 → xcpcio-0.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xcpcio
-Version: 0.63.6
+Version: 0.64.0
 Summary: xcpcio python lib
 Project-URL: homepage, https://github.com/xcpcio/xcpcio
 Project-URL: documentation, https://github.com/xcpcio/xcpcio
@@ -25,6 +25,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
+Requires-Dist: zstandard>=0.25.0
 Description-Content-Type: text/markdown
 
 # xcpcio-python

xcpcio-0.64.0/app/contest_api_server.py

@@ -0,0 +1,140 @@
+import atexit
+import logging
+import shutil
+import tarfile
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Optional
+
+import click
+import zstandard as zstd
+
+from xcpcio import __version__
+from xcpcio.ccs.api_server.server import ContestAPIServer
+
+
+def setup_logging(level: str = "INFO"):
+    """Setup logging configuration"""
+    logging.basicConfig(
+        level=getattr(logging, level.upper()),
+        format="%(asctime)s [%(name)s] %(filename)s:%(lineno)d %(levelname)s: %(message)s",
+    )
+
+
+def extract_archive(archive_path: Path, dest_dir: Path) -> None:
+    """Extract archive to destination directory"""
+    archive_str = str(archive_path)
+
+    if archive_str.endswith(".zip"):
+        with zipfile.ZipFile(archive_path, "r") as zipf:
+            zipf.extractall(dest_dir)
+    elif archive_str.endswith(".tar.gz"):
+        with tarfile.open(archive_path, "r:gz") as tarf:
+            tarf.extractall(dest_dir, filter="data")
+    elif archive_str.endswith(".tar.zst"):
+        with tempfile.NamedTemporaryFile(suffix=".tar") as tmp_tar:
+            with open(archive_path, "rb") as f:
+                dctx = zstd.ZstdDecompressor()
+                dctx.copy_stream(f, tmp_tar)
+            tmp_tar.seek(0)
+            with tarfile.open(fileobj=tmp_tar, mode="r") as tarf:
+                tarf.extractall(dest_dir, filter="data")
+    else:
+        raise ValueError(f"Unsupported archive format: {archive_path}")
+
+
+@click.command()
+@click.version_option(__version__)
+@click.option(
+    "--contest-package",
+    "-p",
+    required=True,
+    type=click.Path(exists=True, path_type=Path),
+    help="Contest package directory or archive file (.zip, .tar.gz, .tar.zst)",
+)
+@click.option("--host", default="0.0.0.0", help="Host to bind to")
+@click.option("--port", default=8000, type=int, help="Port to bind to")
+@click.option("--reload", is_flag=True, help="Enable auto-reload for development")
+@click.option(
+    "--log-level",
+    default="info",
+    type=click.Choice(["debug", "info", "warning", "error", "critical"], case_sensitive=False),
+    help="Log level",
+)
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose logging (same as --log-level debug)")
+def main(contest_package: Path, host: str, port: int, reload: bool, log_level: str, verbose: bool):
+    """
+    Start the Contest API Server.
+
+    Examples:
+
+        # Start server with contest directory
+        contest-api-server -p /path/to/contest
+
+        # Start server with archive file
+        contest-api-server -p /path/to/contest.zip
+        contest-api-server -p /path/to/contest.tar.gz
+        contest-api-server -p /path/to/contest.tar.zst
+
+        # Custom host and port
+        contest-api-server -p /path/to/contest --host 127.0.0.1 --port 9000
+
+        # Enable reload for development
+        contest-api-server -p /path/to/contest --reload
+    """
+    if verbose:
+        log_level = "debug"
+    setup_logging(log_level.upper())
+
+    temp_dir: Optional[Path] = None
+
+    def cleanup_temp_dir():
+        if temp_dir and temp_dir.exists():
+            click.echo(f"Cleaning up temporary directory: {temp_dir}")
+            shutil.rmtree(temp_dir)
+
+    atexit.register(cleanup_temp_dir)
+
+    actual_contest_dir: Path = contest_package
+    is_archive = str(contest_package).endswith((".zip", ".tar.gz", ".tar.zst"))
+
+    if is_archive:
+        if not contest_package.is_file():
+            click.echo(f"Error: Archive file not found: {contest_package}", err=True)
+            raise click.Abort()
+
+        click.echo(f"Extracting archive: {contest_package}")
+        temp_dir = Path(tempfile.mkdtemp(prefix="ccs_package_"))
+
+        try:
+            extract_archive(contest_package, temp_dir)
+            actual_contest_dir = temp_dir
+            click.echo(f"Archive extracted to: {temp_dir}")
+        except Exception as e:
+            click.echo(f"Error extracting archive: {e}", err=True)
+            raise click.Abort()
+    else:
+        if not contest_package.is_dir():
+            click.echo(f"Error: Contest directory not found: {contest_package}", err=True)
+            raise click.Abort()
+
+    click.echo("Starting Contest API Server...")
+    click.echo(f"Contest directory: {actual_contest_dir}")
+    click.echo(f"Host: {host}")
+    click.echo(f"Port: {port}")
+    click.echo(f"Reload: {reload}")
+    click.echo(f"Log level: {log_level}")
+
+    try:
+        server = ContestAPIServer(actual_contest_dir)
+        server.run(host=host, port=port, reload=reload, log_level=log_level.lower())
+    except KeyboardInterrupt:
+        click.echo("\nServer stopped by user")
+    except Exception as e:
+        click.echo(f"Error starting server: {e}", err=True)
+        raise click.Abort()
+
+
+if __name__ == "__main__":
+    main()

xcpcio-0.64.0/cli/ccs_archiver_cli.py

@@ -0,0 +1,221 @@
+import asyncio
+import atexit
+import hashlib
+import logging
+import shutil
+import tarfile
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Optional
+
+import click
+import zstandard as zstd
+
+from xcpcio import __version__
+from xcpcio.ccs.contest_archiver import APICredentials, ArchiveConfig, ContestArchiver
+
+
+def setup_logging(level: str = "INFO"):
+    """Setup logging configuration"""
+    logging.basicConfig(
+        level=getattr(logging, level.upper()),
+        format="%(asctime)s [%(name)s] %(filename)s:%(lineno)d %(levelname)s: %(message)s",
+    )
+
+
+def calculate_checksums(file_path: Path) -> dict:
+    """Calculate MD5, SHA1, SHA256, SHA512 checksums for a file"""
+    md5 = hashlib.md5()
+    sha1 = hashlib.sha1()
+    sha256 = hashlib.sha256()
+    sha512 = hashlib.sha512()
+
+    with open(file_path, "rb") as f:
+        while chunk := f.read(8192):
+            md5.update(chunk)
+            sha1.update(chunk)
+            sha256.update(chunk)
+            sha512.update(chunk)
+
+    return {
+        "md5": md5.hexdigest(),
+        "sha1": sha1.hexdigest(),
+        "sha256": sha256.hexdigest(),
+        "sha512": sha512.hexdigest(),
+    }
+
+
+@click.command()
+@click.version_option(__version__)
+@click.option("--base-url", required=True, help="Base URL of the CCS API (e.g., https://example.com/api)")
+@click.option("--contest-id", required=True, help="Contest ID to dump")
+@click.option(
+    "--output",
+    "-o",
+    required=True,
+    type=click.Path(path_type=Path),
+    help="Output path: directory, or archive file (.zip, .tar.gz, .tar.zst)",
+)
+@click.option("--username", "-u", help="HTTP Basic Auth username")
+@click.option("--password", "-p", help="HTTP Basic Auth password")
+@click.option("--token", "-t", help="Bearer token for authentication")
+@click.option("--no-files", is_flag=True, help="Skip downloading files")
+@click.option("--no-event-feed", is_flag=True, help="Skip dump event-feed(large aggregated data)")
+@click.option("--endpoints", "-e", multiple=True, help="Specific endpoints to dump (can be used multiple times)")
+@click.option("--timeout", default=30, type=int, help="Request timeout in seconds")
+@click.option("--max-concurrent", default=10, type=int, help="Max concurrent requests")
+@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,
+    output: Path,
+    username: Optional[str],
+    password: Optional[str],
+    token: Optional[str],
+    no_files: bool,
+    no_event_feed: bool,
+    endpoints: tuple,
+    timeout: int,
+    max_concurrent: int,
+    log_level: str,
+    verbose: bool,
+):
+    """
+    Archive CCS Contest API data to contest package format.
+
+    This tool fetches contest data from a CCS API and organizes it into the standard
+    contest package format as specified by the CCS Contest Package specification.
+
+    Examples:
+
+        # Output to directory
+        ccs-archiver --base-url https://api.example.com/api --contest-id contest123 -o ./output -u admin -p secret
+
+        # Output to ZIP archive
+        ccs-archiver --base-url https://api.example.com/api --contest-id contest123 -o contest.zip --token abc123
+
+        # Output to tar.gz archive
+        ccs-archiver --base-url https://api.example.com/api --contest-id contest123 -o contest.tar.gz -u admin -p secret
+
+        # Output to tar.zst archive
+        ccs-archiver --base-url https://api.example.com/api --contest-id contest123 -o contest.tar.zst -u admin -p secret
+
+        # Only archive specific endpoints
+        ccs-archiver --base-url https://api.example.com/api --contest-id contest123 -o ./output -u admin -p secret -e teams -e problems
+
+        # Skip file downloads
+        ccs-archiver --base-url https://api.example.com/api --contest-id contest123 -o ./output --no-files
+    """
+
+    if verbose:
+        log_level = "DEBUG"
+
+    setup_logging(log_level)
+
+    if not (username and password) and not token:
+        click.echo("Warning: No authentication provided. Some endpoints may not be accessible.", err=True)
+
+    output_str = str(output)
+    is_archive = output_str.endswith((".zip", ".tar.gz", ".tar.zst"))
+    archive_format = None
+    temp_dir: Optional[Path] = None
+
+    def cleanup_temp_dir():
+        if temp_dir and temp_dir.exists():
+            click.echo(f"Cleaning up temporary directory: {temp_dir}")
+            shutil.rmtree(temp_dir)
+
+    atexit.register(cleanup_temp_dir)
+
+    if is_archive:
+        if output_str.endswith(".zip"):
+            archive_format = "zip"
+        elif output_str.endswith(".tar.gz"):
+            archive_format = "tar.gz"
+        elif output_str.endswith(".tar.zst"):
+            archive_format = "tar.zst"
+
+    credentials = APICredentials(username=username, password=password, token=token)
+
+    if is_archive:
+        temp_dir = Path(tempfile.mkdtemp(prefix="ccs_archive_"))
+        output_dir = temp_dir
+    else:
+        output_dir = output
+
+    config = ArchiveConfig(
+        base_url=base_url.rstrip("/"),
+        contest_id=contest_id,
+        credentials=credentials,
+        output_dir=output_dir,
+        include_files=not no_files,
+        endpoints=list(endpoints) if endpoints else None,
+        timeout=timeout,
+        max_concurrent=max_concurrent,
+        include_event_feed=not no_event_feed,
+    )
+
+    click.echo(f"Archiving contest '{contest_id}' from {base_url}")
+    if is_archive:
+        click.echo(f"Output archive: {output} (format: {archive_format})")
+    else:
+        click.echo(f"Output directory: {output}")
+    if config.endpoints:
+        click.echo(f"Endpoints: {', '.join(config.endpoints)}")
+
+    async def run_archive():
+        async with ContestArchiver(config) as archiver:
+            await archiver.dump_all()
+
+    try:
+        asyncio.run(run_archive())
+
+        if is_archive:
+            click.echo(f"Creating {archive_format} archive...")
+            output.parent.mkdir(parents=True, exist_ok=True)
+
+            if archive_format == "zip":
+                with zipfile.ZipFile(output, "w", zipfile.ZIP_DEFLATED) as zipf:
+                    for file_path in output_dir.rglob("*"):
+                        if file_path.is_file():
+                            arcname = file_path.relative_to(output_dir)
+                            zipf.write(file_path, arcname)
+
+            elif archive_format == "tar.gz":
+                with tarfile.open(output, "w:gz") as tarf:
+                    tarf.add(output_dir, arcname=".")
+
+            elif archive_format == "tar.zst":
+                with open(output, "wb") as f:
+                    cctx = zstd.ZstdCompressor()
+                    with cctx.stream_writer(f) as compressor:
+                        with tarfile.open(fileobj=compressor, mode="w") as tarf:
+                            tarf.add(output_dir, arcname=".")
+
+            click.echo(click.style(f"Contest package created successfully: {output}", fg="green"))
+            click.echo("\nChecksums:")
+            checksums = calculate_checksums(output)
+            click.echo(f"  MD5:    {checksums['md5']}")
+            click.echo(f"  SHA1:   {checksums['sha1']}")
+            click.echo(f"  SHA256: {checksums['sha256']}")
+            click.echo(f"  SHA512: {checksums['sha512']}")
+        else:
+            click.echo(click.style(f"Contest package created successfully in: {config.output_dir}", fg="green"))
+
+    except KeyboardInterrupt:
+        click.echo(click.style("Archive interrupted by user", fg="yellow"), err=True)
+        raise click.Abort()
+    except Exception as e:
+        click.echo(click.style(f"Error during archive: {e}", fg="red"), err=True)
+        raise click.ClickException(str(e))
+
+
+if __name__ == "__main__":
+    main()

{xcpcio-0.63.6 → xcpcio-0.64.0}/pyproject.toml

@@ -28,6 +28,7 @@ dependencies = [
   "tenacity>=8.0.0",
   "fastapi>=0.117.1",
   "uvicorn>=0.36.0",
+  "zstandard>=0.25.0",
 ]
 dynamic = ["version"]
 

{xcpcio-0.63.6 → xcpcio-0.64.0}/uv.lock

@@ -1408,6 +1408,7 @@ dependencies = [
     { name = "semver" },
     { name = "tenacity" },
     { name = "uvicorn" },
+    { name = "zstandard" },
 ]
 
 [package.dev-dependencies]
@@ -1429,6 +1430,7 @@ requires-dist = [
     { name = "semver", specifier = ">=3.0.0" },
     { name = "tenacity", specifier = ">=8.0.0" },
     { name = "uvicorn", specifier = ">=0.36.0" },
+    { name = "zstandard", specifier = ">=0.25.0" },
 ]
 
 [package.metadata.requires-dev]

{xcpcio-0.63.6 → xcpcio-0.64.0}/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.63.6'
+__version__ = VERSION = '0.64.0'

{xcpcio-0.63.6 → xcpcio-0.64.0}/xcpcio/ccs/api_server/dependencies.py

@@ -5,13 +5,15 @@ Dependency injection system for Contest API Server.
 """
 
 from pathlib import Path
-from typing import Annotated
+from typing import Annotated, Dict
 
 from fastapi import Depends
 
+from xcpcio.ccs.reader.base_ccs_reader import BaseCCSReader
+from xcpcio.ccs.reader.contest_package_reader import ContestPackageReader
+
 from .services.contest_service import ContestService
 
-# Global contest service instance cache
 _contest_service_instance = None
 
 
@@ -41,7 +43,10 @@ def configure_dependencies(contest_package_dir: Path) -> None:
         contest_package_dir: Path to contest package directory
     """
     global _contest_service_instance
-    _contest_service_instance = ContestService(contest_package_dir)
+    reader_dict: Dict[str, BaseCCSReader] = {}
+    contest_package_reader = ContestPackageReader(contest_package_dir)
+    reader_dict[contest_package_reader.get_contest_id()] = contest_package_reader
+    _contest_service_instance = ContestService(reader_dict)
 
 
 # Type alias for dependency injection

{xcpcio-0.63.6 → xcpcio-0.64.0}/xcpcio/ccs/api_server/routes/__init__.py

@@ -8,6 +8,7 @@ from fastapi import APIRouter
 
 from . import (
     access,
+    accounts,
     awards,
     clarifications,
     contests,
@@ -30,6 +31,7 @@ def create_router() -> APIRouter:
 
     # Include all route modules
     router.include_router(access.router, tags=["Access"])
+    router.include_router(accounts.router, tags=["Accounts"])
     router.include_router(awards.router, tags=["Awards"])
     router.include_router(clarifications.router, tags=["Clarifications"])
     router.include_router(contests.router, tags=["Contests"])

{xcpcio-0.63.6 → xcpcio-0.64.0}/xcpcio/ccs/api_server/routes/access.py

@@ -11,10 +11,8 @@ logger = logging.getLogger(__name__)
 
 @router.get(
     "/contests/{contest_id}/access",
-    summary="Get Access Information",
-    description="Get access capabilities and visible endpoints for current client",
+    summary="Get access information",
     response_model=Dict[str, Any],
 )
 async def get_access(contest_id: str, service: ContestServiceDep) -> Dict[str, Any]:
-    """Get access information for the current client"""
-    return service.get_access_info(contest_id)
+    return service.get_access(contest_id)

xcpcio-0.64.0/xcpcio/ccs/api_server/routes/accounts.py

@@ -0,0 +1,35 @@
+import logging
+from typing import Any, Dict, List
+
+from fastapi import APIRouter
+from fastapi import Path as FastAPIPath
+
+from ..dependencies import ContestServiceDep
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+
+@router.get(
+    "/contests/{contest_id}/accounts",
+    summary="Get all the accounts",
+    response_model=List[Dict[str, Any]],
+)
+async def get_accounts(
+    contest_id: str = FastAPIPath(..., description="Contest identifier"),
+    service: ContestServiceDep = None,
+) -> List[Dict[str, Any]]:
+    return service.get_accounts(contest_id)
+
+
+@router.get(
+    "/contests/{contest_id}/accounts/{account_id}",
+    summary="Get the given account",
+    response_model=Dict[str, Any],
+)
+async def get_account(
+    contest_id: str = FastAPIPath(..., description="Contest identifier"),
+    account_id: str = FastAPIPath(..., description="Account identifier"),
+    service: ContestServiceDep = None,
+) -> Dict[str, Any]:
+    return service.get_account(contest_id, account_id)

{xcpcio-0.63.6 → xcpcio-0.64.0}/xcpcio/ccs/api_server/routes/awards.py

@@ -3,7 +3,6 @@ from typing import Any, Dict, List
 
 from fastapi import APIRouter, Path
 
-from ...model import Award, Awards
 from ..dependencies import ContestServiceDep
 
 router = APIRouter()
@@ -12,27 +11,23 @@ logger = logging.getLogger(__name__)
 
 @router.get(
     "/contests/{contest_id}/awards",
-    summary="Get Awards",
-    description="Get all awards in the contest",
-    response_model=Awards,
+    summary="Get all the awards standings for this contest",
+    response_model=List[Dict[str, Any]],
 )
 async def get_awards(
     contest_id: str = Path(..., description="Contest identifier"), service: ContestServiceDep = None
 ) -> List[Dict[str, Any]]:
-    """Get all awards"""
     return service.get_awards(contest_id)
 
 
 @router.get(
     "/contests/{contest_id}/awards/{award_id}",
-    summary="Get Award",
-    description="Get specific award information",
-    response_model=Award,
+    summary="Get the specific award for this contest",
+    response_model=Dict[str, Any],
 )
 async def get_award(
     contest_id: str = Path(..., description="Contest identifier"),
     award_id: str = Path(..., description="Award identifier"),
     service: ContestServiceDep = None,
 ) -> Dict[str, Any]:
-    """Get specific award information"""
     return service.get_award(contest_id, award_id)

xcpcio-0.64.0/xcpcio/ccs/api_server/routes/clarifications.py

@@ -0,0 +1,34 @@
+import logging
+from typing import Any, Dict, List
+
+from fastapi import APIRouter, Path
+
+from ..dependencies import ContestServiceDep
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+
+@router.get(
+    "/contests/{contest_id}/clarifications",
+    summary="Get all the clarifications for this contest",
+    response_model=List[Dict[str, Any]],
+)
+async def get_clarifications(
+    contest_id: str = Path(..., description="Contest identifier"),
+    service: ContestServiceDep = None,
+) -> List[Dict[str, Any]]:
+    return service.get_clarifications(contest_id)
+
+
+@router.get(
+    "/contests/{contest_id}/clarifications/{clarification_id}",
+    summary="Get the given clarifications for this contest",
+    response_model=Dict[str, Any],
+)
+async def get_clarification(
+    contest_id: str = Path(..., description="Contest identifier"),
+    clarification_id: str = Path(..., description="Clarification identifier"),
+    service: ContestServiceDep = None,
+) -> Dict[str, Any]:
+    return service.get_clarification(contest_id, clarification_id)

xcpcio-0.64.0/xcpcio/ccs/api_server/routes/contests.py

@@ -0,0 +1,90 @@
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, Query
+from fastapi import Path as FastAPIPath
+from fastapi.responses import FileResponse, StreamingResponse
+
+from ..dependencies import ContestServiceDep
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+
+@router.get(
+    "/contests",
+    summary="Get all the contests",
+    response_model=List[Dict[str, Any]],
+)
+async def get_contests(service: ContestServiceDep) -> List[Dict[str, Any]]:
+    return service.get_contests()
+
+
+@router.get(
+    "/contests/{contest_id}",
+    summary="Get the given contest",
+    response_model=Dict[str, Any],
+)
+async def get_contest(
+    contest_id: str = FastAPIPath(..., description="Contest identifier"),
+    service: ContestServiceDep = None,
+) -> Dict[str, Any]:
+    return service.get_contest(contest_id)
+
+
+@router.get(
+    "/contests/{contest_id}/state",
+    summary="Get the current contest state",
+    response_model=Dict[str, Any],
+)
+async def get_state(
+    contest_id: str = FastAPIPath(..., description="Contest identifier"),
+    service: ContestServiceDep = None,
+) -> Dict[str, Any]:
+    return service.get_contest_state(contest_id)
+
+
+@router.get(
+    "/contests/{contest_id}/banner",
+    summary="Get the banner for the given contest",
+    response_class=FileResponse,
+)
+async def get_contest_banner(
+    contest_id: str = FastAPIPath(..., description="Contest identifier"),
+    service: ContestServiceDep = None,
+) -> FileResponse:
+    file_attr = service.get_contest_banner(contest_id)
+    return FileResponse(path=file_attr.path, media_type=file_attr.media_type, filename=file_attr.name)
+
+
+@router.get(
+    "/contests/{contest_id}/problemset",
+    summary="Get the problemset document for the given contest",
+    response_class=FileResponse,
+)
+async def get_contest_problem_set(
+    contest_id: str = FastAPIPath(..., description="Contest identifier"),
+    service: ContestServiceDep = None,
+) -> FileResponse:
+    file_attr = service.get_contest_problemset(contest_id)
+    return FileResponse(path=file_attr.path, media_type=file_attr.media_type, filename=file_attr.name)
+
+
+@router.get(
+    "/contests/{contest_id}/event-feed",
+    summary="Get event feed for contest",
+    description="Get events for the contest in NDJSON format. Each line contains a single event object.",
+)
+async def get_event_feed(
+    contest_id: str = FastAPIPath(..., description="Contest identifier"),
+    stream: bool = Query(False, description="Whether to stream the output or stop immediately"),
+    since_token: Optional[str] = Query(None, description="Return events after this token"),
+    service: ContestServiceDep = None,
+) -> StreamingResponse:
+    async def generate():
+        events = service.get_event_feed(contest_id, since_token)
+        for event in events:
+            yield json.dumps(event, ensure_ascii=False, separators=(",", ":")) + "\n"
+
+    return StreamingResponse(generate(), media_type="application/x-ndjson")