استفاده از مدلهای AI با GO و تکرار API: یک راهنمای جامع

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
    "time"
)

// Configuration struct to hold our Replicate API settings.
type Config struct {
    Token string
    BaseURL  string
}

// NewConfig creates a new configuration instance.
func NewConfig() *Config {
    return &Config{
        Token: os.Getenv("REPLICATE_API_TOKEN"),
        BaseURL:  "https://api.replicate.com/v1",
    }
}

// Client represents our Replicate API client
type Client struct {
    config *Config
    http   *http.Client
}

// NewClient creates a new Replicate client instance with retry functionality.
func NewClient(config *Config) *Client {
    client := retryablehttp.NewClient()
    client.RetryMax = 3
    client.RetryWaitMin = 1 * time.Second
    client.RetryWaitMax = 30 * time.Second
    client.HTTPClient.Timeout = time.Second * 30

    return &Client{
        config: config,
        http:   client.StandardClient(),
    }
}

// createRequest helps build HTTP requests with appropriate headers
func (c *Client) createRequest(method, endpoint string, body any) (*http.Request, error) {
    var buf bytes.Buffer

    if body != nil {
        if err := json.NewEncoder(&buf).Encode(body); err != nil {
            return nil, fmt.Errorf("encoding request body: %w", err)
        }
    }

    req, err := http.NewRequest(method, c.config.APIBase+endpoint, &buf)
    if err != nil {
        return nil, fmt.Errorf("creating request: %w", err)
    }

    req.Header.Set("Authorization", "Token "+c.config.APIToken)
    req.Header.Set("Content-Type", "application/json")

    return req, nil
}

// PredictionInput represents the input parameters for Stable Diffusion.
type StableDiffusionInput struct {
    Prompt string `json:"prompt"`
    Width  int    `json:"width,omitempty"`
    Height int    `json:"height,omitempty"`
}

// CreatePrediction starts a new image generation task
func (c *Client) CreateStableDiffusionPrediction(input *StableDiffusionInput) (*Prediction, error) {
    payload := map[string]any{
        "version": "stable-diffusion-v1-5",
        "input": input,
    }

    req, err := c.createRequest("POST", "/predictions", payload)
    if err != nil {
        return nil, err
    }

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, fmt.Errorf("making request: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusCreated {
        body, _ := ioutil.ReadAll(resp.Body)
        return nil, fmt.Errorf("API error: %s: %s", resp.Status, body)
    }

    var prediction Prediction
    if err := json.NewDecoder(resp.Body).Decode(&prediction); err != nil {
        return nil, fmt.Errorf("decoding response: %w", err)
    }

    return &prediction, nil
}

// PredictionStatus represents the current state of a prediction
type PredictionStatus string

const (
    StatusStarting    PredictionStatus = "starting"
    StatusProcessing  PredictionStatus = "processing"
    StatusSucceeded   PredictionStatus = "succeeded"
    StatusFailed      PredictionStatus = "failed"
)

// PollPrediction continuously checks a prediction's status until completion
func (c *Client) PollPrediction(id string) (*Prediction, error) {
    ticker := time.NewTicker(2 * time.Second)
    defer ticker.Stop()

    timeout := time.After(10 * time.Minute)

    for {
        select {
        case <-ticker.C:
            prediction, err := c.GetPrediction(id)
            if err != nil {
                return nil, err
            }

            switch prediction.Status {
            case StatusSucceeded:
                return prediction, nil

            case StatusFailed:
                return nil, fmt.Errorf("prediction failed: %s", prediction.Error)

            case StatusStarting, StatusProcessing:
                continue

            default:
                return nil, fmt.Errorf("unknown status: %s", prediction.Status)
            }

        case <-timeout:
            return nil, fmt.Errorf("prediction timed out after 10 minutes")
        }
    }
}

func main() {
    config := NewConfig()
    client := NewClient(config)

    input := &StableDiffusionInput{
        Prompt: "matte black sports car with purple neon wheels:1.2, low rider, neon lights, sunset, reflective puddles, scifi, concept car, sideview, tropical background, 35mm photograph, film, bokeh, professional, 4k, highly detailed",
        Width:  768,
        Height: 512,
    }

    // Create the prediction
    prediction, err := client.CreateStableDiffusionPrediction(input)
    if err != nil {
        fmt.Printf("Error creating prediction: %v\n", err)
        return
    }

    // Poll for results
    result, err := client.PollPrediction(prediction.ID)
    if err != nil {
        fmt.Printf("Error polling prediction: %v\n", err)
        return
    }

    // Handle the result
    if images, ok := result.Output.([]string); ok && len(images) > 0 {
        fmt.Printf("Generated image URL: %s\n", images[0])
    }
}

// Generic prediction creation function.
func (c *Client) CreatePrediction(version string, input any) (*Prediction, error) {
    payload := map[string]any{
        "version": version,
        "input":   input,
    }

    req, err := c.createRequest(http.MethodPost, "/predictions", payload)
    if err != nil {
        return nil, err
    }

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, fmt.Errorf("making request: %w", err)
    }

    defer resp.Body.Close()

    if resp.StatusCode != http.StatusCreated {
        return nil, fmt.Errorf("api error: %s", resp.Status)
    }

    var prediction Prediction
    if err := json.NewDecoder(resp.Body).Decode(&prediction); err != nil {
        return nil, fmt.Errorf("decoding response: %w", err)
    }

    return &prediction, nil 
}