elevenlabs go
1.0.0
Il s'agit d'une bibliothèque client Go pour la plateforme de clonage vocal et de synthèse vocale ElevenLabs. Il fournit une interface de base permettant aux programmes Go d'interagir avec l'API ElevenLabs.
go get github.com/haguro/elevenlabs-go Assurez-vous de remplacer "your-api-key" dans tous les exemples par votre clé API réelle. Reportez-vous à la documentation officielle de l'API Elevenlabs pour plus de détails.
La documentation complète de cette bibliothèque est disponible ici.
L'utilisation de la fonction NewClient renvoie une nouvelle instance Client qui permettra de transmettre un contexte parent, votre clé API et une durée d'expiration.
package main
import (
"context"
"log"
"os"
"time"
"github.com/haguro/elevenlabs-go"
)
func main () {
// Create a new client
client := elevenlabs . NewClient ( context . Background (), "your-api-key" , 30 * time . Second )
// Create a TextToSpeechRequest
ttsReq := elevenlabs. TextToSpeechRequest {
Text : "Hello, world! My name is Adam, nice to meet you!" ,
ModelID : "eleven_monolingual_v1" ,
}
// Call the TextToSpeech method on the client, using the "Adam"'s voice ID.
audio , err := client . TextToSpeech ( "pNInz6obpgDQGcFmaJgB" , ttsReq )
if err != nil {
log . Fatal ( err )
}
// Write the audio file bytes to disk
if err := os . WriteFile ( "adam.mp3" , audio , 0644 ); err != nil {
log . Fatal ( err )
}
log . Println ( "Successfully generated audio file" )
} La bibliothèque dispose d'un client par défaut que vous pouvez configurer et utiliser avec des fonctions proxy qui encapsulent les appels de méthode vers le client par défaut. Le client par défaut a un délai d'expiration par défaut défini sur 30 secondes et est configuré avec context.Background() comme contexte parent. Vous n'aurez qu'à définir votre clé API au minimum lorsque vous profiterez du client par défaut. Voici la version de l'exemple ci-dessus utilisant uniquement des fonctions abrégées.
package main
import (
"log"
"os"
"time"
el "github.com/haguro/elevenlabs-go"
)
func main () {
// Set your API key
el . SetAPIKey ( "your-api-key" )
// Set a different timeout (optional)
el . SetTimeout ( 15 * time . Second )
// Call the TextToSpeech method on the client, using the "Adam"'s voice ID.
audio , err := el . TextToSpeech ( "pNInz6obpgDQGcFmaJgB" , el. TextToSpeechRequest {
Text : "Hello, world! My name is Adam, nice to meet you!" ,
ModelID : "eleven_monolingual_v1" ,
})
if err != nil {
log . Fatal ( err )
}
// Write the audio file bytes to disk
if err := os . WriteFile ( "adam.mp3" , audio , 0644 ); err != nil {
log . Fatal ( err )
}
log . Println ( "Successfully generated audio file" )
} L'API Elevenlabs permet le streaming audio "au fur et à mesure qu'il est généré". Dans Elevenlabs-go, vous souhaiterez transmettre un io.Writer à la méthode TextToSpeechStream où le flux sera copié en continu. Notez que vous devrez définir le délai d'expiration du client sur une valeur suffisamment élevée pour garantir que la requête n'expire pas en cours de flux .
package main
import (
"context"
"log"
"os/exec"
"time"
"github.com/haguro/elevenlabs-go"
)
func main () {
message := `The concept of "flushing" typically applies to I/O buffers in many programming
languages, which store data temporarily in memory before writing it to a more permanent location
like a file or a network connection. Flushing the buffer means writing all the buffered data
immediately, even if the buffer isn't full.`
// Set your API key
elevenlabs . SetAPIKey ( "your-api-key" )
// Set a large enough timeout to ensure the stream is not interrupted.
elevenlabs . SetTimeout ( 1 * time . Minute )
// We'll use mpv to play the audio from the stream piped to standard input
cmd := exec . CommandContext ( context . Background (), "mpv" , "--no-cache" , "--no-terminal" , "--" , "fd://0" )
// Get a pipe connected to the mpv's standard input
pipe , err := cmd . StdinPipe ()
if err != nil {
log . Fatal ( err )
}
// Attempt to run the command in a separate process
if err := cmd . Start (); err != nil {
log . Fatal ( err )
}
// Stream the audio to the pipe connected to mpv's standard input
if err := elevenlabs . TextToSpeechStream (
pipe ,
"pNInz6obpgDQGcFmaJgB" ,
elevenlabs. TextToSpeechRequest {
Text : message ,
ModelID : "eleven_multilingual_v1" ,
}); err != nil {
log . Fatalf ( "Got %T error: %q n " , err , err )
}
// Close the pipe when all stream has been copied to the pipe
if err := pipe . Close (); err != nil {
log . Fatalf ( "Could not close pipe: %s" , err )
}
log . Print ( "Streaming finished." )
// Wait for mpv to exit. With the pipe closed, it will do that as
// soon as it finishes playing
if err := cmd . Wait (); err != nil {
log . Fatal ( err )
}
log . Print ( "All done." )
}Au moment de la rédaction (24 juin 2023), la bibliothèque fournit des liaisons Go pour 100 % des méthodes API d'Elevenlabs. Je prévois d'ajouter quelques fonctions de type utilitaire supplémentaires en cas de besoin ou de demande suffisante.
Selon Elevenlabs, l'API est toujours considérée comme expérimentale et est susceptible de changer.
Les contributions sont les bienvenues ! Si vous avez des idées, des améliorations ou des corrections de bugs, veuillez ouvrir un problème ou soumettre une pull request.
La bibliothèque Python officielle d'Elevenlabs est excellente et les autres Pythonistes sont encouragés à l'utiliser (et aussi à essayer Go ?) !
Il s'agit d'un projet indépendant et n'est ni affilié ni approuvé par Elevenlabs. Elevenlabs et ses marques sont la propriété de leurs propriétaires respectifs. Le but de ce projet est de fournir une bibliothèque client pour faciliter l'accès à l'API publique fournie par Elevenlabs au sein des programmes Go. Toute utilisation des marques déposées d'Elevenlabs dans le cadre de ce projet est uniquement à des fins d'identification et n'implique aucune approbation, parrainage ou affiliation.
Ce projet est sous licence MIT.
Cette bibliothèque de codes est fournie « telle quelle » et sans aucune garantie. Utilisez à vos propres risques. Plus de détails dans le fichier LICENSE.
