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

from . import filter_pb2 as filter__pb2


class ActionInterfaceStub(object):
    """-------- Services --------

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Commit = channel.unary_unary(
                '/filter.ActionInterface/Commit',
                request_serializer=filter__pb2.ActionCommitRequest.SerializeToString,
                response_deserializer=filter__pb2.ActionCommitResponse.FromString,
                )
        self.Delete = channel.unary_unary(
                '/filter.ActionInterface/Delete',
                request_serializer=filter__pb2.ActionDeleteRequest.SerializeToString,
                response_deserializer=filter__pb2.ActionDeleteResponse.FromString,
                )
        self.GetParentFilter = channel.unary_unary(
                '/filter.ActionInterface/GetParentFilter',
                request_serializer=filter__pb2.ActionGetParentFilterRequest.SerializeToString,
                response_deserializer=filter__pb2.ActionGetParentFilterResponse.FromString,
                )


class ActionInterfaceServicer(object):
    """-------- Services --------

    """

    def Commit(self, request, context):
        """Sets new properties for the [Action] on the server side using a [ActionData] object.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Delete(self, request, context):
        """Delete this [Action]
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetParentFilter(self, request, context):
        """Returns the [Filter] this action is part of.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_ActionInterfaceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Commit': grpc.unary_unary_rpc_method_handler(
                    servicer.Commit,
                    request_deserializer=filter__pb2.ActionCommitRequest.FromString,
                    response_serializer=filter__pb2.ActionCommitResponse.SerializeToString,
            ),
            'Delete': grpc.unary_unary_rpc_method_handler(
                    servicer.Delete,
                    request_deserializer=filter__pb2.ActionDeleteRequest.FromString,
                    response_serializer=filter__pb2.ActionDeleteResponse.SerializeToString,
            ),
            'GetParentFilter': grpc.unary_unary_rpc_method_handler(
                    servicer.GetParentFilter,
                    request_deserializer=filter__pb2.ActionGetParentFilterRequest.FromString,
                    response_serializer=filter__pb2.ActionGetParentFilterResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'filter.ActionInterface', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class ActionInterface(object):
    """-------- Services --------

    """

    @staticmethod
    def Commit(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, '/filter.ActionInterface/Commit',
            filter__pb2.ActionCommitRequest.SerializeToString,
            filter__pb2.ActionCommitResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Delete(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, '/filter.ActionInterface/Delete',
            filter__pb2.ActionDeleteRequest.SerializeToString,
            filter__pb2.ActionDeleteResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetParentFilter(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, '/filter.ActionInterface/GetParentFilter',
            filter__pb2.ActionGetParentFilterRequest.SerializeToString,
            filter__pb2.ActionGetParentFilterResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class FilterInterfaceStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.CreateAction = channel.unary_unary(
                '/filter.FilterInterface/CreateAction',
                request_serializer=filter__pb2.FilterCreateActionRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterCreateActionResponse.FromString,
                )
        self.CreateMatcher = channel.unary_unary(
                '/filter.FilterInterface/CreateMatcher',
                request_serializer=filter__pb2.FilterCreateMatcherRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterCreateMatcherResponse.FromString,
                )
        self.Delete = channel.unary_unary(
                '/filter.FilterInterface/Delete',
                request_serializer=filter__pb2.FilterDeleteRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterDeleteResponse.FromString,
                )
        self.FindFilter = channel.unary_unary(
                '/filter.FilterInterface/FindFilter',
                request_serializer=filter__pb2.FilterFindFilterRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterFindFilterResponse.FromString,
                )
        self.GetActions = channel.unary_unary(
                '/filter.FilterInterface/GetActions',
                request_serializer=filter__pb2.FilterGetActionsRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterGetActionsResponse.FromString,
                )
        self.GetMatchers = channel.unary_unary(
                '/filter.FilterInterface/GetMatchers',
                request_serializer=filter__pb2.FilterGetMatchersRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterGetMatchersResponse.FromString,
                )
        self.LowerOrder = channel.unary_unary(
                '/filter.FilterInterface/LowerOrder',
                request_serializer=filter__pb2.FilterLowerOrderRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterLowerOrderResponse.FromString,
                )
        self.OrderFirst = channel.unary_unary(
                '/filter.FilterInterface/OrderFirst',
                request_serializer=filter__pb2.FilterOrderFirstRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterOrderFirstResponse.FromString,
                )
        self.OrderLast = channel.unary_unary(
                '/filter.FilterInterface/OrderLast',
                request_serializer=filter__pb2.FilterOrderLastRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterOrderLastResponse.FromString,
                )
        self.RaiseOrder = channel.unary_unary(
                '/filter.FilterInterface/RaiseOrder',
                request_serializer=filter__pb2.FilterRaiseOrderRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterRaiseOrderResponse.FromString,
                )
        self.RunFilterOnGroup = channel.unary_unary(
                '/filter.FilterInterface/RunFilterOnGroup',
                request_serializer=filter__pb2.FilterRunFilterOnGroupRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterRunFilterOnGroupResponse.FromString,
                )
        self.RunFilterOnJobs = channel.unary_unary(
                '/filter.FilterInterface/RunFilterOnJobs',
                request_serializer=filter__pb2.FilterRunFilterOnJobsRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterRunFilterOnJobsResponse.FromString,
                )
        self.SetEnabled = channel.unary_unary(
                '/filter.FilterInterface/SetEnabled',
                request_serializer=filter__pb2.FilterSetEnabledRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterSetEnabledResponse.FromString,
                )
        self.SetName = channel.unary_unary(
                '/filter.FilterInterface/SetName',
                request_serializer=filter__pb2.FilterSetNameRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterSetNameResponse.FromString,
                )
        self.SetOrder = channel.unary_unary(
                '/filter.FilterInterface/SetOrder',
                request_serializer=filter__pb2.FilterSetOrderRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterSetOrderResponse.FromString,
                )
        self.SetType = channel.unary_unary(
                '/filter.FilterInterface/SetType',
                request_serializer=filter__pb2.FilterSetTypeRequest.SerializeToString,
                response_deserializer=filter__pb2.FilterSetTypeResponse.FromString,
                )


class FilterInterfaceServicer(object):
    """Missing associated documentation comment in .proto file."""

    def CreateAction(self, request, context):
        """Creates a new [Action] that will execute for this filter.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateMatcher(self, request, context):
        """Creates a new [Matcher] for this filter.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Delete(self, request, context):
        """Delete this filter.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FindFilter(self, request, context):
        """Find a filter by it's show and name
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetActions(self, request, context):
        """Returns a list of [Action]s configured for this filter.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetMatchers(self, request, context):
        """Returns a list of [Matcher]s configured for this filter
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LowerOrder(self, request, context):
        """Lowers the order of the filter, this makes it run after the next filter
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrderFirst(self, request, context):
        """Moves the filter to first in the order list.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrderLast(self, request, context):
        """Moves the filter to last in the order list.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RaiseOrder(self, request, context):
        """Raises the order of the filter, this makes it run before the previous filter.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RunFilterOnGroup(self, request, context):
        """Executes the filter on a specified group.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RunFilterOnJobs(self, request, context):
        """Executes the filter on a specified sequence of jobs.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetEnabled(self, request, context):
        """Set the filter to enabled or disabled
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetName(self, request, context):
        """Set the filter name.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetOrder(self, request, context):
        """Directly sets the order of the filter.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetType(self, request, context):
        """Set the type of the filter. See FilterType
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_FilterInterfaceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CreateAction': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateAction,
                    request_deserializer=filter__pb2.FilterCreateActionRequest.FromString,
                    response_serializer=filter__pb2.FilterCreateActionResponse.SerializeToString,
            ),
            'CreateMatcher': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateMatcher,
                    request_deserializer=filter__pb2.FilterCreateMatcherRequest.FromString,
                    response_serializer=filter__pb2.FilterCreateMatcherResponse.SerializeToString,
            ),
            'Delete': grpc.unary_unary_rpc_method_handler(
                    servicer.Delete,
                    request_deserializer=filter__pb2.FilterDeleteRequest.FromString,
                    response_serializer=filter__pb2.FilterDeleteResponse.SerializeToString,
            ),
            'FindFilter': grpc.unary_unary_rpc_method_handler(
                    servicer.FindFilter,
                    request_deserializer=filter__pb2.FilterFindFilterRequest.FromString,
                    response_serializer=filter__pb2.FilterFindFilterResponse.SerializeToString,
            ),
            'GetActions': grpc.unary_unary_rpc_method_handler(
                    servicer.GetActions,
                    request_deserializer=filter__pb2.FilterGetActionsRequest.FromString,
                    response_serializer=filter__pb2.FilterGetActionsResponse.SerializeToString,
            ),
            'GetMatchers': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMatchers,
                    request_deserializer=filter__pb2.FilterGetMatchersRequest.FromString,
                    response_serializer=filter__pb2.FilterGetMatchersResponse.SerializeToString,
            ),
            'LowerOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.LowerOrder,
                    request_deserializer=filter__pb2.FilterLowerOrderRequest.FromString,
                    response_serializer=filter__pb2.FilterLowerOrderResponse.SerializeToString,
            ),
            'OrderFirst': grpc.unary_unary_rpc_method_handler(
                    servicer.OrderFirst,
                    request_deserializer=filter__pb2.FilterOrderFirstRequest.FromString,
                    response_serializer=filter__pb2.FilterOrderFirstResponse.SerializeToString,
            ),
            'OrderLast': grpc.unary_unary_rpc_method_handler(
                    servicer.OrderLast,
                    request_deserializer=filter__pb2.FilterOrderLastRequest.FromString,
                    response_serializer=filter__pb2.FilterOrderLastResponse.SerializeToString,
            ),
            'RaiseOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.RaiseOrder,
                    request_deserializer=filter__pb2.FilterRaiseOrderRequest.FromString,
                    response_serializer=filter__pb2.FilterRaiseOrderResponse.SerializeToString,
            ),
            'RunFilterOnGroup': grpc.unary_unary_rpc_method_handler(
                    servicer.RunFilterOnGroup,
                    request_deserializer=filter__pb2.FilterRunFilterOnGroupRequest.FromString,
                    response_serializer=filter__pb2.FilterRunFilterOnGroupResponse.SerializeToString,
            ),
            'RunFilterOnJobs': grpc.unary_unary_rpc_method_handler(
                    servicer.RunFilterOnJobs,
                    request_deserializer=filter__pb2.FilterRunFilterOnJobsRequest.FromString,
                    response_serializer=filter__pb2.FilterRunFilterOnJobsResponse.SerializeToString,
            ),
            'SetEnabled': grpc.unary_unary_rpc_method_handler(
                    servicer.SetEnabled,
                    request_deserializer=filter__pb2.FilterSetEnabledRequest.FromString,
                    response_serializer=filter__pb2.FilterSetEnabledResponse.SerializeToString,
            ),
            'SetName': grpc.unary_unary_rpc_method_handler(
                    servicer.SetName,
                    request_deserializer=filter__pb2.FilterSetNameRequest.FromString,
                    response_serializer=filter__pb2.FilterSetNameResponse.SerializeToString,
            ),
            'SetOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.SetOrder,
                    request_deserializer=filter__pb2.FilterSetOrderRequest.FromString,
                    response_serializer=filter__pb2.FilterSetOrderResponse.SerializeToString,
            ),
            'SetType': grpc.unary_unary_rpc_method_handler(
                    servicer.SetType,
                    request_deserializer=filter__pb2.FilterSetTypeRequest.FromString,
                    response_serializer=filter__pb2.FilterSetTypeResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'filter.FilterInterface', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class FilterInterface(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def CreateAction(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, '/filter.FilterInterface/CreateAction',
            filter__pb2.FilterCreateActionRequest.SerializeToString,
            filter__pb2.FilterCreateActionResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateMatcher(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, '/filter.FilterInterface/CreateMatcher',
            filter__pb2.FilterCreateMatcherRequest.SerializeToString,
            filter__pb2.FilterCreateMatcherResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Delete(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, '/filter.FilterInterface/Delete',
            filter__pb2.FilterDeleteRequest.SerializeToString,
            filter__pb2.FilterDeleteResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def FindFilter(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, '/filter.FilterInterface/FindFilter',
            filter__pb2.FilterFindFilterRequest.SerializeToString,
            filter__pb2.FilterFindFilterResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetActions(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, '/filter.FilterInterface/GetActions',
            filter__pb2.FilterGetActionsRequest.SerializeToString,
            filter__pb2.FilterGetActionsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetMatchers(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, '/filter.FilterInterface/GetMatchers',
            filter__pb2.FilterGetMatchersRequest.SerializeToString,
            filter__pb2.FilterGetMatchersResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def LowerOrder(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, '/filter.FilterInterface/LowerOrder',
            filter__pb2.FilterLowerOrderRequest.SerializeToString,
            filter__pb2.FilterLowerOrderResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrderFirst(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, '/filter.FilterInterface/OrderFirst',
            filter__pb2.FilterOrderFirstRequest.SerializeToString,
            filter__pb2.FilterOrderFirstResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrderLast(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, '/filter.FilterInterface/OrderLast',
            filter__pb2.FilterOrderLastRequest.SerializeToString,
            filter__pb2.FilterOrderLastResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RaiseOrder(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, '/filter.FilterInterface/RaiseOrder',
            filter__pb2.FilterRaiseOrderRequest.SerializeToString,
            filter__pb2.FilterRaiseOrderResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RunFilterOnGroup(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, '/filter.FilterInterface/RunFilterOnGroup',
            filter__pb2.FilterRunFilterOnGroupRequest.SerializeToString,
            filter__pb2.FilterRunFilterOnGroupResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RunFilterOnJobs(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, '/filter.FilterInterface/RunFilterOnJobs',
            filter__pb2.FilterRunFilterOnJobsRequest.SerializeToString,
            filter__pb2.FilterRunFilterOnJobsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetEnabled(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, '/filter.FilterInterface/SetEnabled',
            filter__pb2.FilterSetEnabledRequest.SerializeToString,
            filter__pb2.FilterSetEnabledResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetName(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, '/filter.FilterInterface/SetName',
            filter__pb2.FilterSetNameRequest.SerializeToString,
            filter__pb2.FilterSetNameResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetOrder(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, '/filter.FilterInterface/SetOrder',
            filter__pb2.FilterSetOrderRequest.SerializeToString,
            filter__pb2.FilterSetOrderResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetType(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, '/filter.FilterInterface/SetType',
            filter__pb2.FilterSetTypeRequest.SerializeToString,
            filter__pb2.FilterSetTypeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class MatcherInterfaceStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.Commit = channel.unary_unary(
                '/filter.MatcherInterface/Commit',
                request_serializer=filter__pb2.MatcherCommitRequest.SerializeToString,
                response_deserializer=filter__pb2.MatcherCommitResponse.FromString,
                )
        self.Delete = channel.unary_unary(
                '/filter.MatcherInterface/Delete',
                request_serializer=filter__pb2.MatcherDeleteRequest.SerializeToString,
                response_deserializer=filter__pb2.MatcherDeleteResponse.FromString,
                )
        self.GetParentFilter = channel.unary_unary(
                '/filter.MatcherInterface/GetParentFilter',
                request_serializer=filter__pb2.MatcherGetParentFilterRequest.SerializeToString,
                response_deserializer=filter__pb2.MatcherGetParentFilterResponse.FromString,
                )


class MatcherInterfaceServicer(object):
    """Missing associated documentation comment in .proto file."""

    def Commit(self, request, context):
        """Sets new properties for the [Matcher] on the server side using a [MatcherData] object.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Delete(self, request, context):
        """Delete this matcher.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetParentFilter(self, request, context):
        """Returns the [Filter] this matcher is part of.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_MatcherInterfaceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Commit': grpc.unary_unary_rpc_method_handler(
                    servicer.Commit,
                    request_deserializer=filter__pb2.MatcherCommitRequest.FromString,
                    response_serializer=filter__pb2.MatcherCommitResponse.SerializeToString,
            ),
            'Delete': grpc.unary_unary_rpc_method_handler(
                    servicer.Delete,
                    request_deserializer=filter__pb2.MatcherDeleteRequest.FromString,
                    response_serializer=filter__pb2.MatcherDeleteResponse.SerializeToString,
            ),
            'GetParentFilter': grpc.unary_unary_rpc_method_handler(
                    servicer.GetParentFilter,
                    request_deserializer=filter__pb2.MatcherGetParentFilterRequest.FromString,
                    response_serializer=filter__pb2.MatcherGetParentFilterResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'filter.MatcherInterface', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class MatcherInterface(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def Commit(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, '/filter.MatcherInterface/Commit',
            filter__pb2.MatcherCommitRequest.SerializeToString,
            filter__pb2.MatcherCommitResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Delete(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, '/filter.MatcherInterface/Delete',
            filter__pb2.MatcherDeleteRequest.SerializeToString,
            filter__pb2.MatcherDeleteResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetParentFilter(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, '/filter.MatcherInterface/GetParentFilter',
            filter__pb2.MatcherGetParentFilterRequest.SerializeToString,
            filter__pb2.MatcherGetParentFilterResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)