exercise_pb2_grpc.py

# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc

import exercise_pb2 as exercise__pb2


class ExerciseServiceStub(object):
    """[Service] 운동 분석 및 세션 관리 서비스
    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.ExtractReferenceData = channel.unary_unary(
                '/ExerciseService/ExtractReferenceData',
                request_serializer=exercise__pb2.ExtractRequest.SerializeToString,
                response_deserializer=exercise__pb2.ExtractResponse.FromString,
                )
        self.StartAnalysis = channel.unary_unary(
                '/ExerciseService/StartAnalysis',
                request_serializer=exercise__pb2.AnalyzeRequest.SerializeToString,
                response_deserializer=exercise__pb2.AnalyzeResponse.FromString,
                )
        self.ReattachAnalysis = channel.unary_unary(
                '/ExerciseService/ReattachAnalysis',
                request_serializer=exercise__pb2.ReattachRequest.SerializeToString,
                response_deserializer=exercise__pb2.ReattachResponse.FromString,
                )
        self.SavePoseDataBatch = channel.unary_unary(
                '/ExerciseService/SavePoseDataBatch',
                request_serializer=exercise__pb2.PoseDataBatchRequest.SerializeToString,
                response_deserializer=exercise__pb2.PoseDataResponse.FromString,
                )
        self.CompleteAnalysis = channel.unary_unary(
                '/ExerciseService/CompleteAnalysis',
                request_serializer=exercise__pb2.SessionCompleteRequest.SerializeToString,
                response_deserializer=exercise__pb2.SessionCompleteResponse.FromString,
                )
        self.StopAnalysis = channel.unary_unary(
                '/ExerciseService/StopAnalysis',
                request_serializer=exercise__pb2.StopRequest.SerializeToString,
                response_deserializer=exercise__pb2.StopResponse.FromString,
                )
        self.ReportFeedbackBatch = channel.unary_unary(
                '/ExerciseService/ReportFeedbackBatch',
                request_serializer=exercise__pb2.FeedbackBatchRequest.SerializeToString,
                response_deserializer=exercise__pb2.FeedbackBatchResponse.FromString,
                )


class ExerciseServiceServicer(object):
    """[Service] 운동 분석 및 세션 관리 서비스
    """

    def ExtractReferenceData(self, request, context):
        """[추가] 등록 단계: 유튜브 링크를 주면 전체 좌표를 반환 (Spring -> FastAPI)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartAnalysis(self, request, context):
        """[수정] 실행 단계: 세션 정보와 함께 'DB에 저장된 기준 좌표'를 전달 (Spring -> FastAPI)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReattachAnalysis(self, request, context):
        """재부착: 이미 IN_PROGRESS 인 세션의 AI 상태를 DB 값으로 되살린다 (Spring -> FastAPI).
        StartAnalysis 와 분리한 이유 — 이 RPC 는 '상태가 이미 있으면 보존하고 성공 반환'이 계약이라
        정상 시작 경로와 멱등 규칙이 정반대다. 한 핸들러에 섞으면 시작 요청이 조용히 no-op 이 될 수 있다.
        (docs/decisions/session-resume-and-ai-state.md §4-B, 이슈 #59 2단계)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SavePoseDataBatch(self, request, context):
        """3. 분석 결과 배치 저장 (FastAPI -> Spring)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CompleteAnalysis(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StopAnalysis(self, request, context):
        """✅ 사용자가 운동을 중단했을 때 AI 서버에 알리는 명령
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReportFeedbackBatch(self, request, context):
        """4. TTS 피드백 발화 이벤트 batch 저장 (FastAPI -> Spring, BT-SET)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_ExerciseServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'ExtractReferenceData': grpc.unary_unary_rpc_method_handler(
                    servicer.ExtractReferenceData,
                    request_deserializer=exercise__pb2.ExtractRequest.FromString,
                    response_serializer=exercise__pb2.ExtractResponse.SerializeToString,
            ),
            'StartAnalysis': grpc.unary_unary_rpc_method_handler(
                    servicer.StartAnalysis,
                    request_deserializer=exercise__pb2.AnalyzeRequest.FromString,
                    response_serializer=exercise__pb2.AnalyzeResponse.SerializeToString,
            ),
            'ReattachAnalysis': grpc.unary_unary_rpc_method_handler(
                    servicer.ReattachAnalysis,
                    request_deserializer=exercise__pb2.ReattachRequest.FromString,
                    response_serializer=exercise__pb2.ReattachResponse.SerializeToString,
            ),
            'SavePoseDataBatch': grpc.unary_unary_rpc_method_handler(
                    servicer.SavePoseDataBatch,
                    request_deserializer=exercise__pb2.PoseDataBatchRequest.FromString,
                    response_serializer=exercise__pb2.PoseDataResponse.SerializeToString,
            ),
            'CompleteAnalysis': grpc.unary_unary_rpc_method_handler(
                    servicer.CompleteAnalysis,
                    request_deserializer=exercise__pb2.SessionCompleteRequest.FromString,
                    response_serializer=exercise__pb2.SessionCompleteResponse.SerializeToString,
            ),
            'StopAnalysis': grpc.unary_unary_rpc_method_handler(
                    servicer.StopAnalysis,
                    request_deserializer=exercise__pb2.StopRequest.FromString,
                    response_serializer=exercise__pb2.StopResponse.SerializeToString,
            ),
            'ReportFeedbackBatch': grpc.unary_unary_rpc_method_handler(
                    servicer.ReportFeedbackBatch,
                    request_deserializer=exercise__pb2.FeedbackBatchRequest.FromString,
                    response_serializer=exercise__pb2.FeedbackBatchResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'ExerciseService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class ExerciseService(object):
    """[Service] 운동 분석 및 세션 관리 서비스
    """

    @staticmethod
    def ExtractReferenceData(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/ExerciseService/ExtractReferenceData',
            exercise__pb2.ExtractRequest.SerializeToString,
            exercise__pb2.ExtractResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartAnalysis(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/ExerciseService/StartAnalysis',
            exercise__pb2.AnalyzeRequest.SerializeToString,
            exercise__pb2.AnalyzeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ReattachAnalysis(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/ExerciseService/ReattachAnalysis',
            exercise__pb2.ReattachRequest.SerializeToString,
            exercise__pb2.ReattachResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SavePoseDataBatch(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/ExerciseService/SavePoseDataBatch',
            exercise__pb2.PoseDataBatchRequest.SerializeToString,
            exercise__pb2.PoseDataResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CompleteAnalysis(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/ExerciseService/CompleteAnalysis',
            exercise__pb2.SessionCompleteRequest.SerializeToString,
            exercise__pb2.SessionCompleteResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StopAnalysis(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/ExerciseService/StopAnalysis',
            exercise__pb2.StopRequest.SerializeToString,
            exercise__pb2.StopResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ReportFeedbackBatch(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/ExerciseService/ReportFeedbackBatch',
            exercise__pb2.FeedbackBatchRequest.SerializeToString,
            exercise__pb2.FeedbackBatchResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)