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

xcpcio/ccs/api_server/routes/problems.py

@@ -1,12 +1,10 @@
 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
 
-from ...model import Problem, Problems
 from ..dependencies import ContestServiceDep
 
 router = APIRouter()
@@ -15,36 +13,32 @@ logger = logging.getLogger(__name__)
 
 @router.get(
     "/contests/{contest_id}/problems",
-    summary="Get Problems",
-    description="Get all problems in the contest",
-    response_model=Problems,
+    summary="Get all the problems for this contest",
+    response_model=List[Dict[str, Any]],
 )
 async def get_problems(
-    contest_id: str = FastAPIPath(..., description="Contest identifier"), service: ContestServiceDep = None
+    contest_id: str = FastAPIPath(..., description="Contest identifier"),
+    service: ContestServiceDep = None,
 ) -> List[Dict[str, Any]]:
-    """Get all problems in the contest"""
     return service.get_problems(contest_id)
 
 
 @router.get(
     "/contests/{contest_id}/problems/{problem_id}",
-    summary="Get Problem",
-    description="Get specific problem information",
-    response_model=Problem,
+    summary="Get the given problem for this contest",
+    response_model=Dict[str, Any],
 )
 async def get_problem(
     contest_id: str = FastAPIPath(..., description="Contest identifier"),
     problem_id: str = FastAPIPath(..., description="Problem identifier"),
     service: ContestServiceDep = None,
 ) -> Dict[str, Any]:
-    """Get specific problem information"""
     return service.get_problem(contest_id, problem_id)
 
 
 @router.get(
     "/contests/{contest_id}/problems/{problem_id}/statement",
     summary="Get Problem Statement",
-    description="Get problem statement file",
     response_class=FileResponse,
 )
 async def get_problem_statement(
@@ -52,26 +46,5 @@ async def get_problem_statement(
     problem_id: str = FastAPIPath(..., description="Problem identifier"),
     service: ContestServiceDep = None,
 ) -> FileResponse:
-    """Get problem statement file"""
-    service.validate_contest_id(contest_id)
-
-    # Get problem from indexed data
-    problem: Dict = service.problems_by_id.get(problem_id)
-    if not problem:
-        raise HTTPException(status_code=404, detail=f"Problem {problem_id} not found")
-
-    # Expected href pattern for this endpoint
-    expected_href = f"contests/{contest_id}/problems/{problem_id}/statement"
-
-    try:
-        statements = problem.get("statement", [])
-        for statement in statements:
-            href = statement["href"]
-            filename = statement["filename"]
-            if href == expected_href and filename:
-                statement_file: Path = service.contest_package_dir / "problems" / problem_id / filename
-                if statement_file.exists():
-                    mime_type = statement["mime"]
-                    return FileResponse(path=statement_file, media_type=mime_type, filename=filename)
-    except Exception as e:
-        raise HTTPException(status_code=404, detail=f"Statement not found. [problem_id={problem_id}] [err={e}]")
+    file_attr = service.get_problem_statement(contest_id, problem_id)
+    return FileResponse(path=file_attr.path, media_type=file_attr.media_type, filename=file_attr.name)

xcpcio/ccs/api_server/routes/runs.py

@@ -3,7 +3,6 @@ from typing import Any, Dict, List, Optional
 
 from fastapi import APIRouter, Path, Query
 
-from ...model import Run, Runs
 from ..dependencies import ContestServiceDep
 
 router = APIRouter()
@@ -12,29 +11,25 @@ logger = logging.getLogger(__name__)
 
 @router.get(
     "/contests/{contest_id}/runs",
-    summary="Get Runs",
-    description="Get all test case runs, optionally filtered by judgement",
-    response_model=Runs,
+    summary="Get all the runs for this contest",
+    response_model=List[Dict[str, Any]],
 )
 async def get_runs(
     contest_id: str = Path(..., description="Contest identifier"),
     judgement_id: Optional[str] = Query(None, description="Filter runs by judgement ID"),
     service: ContestServiceDep = None,
 ) -> List[Dict[str, Any]]:
-    """Get all test case runs, optionally filtered by judgement"""
     return service.get_runs(contest_id, judgement_id)
 
 
 @router.get(
     "/contests/{contest_id}/runs/{run_id}",
-    summary="Get Run",
-    description="Get specific test case run information",
-    response_model=Run,
+    summary="Get the given run for this contest",
+    response_model=Dict[str, Any],
 )
 async def get_run(
     contest_id: str = Path(..., description="Contest identifier"),
     run_id: str = Path(..., description="Run identifier"),
     service: ContestServiceDep = None,
 ) -> Dict[str, Any]:
-    """Get specific test case run information"""
     return service.get_run(contest_id, run_id)

xcpcio/ccs/api_server/routes/submissions.py

@@ -1,12 +1,10 @@
 import logging
-from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 
-from fastapi import APIRouter, HTTPException, Query
+from fastapi import APIRouter
 from fastapi import Path as FastAPIPath
 from fastapi.responses import FileResponse
 
-from ...model import Submission, Submissions
 from ..dependencies import ContestServiceDep
 
 router = APIRouter()
@@ -15,39 +13,32 @@ logger = logging.getLogger(__name__)
 
 @router.get(
     "/contests/{contest_id}/submissions",
-    summary="Get Submissions",
-    description="Get all submissions, optionally filtered by team or problem",
-    response_model=Submissions,
+    summary="Get all the submissions for this contest",
+    response_model=List[Dict[str, Any]],
 )
 async def get_submissions(
     contest_id: str = FastAPIPath(..., description="Contest identifier"),
-    team_id: Optional[str] = Query(None, description="Filter submissions by team ID"),
-    problem_id: Optional[str] = Query(None, description="Filter submissions by problem ID"),
     service: ContestServiceDep = None,
 ) -> List[Dict[str, Any]]:
-    """Get all submissions, optionally filtered by team or problem"""
-    return service.get_submissions(contest_id, team_id, problem_id)
+    return service.get_submissions(contest_id)
 
 
 @router.get(
     "/contests/{contest_id}/submissions/{submission_id}",
-    summary="Get Submission",
-    description="Get specific submission information",
-    response_model=Submission,
+    summary="Get the given submission for this contest",
+    response_model=Dict[str, Any],
 )
 async def get_submission(
     contest_id: str = FastAPIPath(..., description="Contest identifier"),
     submission_id: str = FastAPIPath(..., description="Submission identifier"),
     service: ContestServiceDep = None,
 ) -> Dict[str, Any]:
-    """Get specific submission information"""
     return service.get_submission(contest_id, submission_id)
 
 
 @router.get(
     "/contests/{contest_id}/submissions/{submission_id}/files",
     summary="Get Submission Files",
-    description="Get files for a specific submission",
     response_class=FileResponse,
 )
 async def get_submission_files(
@@ -55,28 +46,5 @@ async def get_submission_files(
     submission_id: str = FastAPIPath(..., description="Submission identifier"),
     service: ContestServiceDep = None,
 ) -> FileResponse:
-    """Get submission files"""
-    service.validate_contest_id(contest_id)
-
-    # Get submission from indexed data
-    submission = service.submissions_by_id.get(submission_id)
-    if not submission:
-        raise HTTPException(status_code=404, detail=f"Submission {submission_id} not found")
-
-    # Expected href pattern for this endpoint
-    expected_href = f"contests/{contest_id}/submissions/{submission_id}/files"
-
-    try:
-        files: List[Dict] = submission["files"]
-        for file_info in files:
-            href = file_info["href"]
-            if href == expected_href:
-                filename = file_info["filename"]
-                submission_file: Path = service.contest_package_dir / "submissions" / submission_id / filename
-                if submission_file.exists():
-                    mime_type = file_info["mime"]
-                    return FileResponse(path=submission_file, media_type=mime_type, filename=filename)
-    except Exception as e:
-        raise HTTPException(
-            status_code=404, detail=f"Submission files not found. [submission_id={submission_id}] [err={e}]"
-        )
+    file_attr = service.get_submission_file(contest_id, submission_id)
+    return FileResponse(path=file_attr.path, media_type=file_attr.media_type, filename=file_attr.name)

xcpcio/ccs/api_server/routes/teams.py

@@ -1,15 +1,10 @@
 import logging
-from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 
-from fastapi import APIRouter, HTTPException, Query
+from fastapi import APIRouter
 from fastapi import Path as FastAPIPath
 from fastapi.responses import FileResponse
 
-from ...model import (
-    Team,
-    Teams,
-)
 from ..dependencies import ContestServiceDep
 
 router = APIRouter()
@@ -18,38 +13,32 @@ logger = logging.getLogger(__name__)
 
 @router.get(
     "/contests/{contest_id}/teams",
-    summary="Get Teams",
-    description="Get all teams, optionally filtered by group",
-    response_model=Teams,
+    summary="Get all the teams for this contest",
+    response_model=List[Dict[str, Any]],
 )
 async def get_teams(
     contest_id: str = FastAPIPath(..., description="Contest identifier"),
-    group_id: Optional[str] = Query(None, description="Filter teams by group ID"),
     service: ContestServiceDep = None,
 ) -> List[Dict[str, Any]]:
-    """Get all teams, optionally filtered by group"""
-    return service.get_teams(contest_id, group_id)
+    return service.get_teams(contest_id)
 
 
 @router.get(
     "/contests/{contest_id}/teams/{team_id}",
-    summary="Get Team",
-    description="Get specific team information",
-    response_model=Team,
+    summary="Get the given team for this contest",
+    response_model=Dict[str, Any],
 )
 async def get_team(
     contest_id: str = FastAPIPath(..., description="Contest identifier"),
     team_id: str = FastAPIPath(..., description="Team identifier"),
     service: ContestServiceDep = None,
 ) -> Dict[str, Any]:
-    """Get specific team information"""
     return service.get_team(contest_id, team_id)
 
 
 @router.get(
     "/contests/{contest_id}/teams/{team_id}/photo",
     summary="Get Team Photo",
-    description="Get photo file for a specific team",
     response_class=FileResponse,
 )
 async def get_team_photo(
@@ -57,26 +46,5 @@ async def get_team_photo(
     team_id: str = FastAPIPath(..., description="Team identifier"),
     service: ContestServiceDep = None,
 ) -> FileResponse:
-    """Get team photo file"""
-    service.validate_contest_id(contest_id)
-
-    # Get team from indexed data
-    team = service.teams_by_id.get(team_id)
-    if not team:
-        raise HTTPException(status_code=404, detail=f"Team {team_id} not found")
-
-    # Expected href pattern for this endpoint
-    expected_href = f"contests/{contest_id}/teams/{team_id}/photo"
-
-    try:
-        photos = team["photo"]
-        for photo in photos:
-            href = photo["href"]
-            if href == expected_href:
-                filename = ["filename"]
-                photo_file: Path = service.contest_package_dir / "teams" / team_id / filename
-                if photo_file.exists():
-                    mime_type = photo["mime"]
-                    return FileResponse(path=photo_file, media_type=mime_type, filename=filename)
-    except Exception as e:
-        raise HTTPException(status_code=404, detail=f"Photo not found. [team_id={team_id}] [err={e}]")
+    file_attr = service.get_team_photo(contest_id, team_id)
+    return FileResponse(path=file_attr.path, media_type=file_attr.media_type, filename=file_attr.name)