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

from . import auth_pb2 as auth__pb2


class AuthServiceStub(object):
    """RPCs in this service do not use any implicit header
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Login = channel.unary_unary(
                '/batchx.auth.AuthService/Login',
                request_serializer=auth__pb2.LoginRequest.SerializeToString,
                response_deserializer=auth__pb2.LoginResponse.FromString,
                )
        self.ForgotPassword = channel.unary_unary(
                '/batchx.auth.AuthService/ForgotPassword',
                request_serializer=auth__pb2.ForgotPasswordRequest.SerializeToString,
                response_deserializer=auth__pb2.ForgotPasswordResponse.FromString,
                )
        self.ConfirmForgotPassword = channel.unary_unary(
                '/batchx.auth.AuthService/ConfirmForgotPassword',
                request_serializer=auth__pb2.ConfirmForgotPasswordRequest.SerializeToString,
                response_deserializer=auth__pb2.ConfirmForgotPasswordResponse.FromString,
                )
        self.RefreshToken = channel.unary_unary(
                '/batchx.auth.AuthService/RefreshToken',
                request_serializer=auth__pb2.RefreshTokenRequest.SerializeToString,
                response_deserializer=auth__pb2.RefreshTokenResponse.FromString,
                )
        self.RevokeRefreshToken = channel.unary_unary(
                '/batchx.auth.AuthService/RevokeRefreshToken',
                request_serializer=auth__pb2.RevokeRefreshTokenRequest.SerializeToString,
                response_deserializer=auth__pb2.RevokeRefreshTokenResponse.FromString,
                )
        self.Signup = channel.unary_unary(
                '/batchx.auth.AuthService/Signup',
                request_serializer=auth__pb2.SignupRequest.SerializeToString,
                response_deserializer=auth__pb2.SignupResponse.FromString,
                )
        self.ConfirmSignup = channel.unary_unary(
                '/batchx.auth.AuthService/ConfirmSignup',
                request_serializer=auth__pb2.ConfirmSignupRequest.SerializeToString,
                response_deserializer=auth__pb2.ConfirmSignupResponse.FromString,
                )
        self.GoogleSignin = channel.unary_unary(
                '/batchx.auth.AuthService/GoogleSignin',
                request_serializer=auth__pb2.GoogleSigninRequest.SerializeToString,
                response_deserializer=auth__pb2.GoogleSigninResponse.FromString,
                )
        self.GoogleSignup = channel.unary_unary(
                '/batchx.auth.AuthService/GoogleSignup',
                request_serializer=auth__pb2.GoogleSignupRequest.SerializeToString,
                response_deserializer=auth__pb2.GoogleSignupResponse.FromString,
                )
        self.ResendSignupConfirmationCode = channel.unary_unary(
                '/batchx.auth.AuthService/ResendSignupConfirmationCode',
                request_serializer=auth__pb2.ResendSignupConfirmationCodeRequest.SerializeToString,
                response_deserializer=auth__pb2.ResendSignupConfirmationCodeResponse.FromString,
                )
        self.StartSignup = channel.unary_unary(
                '/batchx.auth.AuthService/StartSignup',
                request_serializer=auth__pb2.StartSignupRequest.SerializeToString,
                response_deserializer=auth__pb2.StartSignupResponse.FromString,
                )


class AuthServiceServicer(object):
    """RPCs in this service do not use any implicit header
    """

    def Login(self, request, context):
        """Authenticates a user. A user authenticates by answering successive challenges until authentication either fails or the user is issued tokens
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ForgotPassword(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 ConfirmForgotPassword(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 RefreshToken(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 RevokeRefreshToken(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 Signup(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 ConfirmSignup(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 GoogleSignin(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 GoogleSignup(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 ResendSignupConfirmationCode(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 StartSignup(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 add_AuthServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Login': grpc.unary_unary_rpc_method_handler(
                    servicer.Login,
                    request_deserializer=auth__pb2.LoginRequest.FromString,
                    response_serializer=auth__pb2.LoginResponse.SerializeToString,
            ),
            'ForgotPassword': grpc.unary_unary_rpc_method_handler(
                    servicer.ForgotPassword,
                    request_deserializer=auth__pb2.ForgotPasswordRequest.FromString,
                    response_serializer=auth__pb2.ForgotPasswordResponse.SerializeToString,
            ),
            'ConfirmForgotPassword': grpc.unary_unary_rpc_method_handler(
                    servicer.ConfirmForgotPassword,
                    request_deserializer=auth__pb2.ConfirmForgotPasswordRequest.FromString,
                    response_serializer=auth__pb2.ConfirmForgotPasswordResponse.SerializeToString,
            ),
            'RefreshToken': grpc.unary_unary_rpc_method_handler(
                    servicer.RefreshToken,
                    request_deserializer=auth__pb2.RefreshTokenRequest.FromString,
                    response_serializer=auth__pb2.RefreshTokenResponse.SerializeToString,
            ),
            'RevokeRefreshToken': grpc.unary_unary_rpc_method_handler(
                    servicer.RevokeRefreshToken,
                    request_deserializer=auth__pb2.RevokeRefreshTokenRequest.FromString,
                    response_serializer=auth__pb2.RevokeRefreshTokenResponse.SerializeToString,
            ),
            'Signup': grpc.unary_unary_rpc_method_handler(
                    servicer.Signup,
                    request_deserializer=auth__pb2.SignupRequest.FromString,
                    response_serializer=auth__pb2.SignupResponse.SerializeToString,
            ),
            'ConfirmSignup': grpc.unary_unary_rpc_method_handler(
                    servicer.ConfirmSignup,
                    request_deserializer=auth__pb2.ConfirmSignupRequest.FromString,
                    response_serializer=auth__pb2.ConfirmSignupResponse.SerializeToString,
            ),
            'GoogleSignin': grpc.unary_unary_rpc_method_handler(
                    servicer.GoogleSignin,
                    request_deserializer=auth__pb2.GoogleSigninRequest.FromString,
                    response_serializer=auth__pb2.GoogleSigninResponse.SerializeToString,
            ),
            'GoogleSignup': grpc.unary_unary_rpc_method_handler(
                    servicer.GoogleSignup,
                    request_deserializer=auth__pb2.GoogleSignupRequest.FromString,
                    response_serializer=auth__pb2.GoogleSignupResponse.SerializeToString,
            ),
            'ResendSignupConfirmationCode': grpc.unary_unary_rpc_method_handler(
                    servicer.ResendSignupConfirmationCode,
                    request_deserializer=auth__pb2.ResendSignupConfirmationCodeRequest.FromString,
                    response_serializer=auth__pb2.ResendSignupConfirmationCodeResponse.SerializeToString,
            ),
            'StartSignup': grpc.unary_unary_rpc_method_handler(
                    servicer.StartSignup,
                    request_deserializer=auth__pb2.StartSignupRequest.FromString,
                    response_serializer=auth__pb2.StartSignupResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'batchx.auth.AuthService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class AuthService(object):
    """RPCs in this service do not use any implicit header
    """

    @staticmethod
    def Login(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, '/batchx.auth.AuthService/Login',
            auth__pb2.LoginRequest.SerializeToString,
            auth__pb2.LoginResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ForgotPassword(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, '/batchx.auth.AuthService/ForgotPassword',
            auth__pb2.ForgotPasswordRequest.SerializeToString,
            auth__pb2.ForgotPasswordResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ConfirmForgotPassword(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, '/batchx.auth.AuthService/ConfirmForgotPassword',
            auth__pb2.ConfirmForgotPasswordRequest.SerializeToString,
            auth__pb2.ConfirmForgotPasswordResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RefreshToken(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, '/batchx.auth.AuthService/RefreshToken',
            auth__pb2.RefreshTokenRequest.SerializeToString,
            auth__pb2.RefreshTokenResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RevokeRefreshToken(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, '/batchx.auth.AuthService/RevokeRefreshToken',
            auth__pb2.RevokeRefreshTokenRequest.SerializeToString,
            auth__pb2.RevokeRefreshTokenResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Signup(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, '/batchx.auth.AuthService/Signup',
            auth__pb2.SignupRequest.SerializeToString,
            auth__pb2.SignupResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ConfirmSignup(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, '/batchx.auth.AuthService/ConfirmSignup',
            auth__pb2.ConfirmSignupRequest.SerializeToString,
            auth__pb2.ConfirmSignupResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GoogleSignin(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, '/batchx.auth.AuthService/GoogleSignin',
            auth__pb2.GoogleSigninRequest.SerializeToString,
            auth__pb2.GoogleSigninResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GoogleSignup(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, '/batchx.auth.AuthService/GoogleSignup',
            auth__pb2.GoogleSignupRequest.SerializeToString,
            auth__pb2.GoogleSignupResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ResendSignupConfirmationCode(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, '/batchx.auth.AuthService/ResendSignupConfirmationCode',
            auth__pb2.ResendSignupConfirmationCodeRequest.SerializeToString,
            auth__pb2.ResendSignupConfirmationCodeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartSignup(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, '/batchx.auth.AuthService/StartSignup',
            auth__pb2.StartSignupRequest.SerializeToString,
            auth__pb2.StartSignupResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
