Skip to content

armgit / uzu

Public Imported from GitHub
0

A high-performance inference engine for AI models

3.7 KB
Raw Blame
import Foundation
import Observation
import Uzu

// MARK: - Supporting Types

extension TextToSpeechModel {
    enum ViewState {
        case loading
        case idle
        case generating
        case error(Swift.Error)
    }
}

struct GenerationError: Swift.Error {
    let message: String
}

@Observable
final class TextToSpeechModel {

    // MARK: - Publicly observed properties
    var viewState: ViewState = .idle
    var inputText: String = ""
    var outputPath: URL?

    // MARK: - Private
    private let identifier: String
    private var session: TextToSpeechSession?
    private var loadingTask: Task<Void, Never>?
    private var generationTask: Task<Void, Never>?

    init(identifier: String) {
        self.identifier = identifier
    }

    // MARK: - Lifecycle

    @MainActor
    func loadSession(using engineWrapper: EngineObservableWrapper) {
        guard
            case .idle = viewState,
            let engine = engineWrapper.engine,
            let model = engineWrapper.models.first(where: { $0.identifier == identifier }) else {
            return
        }

        if self.session != nil {
            tearDown()
        }

        self.viewState = .loading

        loadingTask?.cancel()
        loadingTask = Task.detached { [weak self] in
            guard let self else { return }
            let session: TextToSpeechSession?
            let newState: ViewState
            do {
                session = try await engine.textToSpeech(model: model)
                newState = .idle
            } catch {
                session = nil
                newState = .error(error)
            }
            await MainActor.run { [weak self] in
                guard let self else { return }
                self.session = session
                self.viewState = newState
                self.loadingTask = nil
            }
        }
    }

    // MARK: - User intents
    func generate() {
        guard case .idle = viewState,
            let session,
            !inputText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
        else { return }
        
        let input = inputText.trimmingCharacters(in: .whitespacesAndNewlines)
        viewState = .generating
        outputPath = nil

        generationTask?.cancel()
        generationTask = Task.detached { [weak self] in
            guard let self else { return }

            let resultPath = URL.documentsDirectory.appendingPathComponent("tts_output.wav")
            var generationError: Swift.Error? = nil
            do {
                if FileManager.default.fileExists(atPath: resultPath.path) {
                    try FileManager.default.removeItem(at: resultPath)
                }
                let output = try await session.synthesize(input: input)
                try output.pcmBatch.saveAsWav(path: resultPath.path)
                if !FileManager.default.fileExists(atPath: resultPath.path) {
                    generationError = GenerationError(message: "Generation failed")
                }
            } catch {
                generationError = error
            }
            
            Task { @MainActor [weak self] in
                guard let self else { return }
                if let error = generationError {
                    self.viewState = .error(error)
                } else {
                    self.viewState = .idle
                    self.outputPath = resultPath
                }
                self.generationTask = nil
            }
        }
    }
    
    func tearDown() {
        loadingTask?.cancel()
        loadingTask = nil
        generationTask?.cancel()
        generationTask = nil
        session = nil
    }

    func stopGeneration() {
        generationTask?.cancel()
        generationTask = nil
        viewState = .idle
        outputPath = nil
    }
}