async def delete_problem_in_problem_set( problem_set: models.ProblemSet = Depends( parse_problem_set_factory(load_links=True)), problem: models.Problem = Depends(parse_problem), ) -> StandardResponse[schemas.ProblemSet]: await problem_set.operate_problem(problem, Operation.Delete) return StandardResponse(problem_set)
def delete_file_from_uncommitted_problem_config( path: str = Path(...), problem: models.Problem = Depends(parse_problem), ) -> StandardResponse[FileInfo]: problem_config = LakeFSProblemConfig(problem) file_info = problem_config.delete_file(pathlib.Path(path)) return StandardResponse(file_info)
async def create_problem( problem_create: schemas.ProblemCreate, background_tasks: BackgroundTasks, domain: models.Domain = Depends(parse_domain_from_auth), user: models.User = Depends(parse_user_from_auth), session: AsyncSession = Depends(db_session_dependency), ) -> StandardResponse[schemas.ProblemDetail]: try: problem_group = models.ProblemGroup() session.sync_session.add(problem_group) logger.info(f"problem group created: {problem_group}") problem = models.Problem( **problem_create.dict(), domain_id=domain.id, owner_id=user.id, problem_group_id=problem_group.id, ) session.sync_session.add(problem) logger.info(f"problem created: {problem}") await session.commit() await session.refresh(problem) except Exception as e: logger.exception(f"problem creation failed: {problem_create}") raise e lakefs_problem_config = LakeFSProblemConfig(problem) background_tasks.add_task(lakefs_problem_config.ensure_branch) return StandardResponse(problem)
def get_file_or_directory_info_in_uncommitted_problem_config( path: str = Path(...), problem: models.Problem = Depends(parse_problem), ) -> StandardResponse[FileInfo]: problem_config = LakeFSProblemConfig(problem) file_info = problem_config.get_file_info(pathlib.Path(path)) return StandardResponse(file_info)
def reset_problem_config( lakefs_reset: schemas.LakeFSReset, problem: models.Problem = Depends(parse_problem), ) -> StandardResponse[Empty]: problem_config = LakeFSProblemConfig(problem) problem_config.reset(lakefs_reset) return StandardResponse()
async def update_problem( problem_edit: schemas.ProblemEdit = Depends( schemas.ProblemEdit.edit_dependency), problem: models.Problem = Depends(parse_problem), ) -> StandardResponse[schemas.Problem]: problem.update_from_dict(problem_edit.dict()) await problem.save_model() return StandardResponse(problem)
def upload_file_to_problem_config( file: UploadFile = File(...), problem: models.Problem = Depends(parse_problem), path: str = Depends(parse_file_path), ) -> StandardResponse[FileInfo]: problem_config = LakeFSProblemConfig(problem) file_info = problem_config.upload_file(pathlib.Path(path), file.file) return StandardResponse(file_info)
def update_problem_config_by_archive( file: UploadFile = File(...), problem: models.Problem = Depends(parse_problem) ) -> StandardResponse[Empty]: logger.info("problem config archive name: %s", file.filename) problem_config = LakeFSProblemConfig(problem) problem_config.upload_archive(file.filename, file.file) return StandardResponse()
async def update_problem_set( problem_set_edit: schemas.ProblemSetEdit = Depends( schemas.ProblemSetEdit.edit_dependency), problem_set: models.ProblemSet = Depends(parse_problem_set), ) -> StandardResponse[schemas.ProblemSet]: problem_set.update_from_dict(problem_set_edit.dict()) await problem_set.save_model() return StandardResponse(problem_set)
async def update_problem_in_problem_set( update_problem: schemas.ProblemSetUpdateProblem, problem_set: models.ProblemSet = Depends( parse_problem_set_factory(load_links=True)), problem: models.Problem = Depends(parse_problem), ) -> StandardResponse[schemas.ProblemSet]: await problem_set.operate_problem(problem, Operation.Update, update_problem.position) return StandardResponse(problem_set)
async def get_problem( problem: models.Problem = Depends(parse_problem), user: models.User = Depends(parse_user_from_auth), ) -> StandardResponse[schemas.ProblemDetailWithLatestRecord]: record = await models.Record.get_user_latest_record(problem_set_id=None, problem_id=problem.id, user_id=user.id) result = schemas.ProblemDetailWithLatestRecord(**problem.dict(), latest_record=record) return StandardResponse(result)
async def commit_problem_config( commit: schemas.ProblemConfigCommit = Body(...), problem: models.Problem = Depends(parse_problem), user: models.User = Depends(parse_user_from_auth), ) -> StandardResponse[schemas.ProblemConfig]: result = await models.ProblemConfig.make_commit(problem=problem, committer=user, commit=commit) logger.info("problem config commit: %s", result) return StandardResponse(schemas.ProblemConfig.from_orm(result))
def delete_directory_from_uncommitted_problem_config( path: str = Path(...), problem: models.Problem = Depends(parse_problem), recursive: bool = Query( False, description="Act as -r in the rm command. " "If false, only empty directory can be deleted.", ), ) -> StandardResponse[FileInfo]: problem_config = LakeFSProblemConfig(problem) file_info = problem_config.delete_directory(pathlib.Path(path), recursive) return StandardResponse(file_info)
async def get_problem_in_problem_set( link: models.ProblemProblemSetLink = Depends( parse_problem_problem_set_link), user: models.User = Depends(parse_user_from_auth), ) -> StandardResponse[schemas.ProblemDetailWithLatestRecord]: # await link.problem_set.operate_problem(link.problem, Operation.Read) record = await models.Record.get_user_latest_record( problem_set_id=link.problem_set_id, problem_id=link.problem_id, user_id=user.id) result = schemas.ProblemDetailWithLatestRecord(**link.problem.dict(), latest_record=record) return StandardResponse(result)
async def add_problem_in_problem_set( add_problem: schemas.ProblemSetAddProblem, problem_set: models.ProblemSet = Depends( parse_problem_set_factory(load_links=True)), domain_auth: DomainAuthentication = Depends(DomainAuthentication), ) -> StandardResponse[schemas.ProblemSet]: problem = await parse_problem_without_validation(add_problem.problem, domain_auth.auth.domain) # examine problem visibility parse_problem(problem, domain_auth.auth) await problem_set.operate_problem(problem, Operation.Create, add_problem.position) return StandardResponse(problem_set)
async def create_problem_set( problem_set_create: schemas.ProblemSetCreate, domain: models.Domain = Depends(parse_domain_from_auth), user: models.User = Depends(parse_user_from_auth), ) -> StandardResponse[schemas.ProblemSet]: problem_set = models.ProblemSet( **problem_set_create.dict(), domain_id=domain.id, owner_id=user.id, ) logger.info(f"create problem set: {problem_set}") await problem_set.save_model() return StandardResponse(problem_set)
async def get_problem_set( problem_set: models.ProblemSet = Depends( parse_problem_set_factory(load_problems=True)), user: models.User = Depends(parse_user_from_auth), ) -> StandardResponse[schemas.ProblemSetDetail]: problems = await models.Problem.get_problems_with_record_states( result_cls=schemas.ProblemPreviewWithLatestRecord, problem_set_id=problem_set.id, problems=problem_set.problems, user_id=user.id, ) result = schemas.ProblemSetDetail(**problem_set.dict( exclude={"problems":...}), problems=problems) return StandardResponse(result)
async def submit_solution_to_problem( background_tasks: BackgroundTasks, celery_app: Celery = Depends(celery_app_dependency), problem_submit: schemas.ProblemSolutionSubmit = Depends( schemas.ProblemSolutionSubmit.form_dependency), problem: models.Problem = Depends(parse_problem), user: models.User = Depends(parse_user_from_auth), ) -> StandardResponse[schemas.Record]: record = await models.Record.submit( background_tasks=background_tasks, celery_app=celery_app, problem_submit=problem_submit, problem_set=None, problem=problem, user=user, ) logger.info("create record: {}", record) return StandardResponse(record)
async def get_user( user: models.User = Depends(parse_uid), ) -> StandardResponse[schemas.User]: return StandardResponse(user)
async def delete_problem( problem: models.Problem = Depends(parse_problem), ) -> StandardResponse[Empty]: await problem.delete_model() return StandardResponse()
async def get_problem_config_json( config: models.ProblemConfig = Depends(parse_problem_config), ) -> StandardResponse[schemas.ProblemConfig]: return StandardResponse(schemas.ProblemConfig.from_orm(config))
async def delete_problem_set( problem_set: models.ProblemSet = Depends(parse_problem_set), ) -> StandardResponse[Empty]: await problem_set.delete_model() return StandardResponse()