python/pyspark/sql/connect/proto/base_pb2_grpc.py - master - githubmirror/spark

python/pyspark/sql/connect/proto/base_pb2_grpc.py
641 строка25 KB
yangjie01
[SPARK-55986][PYTHON] Upgrade black to 26.3.1
16 мар 2026, 19:20
16 мар 2026, 19:20cbcee8c
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""

import grpc

from pyspark.sql.connect.proto import base_pb2 as spark_dot_connect_dot_base__pb2


class SparkConnectServiceStub(object):
    """Main interface for the SparkConnect service."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.ExecutePlan = channel.unary_stream(
            "/spark.connect.SparkConnectService/ExecutePlan",
            request_serializer=spark_dot_connect_dot_base__pb2.ExecutePlanRequest.SerializeToString,
            response_deserializer=spark_dot_connect_dot_base__pb2.ExecutePlanResponse.FromString,
            _registered_method=True,
        )
        self.AnalyzePlan = channel.unary_unary(
            "/spark.connect.SparkConnectService/AnalyzePlan",
            request_serializer=spark_dot_connect_dot_base__pb2.AnalyzePlanRequest.SerializeToString,
            response_deserializer=spark_dot_connect_dot_base__pb2.AnalyzePlanResponse.FromString,
            _registered_method=True,
        )
        self.Config = channel.unary_unary(
            "/spark.connect.SparkConnectService/Config",
            request_serializer=spark_dot_connect_dot_base__pb2.ConfigRequest.SerializeToString,
            response_deserializer=spark_dot_connect_dot_base__pb2.ConfigResponse.FromString,
            _registered_method=True,
        )
        self.AddArtifacts = channel.stream_unary(
            "/spark.connect.SparkConnectService/AddArtifacts",
            request_serializer=spark_dot_connect_dot_base__pb2.AddArtifactsRequest.SerializeToString,
            response_deserializer=spark_dot_connect_dot_base__pb2.AddArtifactsResponse.FromString,
            _registered_method=True,
        )
        self.ArtifactStatus = channel.unary_unary(
            "/spark.connect.SparkConnectService/ArtifactStatus",
            request_serializer=spark_dot_connect_dot_base__pb2.ArtifactStatusesRequest.SerializeToString,
            response_deserializer=spark_dot_connect_dot_base__pb2.ArtifactStatusesResponse.FromString,
            _registered_method=True,
        )
        self.Interrupt = channel.unary_unary(
            "/spark.connect.SparkConnectService/Interrupt",
            request_serializer=spark_dot_connect_dot_base__pb2.InterruptRequest.SerializeToString,
            response_deserializer=spark_dot_connect_dot_base__pb2.InterruptResponse.FromString,
            _registered_method=True,
        )
        self.ReattachExecute = channel.unary_stream(
            "/spark.connect.SparkConnectService/ReattachExecute",
            request_serializer=spark_dot_connect_dot_base__pb2.ReattachExecuteRequest.SerializeToString,
            response_deserializer=spark_dot_connect_dot_base__pb2.ExecutePlanResponse.FromString,
            _registered_method=True,
        )
        self.ReleaseExecute = channel.unary_unary(
            "/spark.connect.SparkConnectService/ReleaseExecute",
            request_serializer=spark_dot_connect_dot_base__pb2.ReleaseExecuteRequest.SerializeToString,
            response_deserializer=spark_dot_connect_dot_base__pb2.ReleaseExecuteResponse.FromString,
            _registered_method=True,
        )
        self.ReleaseSession = channel.unary_unary(
            "/spark.connect.SparkConnectService/ReleaseSession",
            request_serializer=spark_dot_connect_dot_base__pb2.ReleaseSessionRequest.SerializeToString,
            response_deserializer=spark_dot_connect_dot_base__pb2.ReleaseSessionResponse.FromString,
            _registered_method=True,
        )
        self.FetchErrorDetails = channel.unary_unary(
            "/spark.connect.SparkConnectService/FetchErrorDetails",
            request_serializer=spark_dot_connect_dot_base__pb2.FetchErrorDetailsRequest.SerializeToString,
            response_deserializer=spark_dot_connect_dot_base__pb2.FetchErrorDetailsResponse.FromString,
            _registered_method=True,
        )
        self.CloneSession = channel.unary_unary(
            "/spark.connect.SparkConnectService/CloneSession",
            request_serializer=spark_dot_connect_dot_base__pb2.CloneSessionRequest.SerializeToString,
            response_deserializer=spark_dot_connect_dot_base__pb2.CloneSessionResponse.FromString,
            _registered_method=True,
        )
        self.GetStatus = channel.unary_unary(
            "/spark.connect.SparkConnectService/GetStatus",
            request_serializer=spark_dot_connect_dot_base__pb2.GetStatusRequest.SerializeToString,
            response_deserializer=spark_dot_connect_dot_base__pb2.GetStatusResponse.FromString,
            _registered_method=True,
        )


class SparkConnectServiceServicer(object):
    """Main interface for the SparkConnect service."""

    def ExecutePlan(self, request, context):
        """Executes a request that contains the query and returns a stream of [[Response]].

        It is guaranteed that there is at least one ARROW batch returned even if the result set is empty.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def AnalyzePlan(self, request, context):
        """Analyzes a query and returns a [[AnalyzeResponse]] containing metadata about the query."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def Config(self, request, context):
        """Update or fetch the configurations and returns a [[ConfigResponse]] containing the result."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def AddArtifacts(self, request_iterator, context):
        """Add artifacts to the session and returns a [[AddArtifactsResponse]] containing metadata about
        the added artifacts.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ArtifactStatus(self, request, context):
        """Check statuses of artifacts in the session and returns them in a [[ArtifactStatusesResponse]]"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def Interrupt(self, request, context):
        """Interrupts running executions"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ReattachExecute(self, request, context):
        """Reattach to an existing reattachable execution.
        The ExecutePlan must have been started with ReattachOptions.reattachable=true.
        If the ExecutePlanResponse stream ends without a ResultComplete message, there is more to
        continue. If there is a ResultComplete, the client should use ReleaseExecute with
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ReleaseExecute(self, request, context):
        """Release an reattachable execution, or parts thereof.
        The ExecutePlan must have been started with ReattachOptions.reattachable=true.
        Non reattachable executions are released automatically and immediately after the ExecutePlan
        RPC and ReleaseExecute may not be used.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ReleaseSession(self, request, context):
        """Release a session.
        All the executions in the session will be released. Any further requests for the session with
        that session_id for the given user_id will fail. If the session didn't exist or was already
        released, this is a noop.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def FetchErrorDetails(self, request, context):
        """FetchErrorDetails retrieves the matched exception with details based on a provided error id."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def CloneSession(self, request, context):
        """Create a clone of a Spark Connect session on the server side. The server-side session
        is cloned with all its current state (SQL configurations, temporary views, registered
        functions, catalog state) copied over to a new independent session. The cloned session
        is isolated from the source session - any subsequent changes to either session's
        server-side state will not be reflected in the other.

        The request can optionally specify a custom session ID for the cloned session (must be
        a valid UUID). If not provided, a new UUID will be generated automatically.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetStatus(self, request, context):
        """Get status information of different types."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")


def add_SparkConnectServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
        "ExecutePlan": grpc.unary_stream_rpc_method_handler(
            servicer.ExecutePlan,
            request_deserializer=spark_dot_connect_dot_base__pb2.ExecutePlanRequest.FromString,
            response_serializer=spark_dot_connect_dot_base__pb2.ExecutePlanResponse.SerializeToString,
        ),
        "AnalyzePlan": grpc.unary_unary_rpc_method_handler(
            servicer.AnalyzePlan,
            request_deserializer=spark_dot_connect_dot_base__pb2.AnalyzePlanRequest.FromString,
            response_serializer=spark_dot_connect_dot_base__pb2.AnalyzePlanResponse.SerializeToString,
        ),
        "Config": grpc.unary_unary_rpc_method_handler(
            servicer.Config,
            request_deserializer=spark_dot_connect_dot_base__pb2.ConfigRequest.FromString,
            response_serializer=spark_dot_connect_dot_base__pb2.ConfigResponse.SerializeToString,
        ),
        "AddArtifacts": grpc.stream_unary_rpc_method_handler(
            servicer.AddArtifacts,
            request_deserializer=spark_dot_connect_dot_base__pb2.AddArtifactsRequest.FromString,
            response_serializer=spark_dot_connect_dot_base__pb2.AddArtifactsResponse.SerializeToString,
        ),
        "ArtifactStatus": grpc.unary_unary_rpc_method_handler(
            servicer.ArtifactStatus,
            request_deserializer=spark_dot_connect_dot_base__pb2.ArtifactStatusesRequest.FromString,
            response_serializer=spark_dot_connect_dot_base__pb2.ArtifactStatusesResponse.SerializeToString,
        ),
        "Interrupt": grpc.unary_unary_rpc_method_handler(
            servicer.Interrupt,
            request_deserializer=spark_dot_connect_dot_base__pb2.InterruptRequest.FromString,
            response_serializer=spark_dot_connect_dot_base__pb2.InterruptResponse.SerializeToString,
        ),
        "ReattachExecute": grpc.unary_stream_rpc_method_handler(
            servicer.ReattachExecute,
            request_deserializer=spark_dot_connect_dot_base__pb2.ReattachExecuteRequest.FromString,
            response_serializer=spark_dot_connect_dot_base__pb2.ExecutePlanResponse.SerializeToString,
        ),
        "ReleaseExecute": grpc.unary_unary_rpc_method_handler(
            servicer.ReleaseExecute,
            request_deserializer=spark_dot_connect_dot_base__pb2.ReleaseExecuteRequest.FromString,
            response_serializer=spark_dot_connect_dot_base__pb2.ReleaseExecuteResponse.SerializeToString,
        ),
        "ReleaseSession": grpc.unary_unary_rpc_method_handler(
            servicer.ReleaseSession,
            request_deserializer=spark_dot_connect_dot_base__pb2.ReleaseSessionRequest.FromString,
            response_serializer=spark_dot_connect_dot_base__pb2.ReleaseSessionResponse.SerializeToString,
        ),
        "FetchErrorDetails": grpc.unary_unary_rpc_method_handler(
            servicer.FetchErrorDetails,
            request_deserializer=spark_dot_connect_dot_base__pb2.FetchErrorDetailsRequest.FromString,
            response_serializer=spark_dot_connect_dot_base__pb2.FetchErrorDetailsResponse.SerializeToString,
        ),
        "CloneSession": grpc.unary_unary_rpc_method_handler(
            servicer.CloneSession,
            request_deserializer=spark_dot_connect_dot_base__pb2.CloneSessionRequest.FromString,
            response_serializer=spark_dot_connect_dot_base__pb2.CloneSessionResponse.SerializeToString,
        ),
        "GetStatus": grpc.unary_unary_rpc_method_handler(
            servicer.GetStatus,
            request_deserializer=spark_dot_connect_dot_base__pb2.GetStatusRequest.FromString,
            response_serializer=spark_dot_connect_dot_base__pb2.GetStatusResponse.SerializeToString,
        ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
        "spark.connect.SparkConnectService", rpc_method_handlers
    )
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers("spark.connect.SparkConnectService", rpc_method_handlers)


# This class is part of an EXPERIMENTAL API.
class SparkConnectService(object):
    """Main interface for the SparkConnect service."""

    @staticmethod
    def ExecutePlan(
        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_stream(
            request,
            target,
            "/spark.connect.SparkConnectService/ExecutePlan",
            spark_dot_connect_dot_base__pb2.ExecutePlanRequest.SerializeToString,
            spark_dot_connect_dot_base__pb2.ExecutePlanResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def AnalyzePlan(
        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,
            "/spark.connect.SparkConnectService/AnalyzePlan",
            spark_dot_connect_dot_base__pb2.AnalyzePlanRequest.SerializeToString,
            spark_dot_connect_dot_base__pb2.AnalyzePlanResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def Config(
        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,
            "/spark.connect.SparkConnectService/Config",
            spark_dot_connect_dot_base__pb2.ConfigRequest.SerializeToString,
            spark_dot_connect_dot_base__pb2.ConfigResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def AddArtifacts(
        request_iterator,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.stream_unary(
            request_iterator,
            target,
            "/spark.connect.SparkConnectService/AddArtifacts",
            spark_dot_connect_dot_base__pb2.AddArtifactsRequest.SerializeToString,
            spark_dot_connect_dot_base__pb2.AddArtifactsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ArtifactStatus(
        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,
            "/spark.connect.SparkConnectService/ArtifactStatus",
            spark_dot_connect_dot_base__pb2.ArtifactStatusesRequest.SerializeToString,
            spark_dot_connect_dot_base__pb2.ArtifactStatusesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def Interrupt(
        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,
            "/spark.connect.SparkConnectService/Interrupt",
            spark_dot_connect_dot_base__pb2.InterruptRequest.SerializeToString,
            spark_dot_connect_dot_base__pb2.InterruptResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ReattachExecute(
        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_stream(
            request,
            target,
            "/spark.connect.SparkConnectService/ReattachExecute",
            spark_dot_connect_dot_base__pb2.ReattachExecuteRequest.SerializeToString,
            spark_dot_connect_dot_base__pb2.ExecutePlanResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ReleaseExecute(
        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,
            "/spark.connect.SparkConnectService/ReleaseExecute",
            spark_dot_connect_dot_base__pb2.ReleaseExecuteRequest.SerializeToString,
            spark_dot_connect_dot_base__pb2.ReleaseExecuteResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ReleaseSession(
        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,
            "/spark.connect.SparkConnectService/ReleaseSession",
            spark_dot_connect_dot_base__pb2.ReleaseSessionRequest.SerializeToString,
            spark_dot_connect_dot_base__pb2.ReleaseSessionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def FetchErrorDetails(
        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,
            "/spark.connect.SparkConnectService/FetchErrorDetails",
            spark_dot_connect_dot_base__pb2.FetchErrorDetailsRequest.SerializeToString,
            spark_dot_connect_dot_base__pb2.FetchErrorDetailsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def CloneSession(
        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,
            "/spark.connect.SparkConnectService/CloneSession",
            spark_dot_connect_dot_base__pb2.CloneSessionRequest.SerializeToString,
            spark_dot_connect_dot_base__pb2.CloneSessionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetStatus(
        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,
            "/spark.connect.SparkConnectService/GetStatus",
            spark_dot_connect_dot_base__pb2.GetStatusRequest.SerializeToString,
            spark_dot_connect_dot_base__pb2.GetStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )