Download handler.go from dukunhamsembrek/tesaibottelegramdukun: direct link, hf CLI and curl.
- Browser
- Download file 2.8 kB
-
https://huggingface.co/spaces/dukunhamsembrek/tesaibottelegramdukun/resolve/main/handler.go
- Command line
-
hf download hf://spaces/dukunhamsembrek/tesaibottelegramdukun/handler.go
-
curl -L -o handler.go https://huggingface.co/spaces/dukunhamsembrek/tesaibottelegramdukun/resolve/main/handler.go
2.8 kB
| package main | |
| import ( | |
| "bytes" | |
| "encoding/base64" | |
| "image" | |
| "image/jpeg" | |
| _ "image/png" | |
| "runtime" | |
| "sync" | |
| "time" | |
| "github.com/disintegration/imaging" | |
| "github.com/gofiber/fiber/v2" | |
| ) | |
| type CompressRequest struct { | |
| Images []string `json:"images"` // Base64 encoded images | |
| Quality int `json:"quality"` // JPEG quality 1-100 | |
| MaxDim int `json:"max_dim"` // Max dimension for resize | |
| } | |
| type CompressResponse struct { | |
| Results []string `json:"results"` // Base64 encoded results | |
| ProcessingMs int64 `json:"processing_ms"` // Total processing time | |
| Count int `json:"count"` // Number of images processed | |
| Errors []string `json:"errors"` // Any errors encountered | |
| } | |
| func HandleCompress(c *fiber.Ctx) error { | |
| start := time.Now() | |
| var req CompressRequest | |
| if err := c.BodyParser(&req); err != nil { | |
| return c.Status(400).JSON(fiber.Map{"error": "Invalid request: " + err.Error()}) | |
| } | |
| // Defaults | |
| if req.Quality == 0 { | |
| req.Quality = 85 | |
| } | |
| if req.MaxDim == 0 { | |
| req.MaxDim = 2048 | |
| } | |
| if len(req.Images) == 0 { | |
| return c.Status(400).JSON(fiber.Map{"error": "No images provided"}) | |
| } | |
| // Process images in parallel | |
| results := make([]string, len(req.Images)) | |
| errors := make([]string, len(req.Images)) | |
| var wg sync.WaitGroup | |
| sem := make(chan struct{}, runtime.NumCPU()) // Limit concurrency to CPU count | |
| for i, imgB64 := range req.Images { | |
| wg.Add(1) | |
| go func(idx int, data string) { | |
| defer wg.Done() | |
| sem <- struct{}{} // Acquire | |
| defer func() { <-sem }() // Release | |
| result, err := compressImage(data, req.Quality, req.MaxDim) | |
| if err != nil { | |
| errors[idx] = err.Error() | |
| results[idx] = "" | |
| return | |
| } | |
| results[idx] = result | |
| }(i, imgB64) | |
| } | |
| wg.Wait() | |
| // Filter out empty errors | |
| var nonEmptyErrors []string | |
| for _, e := range errors { | |
| if e != "" { | |
| nonEmptyErrors = append(nonEmptyErrors, e) | |
| } | |
| } | |
| elapsed := time.Since(start).Milliseconds() | |
| return c.JSON(CompressResponse{ | |
| Results: results, | |
| ProcessingMs: elapsed, | |
| Count: len(results), | |
| Errors: nonEmptyErrors, | |
| }) | |
| } | |
| func compressImage(b64 string, quality, maxDim int) (string, error) { | |
| // Decode base64 | |
| data, err := base64.StdEncoding.DecodeString(b64) | |
| if err != nil { | |
| return "", err | |
| } | |
| // Decode image | |
| img, _, err := image.Decode(bytes.NewReader(data)) | |
| if err != nil { | |
| return "", err | |
| } | |
| // Resize if needed (maintain aspect ratio) | |
| bounds := img.Bounds() | |
| w, h := bounds.Dx(), bounds.Dy() | |
| if w > maxDim || h > maxDim { | |
| img = imaging.Fit(img, maxDim, maxDim, imaging.Lanczos) | |
| } | |
| // Encode to JPEG | |
| var buf bytes.Buffer | |
| if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: quality}); err != nil { | |
| return "", err | |
| } | |
| return base64.StdEncoding.EncodeToString(buf.Bytes()), nil | |
| } | |