The open source AI code editor

package http

import (
    "context"
    "encoding/json"
    "errors"
    "io"
    "log/slog"
    "mime/multipart"
    "net/http"
    "time"

    "golang.org/x/sync/errgroup"
    "golang.org/x/sync/semaphore"
    "go.opentelemetry.io/otel"
)

type Result[T any] struct {
    Name  string `json:"name"`
    Value T      `json:"value,omitempty"`
    Error string `json:"error,omitempty"`
}

type Meta struct {
    Format string `json:"format"`
    Width  int    `json:"width"`
    Height int    `json:"height"`
    Bytes  int64  `json:"bytes"`
}

const (
    perRequestTimeout = 30 * time.Second
    maxParallel       = 8
)

func (s *Server) handleBatch(
    w http.ResponseWriter,
    r *http.Request,
) {
    ctx, span := otel.Tracer("http").
        Start(r.Context(), "batch")
    defer span.End()

    ctx, cancel := context.WithTimeout(
        ctx, perRequestTimeout,
    )
    defer cancel()

    r.Body = http.MaxBytesReader(
        w, r.Body, s.cfg.MaxBytes,
    )
    if err := r.ParseMultipartForm(
        s.cfg.MaxBytes,
    ); err != nil {
        s.fail(w, http.StatusBadRequest, err)
        return
    }
    files := pickFiles(r.MultipartForm)
    if len(files) == 0 {
        s.fail(w, http.StatusBadRequest,
            errors.New("no files"))
        return
    }

    out := make(
        []Result[Meta], len(files),
    )
    sem := semaphore.NewWeighted(maxParallel)
    g, gctx := errgroup.WithContext(ctx)

    for i, fh := range files {
        i, fh := i, fh
        if err := sem.Acquire(gctx, 1); err != nil {
            break
        }
        g.Go(func() error {
            defer sem.Release(1)
            out[i] = process(gctx, s, fh)
            return nil
        })
    }
    _ = g.Wait()

    s.log.LogAttrs(ctx,
        slog.LevelInfo, "batch.done",
        slog.Int("count", len(out)),
        slog.Duration("budget",
            perRequestTimeout),
    )

    w.Header().Set(
        "Content-Type", "application/json",
    )
    _ = json.NewEncoder(w).Encode(out)
}

func process(
    ctx context.Context,
    s *Server,
    fh *multipart.FileHeader,
) Result[Meta] {
    res := Result[Meta]{Name: fh.Filename}
    f, err := fh.Open()
    if err != nil {
        res.Error = err.Error()
        return res
    }
    defer f.Close()

    data, err := io.ReadAll(
        io.LimitReader(f, s.cfg.MaxBytes),
    )
    if err != nil {
        res.Error = err.Error()
        return res
    }
    m, err := s.proc.ExtractCtx(ctx, data)
    if err != nil {
        res.Error = err.Error()
        return res
    }
    res.Value = Meta{
        Format: m.Format,
        Width:  m.Width,
        Height: m.Height,
        Bytes:  int64(len(data)),
    }
    return res
}

import numpy as np
import pandas as pd

iris_data = pd.read_csv("iris_dataset.csv")

def describe(species: str) -> pd.Series:

        7
        
      
subset = data[data["species"] == species]          
subset = iris_data[iris_data["species"] == species]
if subset.empty:
raise ValueError(f"{species} missing from sample")
return subset[["petal", "sepal"]].agg(["mean", "std"]).loc["mean"]

def summary():

        13
        
      
for species in np.sort(data["species"].unique()):     
for species in np.sort(iris_data["species"].unique()):
try:
stats = describe(species)
except ValueError:
print(f"{species}: no records")
continue
print(f"{species}: petal={stats['petal']:.2f} sepal={stats['sepal']:.2f}")

if __name__ == "__main__":
summary()