mirror of
https://github.com/GayPizzaSpecifications/stable-diffusion-rpc.git
synced 2025-08-03 05:30:54 +00:00
815 lines
29 KiB
Swift
815 lines
29 KiB
Swift
//
|
|
// DO NOT EDIT.
|
|
//
|
|
// Generated by the protocol buffer compiler.
|
|
// Source: StableDiffusion.proto
|
|
//
|
|
|
|
//
|
|
// Copyright 2018, gRPC Authors All rights reserved.
|
|
//
|
|
// Licensed 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.
|
|
//
|
|
import GRPC
|
|
import NIO
|
|
import NIOConcurrencyHelpers
|
|
import SwiftProtobuf
|
|
|
|
|
|
/// Usage: instantiate `SdModelServiceClient`, then call methods of this protocol to make API calls.
|
|
public protocol SdModelServiceClientProtocol: GRPCClient {
|
|
var serviceName: String { get }
|
|
var interceptors: SdModelServiceClientInterceptorFactoryProtocol? { get }
|
|
|
|
func listModels(
|
|
_ request: SdListModelsRequest,
|
|
callOptions: CallOptions?
|
|
) -> UnaryCall<SdListModelsRequest, SdListModelsResponse>
|
|
|
|
func reloadModels(
|
|
_ request: SdReloadModelsRequest,
|
|
callOptions: CallOptions?
|
|
) -> UnaryCall<SdReloadModelsRequest, SdReloadModelsResponse>
|
|
|
|
func loadModel(
|
|
_ request: SdLoadModelRequest,
|
|
callOptions: CallOptions?
|
|
) -> UnaryCall<SdLoadModelRequest, SdLoadModelResponse>
|
|
}
|
|
|
|
extension SdModelServiceClientProtocol {
|
|
public var serviceName: String {
|
|
return "gay.pizza.stable.diffusion.ModelService"
|
|
}
|
|
|
|
/// Unary call to ListModels
|
|
///
|
|
/// - Parameters:
|
|
/// - request: Request to send to ListModels.
|
|
/// - callOptions: Call options.
|
|
/// - Returns: A `UnaryCall` with futures for the metadata, status and response.
|
|
public func listModels(
|
|
_ request: SdListModelsRequest,
|
|
callOptions: CallOptions? = nil
|
|
) -> UnaryCall<SdListModelsRequest, SdListModelsResponse> {
|
|
return self.makeUnaryCall(
|
|
path: SdModelServiceClientMetadata.Methods.listModels.path,
|
|
request: request,
|
|
callOptions: callOptions ?? self.defaultCallOptions,
|
|
interceptors: self.interceptors?.makeListModelsInterceptors() ?? []
|
|
)
|
|
}
|
|
|
|
/// Unary call to ReloadModels
|
|
///
|
|
/// - Parameters:
|
|
/// - request: Request to send to ReloadModels.
|
|
/// - callOptions: Call options.
|
|
/// - Returns: A `UnaryCall` with futures for the metadata, status and response.
|
|
public func reloadModels(
|
|
_ request: SdReloadModelsRequest,
|
|
callOptions: CallOptions? = nil
|
|
) -> UnaryCall<SdReloadModelsRequest, SdReloadModelsResponse> {
|
|
return self.makeUnaryCall(
|
|
path: SdModelServiceClientMetadata.Methods.reloadModels.path,
|
|
request: request,
|
|
callOptions: callOptions ?? self.defaultCallOptions,
|
|
interceptors: self.interceptors?.makeReloadModelsInterceptors() ?? []
|
|
)
|
|
}
|
|
|
|
/// Unary call to LoadModel
|
|
///
|
|
/// - Parameters:
|
|
/// - request: Request to send to LoadModel.
|
|
/// - callOptions: Call options.
|
|
/// - Returns: A `UnaryCall` with futures for the metadata, status and response.
|
|
public func loadModel(
|
|
_ request: SdLoadModelRequest,
|
|
callOptions: CallOptions? = nil
|
|
) -> UnaryCall<SdLoadModelRequest, SdLoadModelResponse> {
|
|
return self.makeUnaryCall(
|
|
path: SdModelServiceClientMetadata.Methods.loadModel.path,
|
|
request: request,
|
|
callOptions: callOptions ?? self.defaultCallOptions,
|
|
interceptors: self.interceptors?.makeLoadModelInterceptors() ?? []
|
|
)
|
|
}
|
|
}
|
|
|
|
#if compiler(>=5.6)
|
|
@available(*, deprecated)
|
|
extension SdModelServiceClient: @unchecked Sendable {}
|
|
#endif // compiler(>=5.6)
|
|
|
|
@available(*, deprecated, renamed: "SdModelServiceNIOClient")
|
|
public final class SdModelServiceClient: SdModelServiceClientProtocol {
|
|
private let lock = Lock()
|
|
private var _defaultCallOptions: CallOptions
|
|
private var _interceptors: SdModelServiceClientInterceptorFactoryProtocol?
|
|
public let channel: GRPCChannel
|
|
public var defaultCallOptions: CallOptions {
|
|
get { self.lock.withLock { return self._defaultCallOptions } }
|
|
set { self.lock.withLockVoid { self._defaultCallOptions = newValue } }
|
|
}
|
|
public var interceptors: SdModelServiceClientInterceptorFactoryProtocol? {
|
|
get { self.lock.withLock { return self._interceptors } }
|
|
set { self.lock.withLockVoid { self._interceptors = newValue } }
|
|
}
|
|
|
|
/// Creates a client for the gay.pizza.stable.diffusion.ModelService service.
|
|
///
|
|
/// - Parameters:
|
|
/// - channel: `GRPCChannel` to the service host.
|
|
/// - defaultCallOptions: Options to use for each service call if the user doesn't provide them.
|
|
/// - interceptors: A factory providing interceptors for each RPC.
|
|
public init(
|
|
channel: GRPCChannel,
|
|
defaultCallOptions: CallOptions = CallOptions(),
|
|
interceptors: SdModelServiceClientInterceptorFactoryProtocol? = nil
|
|
) {
|
|
self.channel = channel
|
|
self._defaultCallOptions = defaultCallOptions
|
|
self._interceptors = interceptors
|
|
}
|
|
}
|
|
|
|
public struct SdModelServiceNIOClient: SdModelServiceClientProtocol {
|
|
public var channel: GRPCChannel
|
|
public var defaultCallOptions: CallOptions
|
|
public var interceptors: SdModelServiceClientInterceptorFactoryProtocol?
|
|
|
|
/// Creates a client for the gay.pizza.stable.diffusion.ModelService service.
|
|
///
|
|
/// - Parameters:
|
|
/// - channel: `GRPCChannel` to the service host.
|
|
/// - defaultCallOptions: Options to use for each service call if the user doesn't provide them.
|
|
/// - interceptors: A factory providing interceptors for each RPC.
|
|
public init(
|
|
channel: GRPCChannel,
|
|
defaultCallOptions: CallOptions = CallOptions(),
|
|
interceptors: SdModelServiceClientInterceptorFactoryProtocol? = nil
|
|
) {
|
|
self.channel = channel
|
|
self.defaultCallOptions = defaultCallOptions
|
|
self.interceptors = interceptors
|
|
}
|
|
}
|
|
|
|
#if compiler(>=5.6)
|
|
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
|
|
public protocol SdModelServiceAsyncClientProtocol: GRPCClient {
|
|
static var serviceDescriptor: GRPCServiceDescriptor { get }
|
|
var interceptors: SdModelServiceClientInterceptorFactoryProtocol? { get }
|
|
|
|
func makeListModelsCall(
|
|
_ request: SdListModelsRequest,
|
|
callOptions: CallOptions?
|
|
) -> GRPCAsyncUnaryCall<SdListModelsRequest, SdListModelsResponse>
|
|
|
|
func makeReloadModelsCall(
|
|
_ request: SdReloadModelsRequest,
|
|
callOptions: CallOptions?
|
|
) -> GRPCAsyncUnaryCall<SdReloadModelsRequest, SdReloadModelsResponse>
|
|
|
|
func makeLoadModelCall(
|
|
_ request: SdLoadModelRequest,
|
|
callOptions: CallOptions?
|
|
) -> GRPCAsyncUnaryCall<SdLoadModelRequest, SdLoadModelResponse>
|
|
}
|
|
|
|
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
|
|
extension SdModelServiceAsyncClientProtocol {
|
|
public static var serviceDescriptor: GRPCServiceDescriptor {
|
|
return SdModelServiceClientMetadata.serviceDescriptor
|
|
}
|
|
|
|
public var interceptors: SdModelServiceClientInterceptorFactoryProtocol? {
|
|
return nil
|
|
}
|
|
|
|
public func makeListModelsCall(
|
|
_ request: SdListModelsRequest,
|
|
callOptions: CallOptions? = nil
|
|
) -> GRPCAsyncUnaryCall<SdListModelsRequest, SdListModelsResponse> {
|
|
return self.makeAsyncUnaryCall(
|
|
path: SdModelServiceClientMetadata.Methods.listModels.path,
|
|
request: request,
|
|
callOptions: callOptions ?? self.defaultCallOptions,
|
|
interceptors: self.interceptors?.makeListModelsInterceptors() ?? []
|
|
)
|
|
}
|
|
|
|
public func makeReloadModelsCall(
|
|
_ request: SdReloadModelsRequest,
|
|
callOptions: CallOptions? = nil
|
|
) -> GRPCAsyncUnaryCall<SdReloadModelsRequest, SdReloadModelsResponse> {
|
|
return self.makeAsyncUnaryCall(
|
|
path: SdModelServiceClientMetadata.Methods.reloadModels.path,
|
|
request: request,
|
|
callOptions: callOptions ?? self.defaultCallOptions,
|
|
interceptors: self.interceptors?.makeReloadModelsInterceptors() ?? []
|
|
)
|
|
}
|
|
|
|
public func makeLoadModelCall(
|
|
_ request: SdLoadModelRequest,
|
|
callOptions: CallOptions? = nil
|
|
) -> GRPCAsyncUnaryCall<SdLoadModelRequest, SdLoadModelResponse> {
|
|
return self.makeAsyncUnaryCall(
|
|
path: SdModelServiceClientMetadata.Methods.loadModel.path,
|
|
request: request,
|
|
callOptions: callOptions ?? self.defaultCallOptions,
|
|
interceptors: self.interceptors?.makeLoadModelInterceptors() ?? []
|
|
)
|
|
}
|
|
}
|
|
|
|
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
|
|
extension SdModelServiceAsyncClientProtocol {
|
|
public func listModels(
|
|
_ request: SdListModelsRequest,
|
|
callOptions: CallOptions? = nil
|
|
) async throws -> SdListModelsResponse {
|
|
return try await self.performAsyncUnaryCall(
|
|
path: SdModelServiceClientMetadata.Methods.listModels.path,
|
|
request: request,
|
|
callOptions: callOptions ?? self.defaultCallOptions,
|
|
interceptors: self.interceptors?.makeListModelsInterceptors() ?? []
|
|
)
|
|
}
|
|
|
|
public func reloadModels(
|
|
_ request: SdReloadModelsRequest,
|
|
callOptions: CallOptions? = nil
|
|
) async throws -> SdReloadModelsResponse {
|
|
return try await self.performAsyncUnaryCall(
|
|
path: SdModelServiceClientMetadata.Methods.reloadModels.path,
|
|
request: request,
|
|
callOptions: callOptions ?? self.defaultCallOptions,
|
|
interceptors: self.interceptors?.makeReloadModelsInterceptors() ?? []
|
|
)
|
|
}
|
|
|
|
public func loadModel(
|
|
_ request: SdLoadModelRequest,
|
|
callOptions: CallOptions? = nil
|
|
) async throws -> SdLoadModelResponse {
|
|
return try await self.performAsyncUnaryCall(
|
|
path: SdModelServiceClientMetadata.Methods.loadModel.path,
|
|
request: request,
|
|
callOptions: callOptions ?? self.defaultCallOptions,
|
|
interceptors: self.interceptors?.makeLoadModelInterceptors() ?? []
|
|
)
|
|
}
|
|
}
|
|
|
|
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
|
|
public struct SdModelServiceAsyncClient: SdModelServiceAsyncClientProtocol {
|
|
public var channel: GRPCChannel
|
|
public var defaultCallOptions: CallOptions
|
|
public var interceptors: SdModelServiceClientInterceptorFactoryProtocol?
|
|
|
|
public init(
|
|
channel: GRPCChannel,
|
|
defaultCallOptions: CallOptions = CallOptions(),
|
|
interceptors: SdModelServiceClientInterceptorFactoryProtocol? = nil
|
|
) {
|
|
self.channel = channel
|
|
self.defaultCallOptions = defaultCallOptions
|
|
self.interceptors = interceptors
|
|
}
|
|
}
|
|
|
|
#endif // compiler(>=5.6)
|
|
|
|
public protocol SdModelServiceClientInterceptorFactoryProtocol: GRPCSendable {
|
|
|
|
/// - Returns: Interceptors to use when invoking 'listModels'.
|
|
func makeListModelsInterceptors() -> [ClientInterceptor<SdListModelsRequest, SdListModelsResponse>]
|
|
|
|
/// - Returns: Interceptors to use when invoking 'reloadModels'.
|
|
func makeReloadModelsInterceptors() -> [ClientInterceptor<SdReloadModelsRequest, SdReloadModelsResponse>]
|
|
|
|
/// - Returns: Interceptors to use when invoking 'loadModel'.
|
|
func makeLoadModelInterceptors() -> [ClientInterceptor<SdLoadModelRequest, SdLoadModelResponse>]
|
|
}
|
|
|
|
public enum SdModelServiceClientMetadata {
|
|
public static let serviceDescriptor = GRPCServiceDescriptor(
|
|
name: "ModelService",
|
|
fullName: "gay.pizza.stable.diffusion.ModelService",
|
|
methods: [
|
|
SdModelServiceClientMetadata.Methods.listModels,
|
|
SdModelServiceClientMetadata.Methods.reloadModels,
|
|
SdModelServiceClientMetadata.Methods.loadModel,
|
|
]
|
|
)
|
|
|
|
public enum Methods {
|
|
public static let listModels = GRPCMethodDescriptor(
|
|
name: "ListModels",
|
|
path: "/gay.pizza.stable.diffusion.ModelService/ListModels",
|
|
type: GRPCCallType.unary
|
|
)
|
|
|
|
public static let reloadModels = GRPCMethodDescriptor(
|
|
name: "ReloadModels",
|
|
path: "/gay.pizza.stable.diffusion.ModelService/ReloadModels",
|
|
type: GRPCCallType.unary
|
|
)
|
|
|
|
public static let loadModel = GRPCMethodDescriptor(
|
|
name: "LoadModel",
|
|
path: "/gay.pizza.stable.diffusion.ModelService/LoadModel",
|
|
type: GRPCCallType.unary
|
|
)
|
|
}
|
|
}
|
|
|
|
/// Usage: instantiate `SdImageGenerationServiceClient`, then call methods of this protocol to make API calls.
|
|
public protocol SdImageGenerationServiceClientProtocol: GRPCClient {
|
|
var serviceName: String { get }
|
|
var interceptors: SdImageGenerationServiceClientInterceptorFactoryProtocol? { get }
|
|
|
|
func generateImage(
|
|
_ request: SdGenerateImagesRequest,
|
|
callOptions: CallOptions?
|
|
) -> UnaryCall<SdGenerateImagesRequest, SdGenerateImagesResponse>
|
|
}
|
|
|
|
extension SdImageGenerationServiceClientProtocol {
|
|
public var serviceName: String {
|
|
return "gay.pizza.stable.diffusion.ImageGenerationService"
|
|
}
|
|
|
|
/// Unary call to GenerateImage
|
|
///
|
|
/// - Parameters:
|
|
/// - request: Request to send to GenerateImage.
|
|
/// - callOptions: Call options.
|
|
/// - Returns: A `UnaryCall` with futures for the metadata, status and response.
|
|
public func generateImage(
|
|
_ request: SdGenerateImagesRequest,
|
|
callOptions: CallOptions? = nil
|
|
) -> UnaryCall<SdGenerateImagesRequest, SdGenerateImagesResponse> {
|
|
return self.makeUnaryCall(
|
|
path: SdImageGenerationServiceClientMetadata.Methods.generateImage.path,
|
|
request: request,
|
|
callOptions: callOptions ?? self.defaultCallOptions,
|
|
interceptors: self.interceptors?.makeGenerateImageInterceptors() ?? []
|
|
)
|
|
}
|
|
}
|
|
|
|
#if compiler(>=5.6)
|
|
@available(*, deprecated)
|
|
extension SdImageGenerationServiceClient: @unchecked Sendable {}
|
|
#endif // compiler(>=5.6)
|
|
|
|
@available(*, deprecated, renamed: "SdImageGenerationServiceNIOClient")
|
|
public final class SdImageGenerationServiceClient: SdImageGenerationServiceClientProtocol {
|
|
private let lock = Lock()
|
|
private var _defaultCallOptions: CallOptions
|
|
private var _interceptors: SdImageGenerationServiceClientInterceptorFactoryProtocol?
|
|
public let channel: GRPCChannel
|
|
public var defaultCallOptions: CallOptions {
|
|
get { self.lock.withLock { return self._defaultCallOptions } }
|
|
set { self.lock.withLockVoid { self._defaultCallOptions = newValue } }
|
|
}
|
|
public var interceptors: SdImageGenerationServiceClientInterceptorFactoryProtocol? {
|
|
get { self.lock.withLock { return self._interceptors } }
|
|
set { self.lock.withLockVoid { self._interceptors = newValue } }
|
|
}
|
|
|
|
/// Creates a client for the gay.pizza.stable.diffusion.ImageGenerationService service.
|
|
///
|
|
/// - Parameters:
|
|
/// - channel: `GRPCChannel` to the service host.
|
|
/// - defaultCallOptions: Options to use for each service call if the user doesn't provide them.
|
|
/// - interceptors: A factory providing interceptors for each RPC.
|
|
public init(
|
|
channel: GRPCChannel,
|
|
defaultCallOptions: CallOptions = CallOptions(),
|
|
interceptors: SdImageGenerationServiceClientInterceptorFactoryProtocol? = nil
|
|
) {
|
|
self.channel = channel
|
|
self._defaultCallOptions = defaultCallOptions
|
|
self._interceptors = interceptors
|
|
}
|
|
}
|
|
|
|
public struct SdImageGenerationServiceNIOClient: SdImageGenerationServiceClientProtocol {
|
|
public var channel: GRPCChannel
|
|
public var defaultCallOptions: CallOptions
|
|
public var interceptors: SdImageGenerationServiceClientInterceptorFactoryProtocol?
|
|
|
|
/// Creates a client for the gay.pizza.stable.diffusion.ImageGenerationService service.
|
|
///
|
|
/// - Parameters:
|
|
/// - channel: `GRPCChannel` to the service host.
|
|
/// - defaultCallOptions: Options to use for each service call if the user doesn't provide them.
|
|
/// - interceptors: A factory providing interceptors for each RPC.
|
|
public init(
|
|
channel: GRPCChannel,
|
|
defaultCallOptions: CallOptions = CallOptions(),
|
|
interceptors: SdImageGenerationServiceClientInterceptorFactoryProtocol? = nil
|
|
) {
|
|
self.channel = channel
|
|
self.defaultCallOptions = defaultCallOptions
|
|
self.interceptors = interceptors
|
|
}
|
|
}
|
|
|
|
#if compiler(>=5.6)
|
|
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
|
|
public protocol SdImageGenerationServiceAsyncClientProtocol: GRPCClient {
|
|
static var serviceDescriptor: GRPCServiceDescriptor { get }
|
|
var interceptors: SdImageGenerationServiceClientInterceptorFactoryProtocol? { get }
|
|
|
|
func makeGenerateImageCall(
|
|
_ request: SdGenerateImagesRequest,
|
|
callOptions: CallOptions?
|
|
) -> GRPCAsyncUnaryCall<SdGenerateImagesRequest, SdGenerateImagesResponse>
|
|
}
|
|
|
|
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
|
|
extension SdImageGenerationServiceAsyncClientProtocol {
|
|
public static var serviceDescriptor: GRPCServiceDescriptor {
|
|
return SdImageGenerationServiceClientMetadata.serviceDescriptor
|
|
}
|
|
|
|
public var interceptors: SdImageGenerationServiceClientInterceptorFactoryProtocol? {
|
|
return nil
|
|
}
|
|
|
|
public func makeGenerateImageCall(
|
|
_ request: SdGenerateImagesRequest,
|
|
callOptions: CallOptions? = nil
|
|
) -> GRPCAsyncUnaryCall<SdGenerateImagesRequest, SdGenerateImagesResponse> {
|
|
return self.makeAsyncUnaryCall(
|
|
path: SdImageGenerationServiceClientMetadata.Methods.generateImage.path,
|
|
request: request,
|
|
callOptions: callOptions ?? self.defaultCallOptions,
|
|
interceptors: self.interceptors?.makeGenerateImageInterceptors() ?? []
|
|
)
|
|
}
|
|
}
|
|
|
|
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
|
|
extension SdImageGenerationServiceAsyncClientProtocol {
|
|
public func generateImage(
|
|
_ request: SdGenerateImagesRequest,
|
|
callOptions: CallOptions? = nil
|
|
) async throws -> SdGenerateImagesResponse {
|
|
return try await self.performAsyncUnaryCall(
|
|
path: SdImageGenerationServiceClientMetadata.Methods.generateImage.path,
|
|
request: request,
|
|
callOptions: callOptions ?? self.defaultCallOptions,
|
|
interceptors: self.interceptors?.makeGenerateImageInterceptors() ?? []
|
|
)
|
|
}
|
|
}
|
|
|
|
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
|
|
public struct SdImageGenerationServiceAsyncClient: SdImageGenerationServiceAsyncClientProtocol {
|
|
public var channel: GRPCChannel
|
|
public var defaultCallOptions: CallOptions
|
|
public var interceptors: SdImageGenerationServiceClientInterceptorFactoryProtocol?
|
|
|
|
public init(
|
|
channel: GRPCChannel,
|
|
defaultCallOptions: CallOptions = CallOptions(),
|
|
interceptors: SdImageGenerationServiceClientInterceptorFactoryProtocol? = nil
|
|
) {
|
|
self.channel = channel
|
|
self.defaultCallOptions = defaultCallOptions
|
|
self.interceptors = interceptors
|
|
}
|
|
}
|
|
|
|
#endif // compiler(>=5.6)
|
|
|
|
public protocol SdImageGenerationServiceClientInterceptorFactoryProtocol: GRPCSendable {
|
|
|
|
/// - Returns: Interceptors to use when invoking 'generateImage'.
|
|
func makeGenerateImageInterceptors() -> [ClientInterceptor<SdGenerateImagesRequest, SdGenerateImagesResponse>]
|
|
}
|
|
|
|
public enum SdImageGenerationServiceClientMetadata {
|
|
public static let serviceDescriptor = GRPCServiceDescriptor(
|
|
name: "ImageGenerationService",
|
|
fullName: "gay.pizza.stable.diffusion.ImageGenerationService",
|
|
methods: [
|
|
SdImageGenerationServiceClientMetadata.Methods.generateImage,
|
|
]
|
|
)
|
|
|
|
public enum Methods {
|
|
public static let generateImage = GRPCMethodDescriptor(
|
|
name: "GenerateImage",
|
|
path: "/gay.pizza.stable.diffusion.ImageGenerationService/GenerateImage",
|
|
type: GRPCCallType.unary
|
|
)
|
|
}
|
|
}
|
|
|
|
/// To build a server, implement a class that conforms to this protocol.
|
|
public protocol SdModelServiceProvider: CallHandlerProvider {
|
|
var interceptors: SdModelServiceServerInterceptorFactoryProtocol? { get }
|
|
|
|
func listModels(request: SdListModelsRequest, context: StatusOnlyCallContext) -> EventLoopFuture<SdListModelsResponse>
|
|
|
|
func reloadModels(request: SdReloadModelsRequest, context: StatusOnlyCallContext) -> EventLoopFuture<SdReloadModelsResponse>
|
|
|
|
func loadModel(request: SdLoadModelRequest, context: StatusOnlyCallContext) -> EventLoopFuture<SdLoadModelResponse>
|
|
}
|
|
|
|
extension SdModelServiceProvider {
|
|
public var serviceName: Substring {
|
|
return SdModelServiceServerMetadata.serviceDescriptor.fullName[...]
|
|
}
|
|
|
|
/// Determines, calls and returns the appropriate request handler, depending on the request's method.
|
|
/// Returns nil for methods not handled by this service.
|
|
public func handle(
|
|
method name: Substring,
|
|
context: CallHandlerContext
|
|
) -> GRPCServerHandlerProtocol? {
|
|
switch name {
|
|
case "ListModels":
|
|
return UnaryServerHandler(
|
|
context: context,
|
|
requestDeserializer: ProtobufDeserializer<SdListModelsRequest>(),
|
|
responseSerializer: ProtobufSerializer<SdListModelsResponse>(),
|
|
interceptors: self.interceptors?.makeListModelsInterceptors() ?? [],
|
|
userFunction: self.listModels(request:context:)
|
|
)
|
|
|
|
case "ReloadModels":
|
|
return UnaryServerHandler(
|
|
context: context,
|
|
requestDeserializer: ProtobufDeserializer<SdReloadModelsRequest>(),
|
|
responseSerializer: ProtobufSerializer<SdReloadModelsResponse>(),
|
|
interceptors: self.interceptors?.makeReloadModelsInterceptors() ?? [],
|
|
userFunction: self.reloadModels(request:context:)
|
|
)
|
|
|
|
case "LoadModel":
|
|
return UnaryServerHandler(
|
|
context: context,
|
|
requestDeserializer: ProtobufDeserializer<SdLoadModelRequest>(),
|
|
responseSerializer: ProtobufSerializer<SdLoadModelResponse>(),
|
|
interceptors: self.interceptors?.makeLoadModelInterceptors() ?? [],
|
|
userFunction: self.loadModel(request:context:)
|
|
)
|
|
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
#if compiler(>=5.6)
|
|
|
|
/// To implement a server, implement an object which conforms to this protocol.
|
|
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
|
|
public protocol SdModelServiceAsyncProvider: CallHandlerProvider {
|
|
static var serviceDescriptor: GRPCServiceDescriptor { get }
|
|
var interceptors: SdModelServiceServerInterceptorFactoryProtocol? { get }
|
|
|
|
@Sendable func listModels(
|
|
request: SdListModelsRequest,
|
|
context: GRPCAsyncServerCallContext
|
|
) async throws -> SdListModelsResponse
|
|
|
|
@Sendable func reloadModels(
|
|
request: SdReloadModelsRequest,
|
|
context: GRPCAsyncServerCallContext
|
|
) async throws -> SdReloadModelsResponse
|
|
|
|
@Sendable func loadModel(
|
|
request: SdLoadModelRequest,
|
|
context: GRPCAsyncServerCallContext
|
|
) async throws -> SdLoadModelResponse
|
|
}
|
|
|
|
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
|
|
extension SdModelServiceAsyncProvider {
|
|
public static var serviceDescriptor: GRPCServiceDescriptor {
|
|
return SdModelServiceServerMetadata.serviceDescriptor
|
|
}
|
|
|
|
public var serviceName: Substring {
|
|
return SdModelServiceServerMetadata.serviceDescriptor.fullName[...]
|
|
}
|
|
|
|
public var interceptors: SdModelServiceServerInterceptorFactoryProtocol? {
|
|
return nil
|
|
}
|
|
|
|
public func handle(
|
|
method name: Substring,
|
|
context: CallHandlerContext
|
|
) -> GRPCServerHandlerProtocol? {
|
|
switch name {
|
|
case "ListModels":
|
|
return GRPCAsyncServerHandler(
|
|
context: context,
|
|
requestDeserializer: ProtobufDeserializer<SdListModelsRequest>(),
|
|
responseSerializer: ProtobufSerializer<SdListModelsResponse>(),
|
|
interceptors: self.interceptors?.makeListModelsInterceptors() ?? [],
|
|
wrapping: self.listModels(request:context:)
|
|
)
|
|
|
|
case "ReloadModels":
|
|
return GRPCAsyncServerHandler(
|
|
context: context,
|
|
requestDeserializer: ProtobufDeserializer<SdReloadModelsRequest>(),
|
|
responseSerializer: ProtobufSerializer<SdReloadModelsResponse>(),
|
|
interceptors: self.interceptors?.makeReloadModelsInterceptors() ?? [],
|
|
wrapping: self.reloadModels(request:context:)
|
|
)
|
|
|
|
case "LoadModel":
|
|
return GRPCAsyncServerHandler(
|
|
context: context,
|
|
requestDeserializer: ProtobufDeserializer<SdLoadModelRequest>(),
|
|
responseSerializer: ProtobufSerializer<SdLoadModelResponse>(),
|
|
interceptors: self.interceptors?.makeLoadModelInterceptors() ?? [],
|
|
wrapping: self.loadModel(request:context:)
|
|
)
|
|
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // compiler(>=5.6)
|
|
|
|
public protocol SdModelServiceServerInterceptorFactoryProtocol {
|
|
|
|
/// - Returns: Interceptors to use when handling 'listModels'.
|
|
/// Defaults to calling `self.makeInterceptors()`.
|
|
func makeListModelsInterceptors() -> [ServerInterceptor<SdListModelsRequest, SdListModelsResponse>]
|
|
|
|
/// - Returns: Interceptors to use when handling 'reloadModels'.
|
|
/// Defaults to calling `self.makeInterceptors()`.
|
|
func makeReloadModelsInterceptors() -> [ServerInterceptor<SdReloadModelsRequest, SdReloadModelsResponse>]
|
|
|
|
/// - Returns: Interceptors to use when handling 'loadModel'.
|
|
/// Defaults to calling `self.makeInterceptors()`.
|
|
func makeLoadModelInterceptors() -> [ServerInterceptor<SdLoadModelRequest, SdLoadModelResponse>]
|
|
}
|
|
|
|
public enum SdModelServiceServerMetadata {
|
|
public static let serviceDescriptor = GRPCServiceDescriptor(
|
|
name: "ModelService",
|
|
fullName: "gay.pizza.stable.diffusion.ModelService",
|
|
methods: [
|
|
SdModelServiceServerMetadata.Methods.listModels,
|
|
SdModelServiceServerMetadata.Methods.reloadModels,
|
|
SdModelServiceServerMetadata.Methods.loadModel,
|
|
]
|
|
)
|
|
|
|
public enum Methods {
|
|
public static let listModels = GRPCMethodDescriptor(
|
|
name: "ListModels",
|
|
path: "/gay.pizza.stable.diffusion.ModelService/ListModels",
|
|
type: GRPCCallType.unary
|
|
)
|
|
|
|
public static let reloadModels = GRPCMethodDescriptor(
|
|
name: "ReloadModels",
|
|
path: "/gay.pizza.stable.diffusion.ModelService/ReloadModels",
|
|
type: GRPCCallType.unary
|
|
)
|
|
|
|
public static let loadModel = GRPCMethodDescriptor(
|
|
name: "LoadModel",
|
|
path: "/gay.pizza.stable.diffusion.ModelService/LoadModel",
|
|
type: GRPCCallType.unary
|
|
)
|
|
}
|
|
}
|
|
/// To build a server, implement a class that conforms to this protocol.
|
|
public protocol SdImageGenerationServiceProvider: CallHandlerProvider {
|
|
var interceptors: SdImageGenerationServiceServerInterceptorFactoryProtocol? { get }
|
|
|
|
func generateImage(request: SdGenerateImagesRequest, context: StatusOnlyCallContext) -> EventLoopFuture<SdGenerateImagesResponse>
|
|
}
|
|
|
|
extension SdImageGenerationServiceProvider {
|
|
public var serviceName: Substring {
|
|
return SdImageGenerationServiceServerMetadata.serviceDescriptor.fullName[...]
|
|
}
|
|
|
|
/// Determines, calls and returns the appropriate request handler, depending on the request's method.
|
|
/// Returns nil for methods not handled by this service.
|
|
public func handle(
|
|
method name: Substring,
|
|
context: CallHandlerContext
|
|
) -> GRPCServerHandlerProtocol? {
|
|
switch name {
|
|
case "GenerateImage":
|
|
return UnaryServerHandler(
|
|
context: context,
|
|
requestDeserializer: ProtobufDeserializer<SdGenerateImagesRequest>(),
|
|
responseSerializer: ProtobufSerializer<SdGenerateImagesResponse>(),
|
|
interceptors: self.interceptors?.makeGenerateImageInterceptors() ?? [],
|
|
userFunction: self.generateImage(request:context:)
|
|
)
|
|
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
#if compiler(>=5.6)
|
|
|
|
/// To implement a server, implement an object which conforms to this protocol.
|
|
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
|
|
public protocol SdImageGenerationServiceAsyncProvider: CallHandlerProvider {
|
|
static var serviceDescriptor: GRPCServiceDescriptor { get }
|
|
var interceptors: SdImageGenerationServiceServerInterceptorFactoryProtocol? { get }
|
|
|
|
@Sendable func generateImage(
|
|
request: SdGenerateImagesRequest,
|
|
context: GRPCAsyncServerCallContext
|
|
) async throws -> SdGenerateImagesResponse
|
|
}
|
|
|
|
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
|
|
extension SdImageGenerationServiceAsyncProvider {
|
|
public static var serviceDescriptor: GRPCServiceDescriptor {
|
|
return SdImageGenerationServiceServerMetadata.serviceDescriptor
|
|
}
|
|
|
|
public var serviceName: Substring {
|
|
return SdImageGenerationServiceServerMetadata.serviceDescriptor.fullName[...]
|
|
}
|
|
|
|
public var interceptors: SdImageGenerationServiceServerInterceptorFactoryProtocol? {
|
|
return nil
|
|
}
|
|
|
|
public func handle(
|
|
method name: Substring,
|
|
context: CallHandlerContext
|
|
) -> GRPCServerHandlerProtocol? {
|
|
switch name {
|
|
case "GenerateImage":
|
|
return GRPCAsyncServerHandler(
|
|
context: context,
|
|
requestDeserializer: ProtobufDeserializer<SdGenerateImagesRequest>(),
|
|
responseSerializer: ProtobufSerializer<SdGenerateImagesResponse>(),
|
|
interceptors: self.interceptors?.makeGenerateImageInterceptors() ?? [],
|
|
wrapping: self.generateImage(request:context:)
|
|
)
|
|
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // compiler(>=5.6)
|
|
|
|
public protocol SdImageGenerationServiceServerInterceptorFactoryProtocol {
|
|
|
|
/// - Returns: Interceptors to use when handling 'generateImage'.
|
|
/// Defaults to calling `self.makeInterceptors()`.
|
|
func makeGenerateImageInterceptors() -> [ServerInterceptor<SdGenerateImagesRequest, SdGenerateImagesResponse>]
|
|
}
|
|
|
|
public enum SdImageGenerationServiceServerMetadata {
|
|
public static let serviceDescriptor = GRPCServiceDescriptor(
|
|
name: "ImageGenerationService",
|
|
fullName: "gay.pizza.stable.diffusion.ImageGenerationService",
|
|
methods: [
|
|
SdImageGenerationServiceServerMetadata.Methods.generateImage,
|
|
]
|
|
)
|
|
|
|
public enum Methods {
|
|
public static let generateImage = GRPCMethodDescriptor(
|
|
name: "GenerateImage",
|
|
path: "/gay.pizza.stable.diffusion.ImageGenerationService/GenerateImage",
|
|
type: GRPCCallType.unary
|
|
)
|
|
}
|
|
}
|