LocalAI/pkg/grpc/base/base.go

package base

// This is a wrapper to satisfy the GRPC service interface
// It is meant to be used by the main executable that is the server for the specific backend type (falcon, gpt3, etc)
import (
	"context"
	"fmt"
	"os"

	"github.com/mudler/LocalAI/pkg/grpc/grpcerrors"
	pb "github.com/mudler/LocalAI/pkg/grpc/proto"
	gopsutil "github.com/shirou/gopsutil/v3/process"
)

// Base is a base class for all backends to implement
// Note: the backends that does not support multiple requests
// should use SingleThread instead
type Base struct {
}

func (llm *Base) Locking() bool {
	return false
}

func (llm *Base) Lock() {
	panic("not implemented")
}

func (llm *Base) Unlock() {
	panic("not implemented")
}

func (llm *Base) Busy() bool {
	return false
}

func (llm *Base) Load(opts *pb.ModelOptions) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) Predict(opts *pb.PredictOptions) (string, error) {
	return "", fmt.Errorf("unimplemented")
}

func (llm *Base) PredictStream(opts *pb.PredictOptions, results chan string) error {
	close(results)
	return fmt.Errorf("unimplemented")
}

func (llm *Base) Embeddings(opts *pb.PredictOptions) ([]float32, error) {
	return []float32{}, fmt.Errorf("unimplemented")
}

func (llm *Base) GenerateImage(*pb.GenerateImageRequest) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) GenerateVideo(*pb.GenerateVideoRequest) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) Generate3D(*pb.Generate3DRequest) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) Animate3D(*pb.Animate3DRequest) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) UpscaleImage(*pb.UpscaleImageRequest) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) AudioTranscription(context.Context, *pb.TranscriptRequest) (pb.TranscriptResult, error) {
	return pb.TranscriptResult{}, fmt.Errorf("unimplemented")
}

func (llm *Base) AudioTranscriptionStream(context.Context, *pb.TranscriptRequest, chan *pb.TranscriptStreamResponse) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) TTS(*pb.TTSRequest) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) TTSStream(*pb.TTSRequest, chan []byte) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) SoundGeneration(*pb.SoundGenerationRequest) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) Detect(*pb.DetectOptions) (pb.DetectResponse, error) {
	return pb.DetectResponse{}, fmt.Errorf("unimplemented")
}

func (llm *Base) Depth(*pb.DepthRequest) (pb.DepthResponse, error) {
	return pb.DepthResponse{}, fmt.Errorf("unimplemented")
}

func (llm *Base) FaceVerify(*pb.FaceVerifyRequest) (pb.FaceVerifyResponse, error) {
	return pb.FaceVerifyResponse{}, fmt.Errorf("unimplemented")
}

func (llm *Base) FaceAnalyze(*pb.FaceAnalyzeRequest) (pb.FaceAnalyzeResponse, error) {
	return pb.FaceAnalyzeResponse{}, fmt.Errorf("unimplemented")
}

func (llm *Base) VoiceVerify(*pb.VoiceVerifyRequest) (pb.VoiceVerifyResponse, error) {
	return pb.VoiceVerifyResponse{}, fmt.Errorf("unimplemented")
}

func (llm *Base) VoiceAnalyze(*pb.VoiceAnalyzeRequest) (pb.VoiceAnalyzeResponse, error) {
	return pb.VoiceAnalyzeResponse{}, fmt.Errorf("unimplemented")
}

func (llm *Base) VoiceEmbed(*pb.VoiceEmbedRequest) (pb.VoiceEmbedResponse, error) {
	return pb.VoiceEmbedResponse{}, fmt.Errorf("unimplemented")
}

func (llm *Base) Diarize(*pb.DiarizeRequest) (pb.DiarizeResponse, error) {
	return pb.DiarizeResponse{}, fmt.Errorf("unimplemented")
}

func (llm *Base) SoundDetection(context.Context, *pb.SoundDetectionRequest) (*pb.SoundDetectionResponse, error) {
	return nil, fmt.Errorf("unimplemented")
}

func (llm *Base) TokenizeString(opts *pb.PredictOptions) (pb.TokenizationResponse, error) {
	return pb.TokenizationResponse{}, fmt.Errorf("unimplemented")
}

func (llm *Base) Detokenize(req *pb.DetokenizeRequest) (pb.DetokenizeResponse, error) {
	return pb.DetokenizeResponse{}, fmt.Errorf("unimplemented")
}

func (llm *Base) ModelMetadata(opts *pb.ModelOptions) (*pb.ModelMetadataResponse, error) {
	return nil, fmt.Errorf("unimplemented")
}

// backends may wish to call this to capture the gopsutil info, then enhance with additional memory usage details?
func (llm *Base) Status() (pb.StatusResponse, error) {
	return pb.StatusResponse{
		Memory: memoryUsage(),
	}, nil
}

func (llm *Base) StoresSet(*pb.StoresSetOptions) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) StoresGet(*pb.StoresGetOptions) (pb.StoresGetResult, error) {
	return pb.StoresGetResult{}, fmt.Errorf("unimplemented")
}

func (llm *Base) StoresDelete(*pb.StoresDeleteOptions) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) StoresFind(*pb.StoresFindOptions) (pb.StoresFindResult, error) {
	return pb.StoresFindResult{}, fmt.Errorf("unimplemented")
}

func (llm *Base) VAD(*pb.VADRequest) (pb.VADResponse, error) {
	return pb.VADResponse{}, fmt.Errorf("unimplemented")
}

func (llm *Base) AudioEncode(*pb.AudioEncodeRequest) (*pb.AudioEncodeResult, error) {
	return nil, fmt.Errorf("unimplemented")
}

func (llm *Base) AudioDecode(*pb.AudioDecodeRequest) (*pb.AudioDecodeResult, error) {
	return nil, fmt.Errorf("unimplemented")
}

func (llm *Base) AudioTransform(*pb.AudioTransformRequest) (*pb.AudioTransformResult, error) {
	return nil, fmt.Errorf("unimplemented")
}

func (llm *Base) AudioTransformStream(in <-chan *pb.AudioTransformFrameRequest, out chan<- *pb.AudioTransformFrameResponse) error {
	close(out)
	return fmt.Errorf("unimplemented")
}

func (llm *Base) AudioTranscriptionLive(in <-chan *pb.TranscriptLiveRequest, out chan<- *pb.TranscriptLiveResponse) error {
	close(out)
	return grpcerrors.LiveTranscriptionUnsupported("base", "not implemented by this backend")
}

func (llm *Base) AudioToAudioStream(in <-chan *pb.AudioToAudioRequest, out chan<- *pb.AudioToAudioResponse) error {
	close(out)
	return fmt.Errorf("unimplemented")
}

func (llm *Base) Forward(ctx context.Context, in <-chan *pb.ForwardRequest, out chan<- *pb.ForwardReply) error {
	close(out)
	return fmt.Errorf("unimplemented")
}

func (llm *Base) StartFineTune(*pb.FineTuneRequest) (*pb.FineTuneJobResult, error) {
	return nil, fmt.Errorf("unimplemented")
}

func (llm *Base) FineTuneProgress(*pb.FineTuneProgressRequest, chan *pb.FineTuneProgressUpdate) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) StopFineTune(*pb.FineTuneStopRequest) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) ListCheckpoints(*pb.ListCheckpointsRequest) (*pb.ListCheckpointsResponse, error) {
	return nil, fmt.Errorf("unimplemented")
}

func (llm *Base) ExportModel(*pb.ExportModelRequest) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) StartQuantization(*pb.QuantizationRequest) (*pb.QuantizationJobResult, error) {
	return nil, fmt.Errorf("unimplemented")
}

func (llm *Base) QuantizationProgress(*pb.QuantizationProgressRequest, chan *pb.QuantizationProgressUpdate) error {
	return fmt.Errorf("unimplemented")
}

func (llm *Base) StopQuantization(*pb.QuantizationStopRequest) error {
	return fmt.Errorf("unimplemented")
}

func memoryUsage() *pb.MemoryUsageData {
	mud := pb.MemoryUsageData{
		Breakdown: make(map[string]uint64),
	}

	pid := int32(os.Getpid())

	backendProcess, err := gopsutil.NewProcess(pid)

	if err == nil {
		memInfo, err := backendProcess.MemoryInfo()
		if err == nil {
			mud.Total = memInfo.VMS // TEST, but rss seems reasonable first guess. Does include swap, but we might care about that.
			mud.Breakdown["gopsutil-RSS"] = memInfo.RSS
		}
	}
	return &mud
}
func (llm *Base) Free() error {
	return nil
}

func (*Base) MotionStream(context.Context, func() (*pb.MotionRequest, error), func(*pb.MotionResponse) error) error {
	return fmt.Errorf("motion streaming is not supported")
}