xcpcio 0.63.7__tar.gz → 0.64.1__tar.gz

xcpcio-0.64.1/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: xcpcio
+Version: 0.64.1
+Summary: xcpcio python lib
+Project-URL: homepage, https://github.com/xcpcio/xcpcio
+Project-URL: documentation, https://github.com/xcpcio/xcpcio
+Project-URL: repository, https://github.com/xcpcio/xcpcio
+Author-email: Dup4 <hi@dup4.com>
+Maintainer-email: Dup4 <hi@dup4.com>, cubercsl <hi@cubercsl.site>
+License-Expression: MIT
+Keywords: xcpcio
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: aiofiles>=23.0.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: fastapi>=0.117.1
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: semver>=3.0.0
+Requires-Dist: tenacity>=8.0.0
+Requires-Dist: uvicorn>=0.36.0
+Requires-Dist: zstandard>=0.25.0
+Description-Content-Type: text/markdown
+
+# xcpcio-python
+
+Python library and CLI tools for XCPCIO.
+
+## Features
+
+- **Type Definitions**: Pydantic models for contest data structures (teams, submissions, problems, etc.)
+- **Constants**: Shared constants for submission statuses, time units, and penalty calculations
+- **CCS Archiver**: CLI tool to archive CCS API data to contest package format
+- **Contest API Server**: CLI tool to serve contest packages via CCS API
+- **Cross-Language Compatibility**: Mirrors TypeScript types for data consistency
+
+## Installation
+
+```bash
+pip install xcpcio
+```
+
+Or install with [uv](https://github.com/astral-sh/uv):
+
+```bash
+uv add xcpcio
+```
+
+## Development
+
+### Setup
+
+```bash
+# Clone repository
+git clone https://github.com/xcpcio/xcpcio.git
+cd xcpcio/python
+
+# Install dependencies with uv
+uv sync
+```
+
+### Testing
+
+```bash
+# Run tests
+uv run pytest
+
+# Run specific test file
+uv run pytest tests/test_types.py
+```
+
+## Documentation
+
+For detailed documentation, visit:
+
+- [CCS Utility Guide](https://xcpcio.com/guide/ccs-utility)
+
+## License
+
+MIT License &copy; 2020-PRESENT [Dup4](https://github.com/Dup4)

xcpcio-0.64.1/README.md

@@ -0,0 +1,56 @@
+# xcpcio-python
+
+Python library and CLI tools for XCPCIO.
+
+## Features
+
+- **Type Definitions**: Pydantic models for contest data structures (teams, submissions, problems, etc.)
+- **Constants**: Shared constants for submission statuses, time units, and penalty calculations
+- **CCS Archiver**: CLI tool to archive CCS API data to contest package format
+- **Contest API Server**: CLI tool to serve contest packages via CCS API
+- **Cross-Language Compatibility**: Mirrors TypeScript types for data consistency
+
+## Installation
+
+```bash
+pip install xcpcio
+```
+
+Or install with [uv](https://github.com/astral-sh/uv):
+
+```bash
+uv add xcpcio
+```
+
+## Development
+
+### Setup
+
+```bash
+# Clone repository
+git clone https://github.com/xcpcio/xcpcio.git
+cd xcpcio/python
+
+# Install dependencies with uv
+uv sync
+```
+
+### Testing
+
+```bash
+# Run tests
+uv run pytest
+
+# Run specific test file
+uv run pytest tests/test_types.py
+```
+
+## Documentation
+
+For detailed documentation, visit:
+
+- [CCS Utility Guide](https://xcpcio.com/guide/ccs-utility)
+
+## License
+
+MIT License © 2020-PRESENT [Dup4](https://github.com/Dup4)

xcpcio-0.64.1/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.1/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.7 → xcpcio-0.64.1}/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.7 → xcpcio-0.64.1}/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.7 → xcpcio-0.64.1}/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.7'
+__version__ = VERSION = '0.64.1'

{xcpcio-0.63.7 → xcpcio-0.64.1}/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.7 → xcpcio-0.64.1}/xcpcio/ccs/api_server/routes/contests.py

@@ -1,9 +1,8 @@
 import json
 import logging
-from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from fastapi import APIRouter, HTTPException, Query
+from fastapi import APIRouter, Query
 from fastapi import Path as FastAPIPath
 from fastapi.responses import FileResponse, StreamingResponse
 
@@ -55,22 +54,8 @@ async def get_contest_banner(
     contest_id: str = FastAPIPath(..., description="Contest identifier"),
     service: ContestServiceDep = None,
 ) -> FileResponse:
-    service.validate_contest_id(contest_id)
-
-    expected_href = f"contests/{contest_id}/banner"
-
-    try:
-        banners = service.contest.get("banner", [])
-        for banner in banners:
-            href = banner["href"]
-            if href == expected_href:
-                filename = banner["filename"]
-                banner_file: Path = service.contest_package_dir / "contest" / filename
-                if banner_file.exists():
-                    mime_type = banner["mime"]
-                    return FileResponse(path=banner_file, media_type=mime_type, filename=filename)
-    except Exception as e:
-        raise HTTPException(status_code=404, detail=f"Banner not found. [contest_id={contest_id}] [err={e}]")
+    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(
@@ -82,22 +67,8 @@ async def get_contest_problem_set(
     contest_id: str = FastAPIPath(..., description="Contest identifier"),
     service: ContestServiceDep = None,
 ) -> FileResponse:
-    service.validate_contest_id(contest_id)
-
-    expected_href = f"contests/{contest_id}/problemset"
-
-    try:
-        problem_set_list = service.contest.get("problemset", [])
-        for problem_set in problem_set_list:
-            href = problem_set["href"]
-            if href == expected_href:
-                filename = problem_set["filename"]
-                problem_set_file: Path = service.contest_package_dir / "contest" / filename
-                if problem_set_file.exists():
-                    mime_type = problem_set["mime"]
-                    return FileResponse(path=problem_set_file, media_type=mime_type, filename=filename)
-    except Exception as e:
-        raise HTTPException(status_code=404, detail=f"Problem set not found. [contest_id={contest_id}] [err={e}]")
+    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(

{xcpcio-0.63.7 → xcpcio-0.64.1}/xcpcio/ccs/api_server/routes/organizations.py

@@ -1,8 +1,7 @@
 import logging
-from pathlib import Path
 from typing import Any, Dict, List
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter
 from fastapi import Path as FastAPIPath
 from fastapi.responses import FileResponse
 
@@ -47,25 +46,5 @@ async def get_organization_logo(
     organization_id: str = FastAPIPath(..., description="Organization identifier"),
     service: ContestServiceDep = None,
 ) -> FileResponse:
-    service.validate_contest_id(contest_id)
-
-    org = service.organizations_by_id.get(organization_id)
-    if not org:
-        raise HTTPException(status_code=404, detail=f"Organization {organization_id} not found")
-
-    expected_href = f"contests/{contest_id}/organizations/{organization_id}/logo"
-
-    try:
-        logos = org["logo"]
-        for logo in logos:
-            href = logo["href"]
-            if href == expected_href:
-                filename = logo["filename"]
-                logo_file: Path = service.contest_package_dir / "organizations" / organization_id / filename
-                if logo_file.exists():
-                    mime_type = logo["mime"]
-                    return FileResponse(path=logo_file, media_type=mime_type, filename=filename)
-    except Exception as e:
-        raise HTTPException(
-            status_code=404, detail=f"Logo file not found. [organization_id={organization_id}] [err={e}]"
-        )
+    file_attr = service.get_organization_logo(contest_id, organization_id)
+    return FileResponse(path=file_attr.path, media_type=file_attr.media_type, filename=file_attr.name)