Restructure project with new pkg layout and update dependencies

This commit is contained in:
Mingor committed 2025-04-22 18:46:59 +08:00
1 parent 1838c1d559
commit 191785021e
55 files changed
+603 -4252

No files matched your search

+17
View File
@@ -0,0 +1,17 @@
package httpclient
import (
"fmt"
)
// NewHTTPClient 根据配置类型返回对应 HTTPClient 实例
func NewHTTPClient(clientType string) (HTTPClient, error) {
switch clientType {
case "fasthttp":
return NewFastHTTPClient(), nil
case "net-http":
return NewNetHTTPClient(), nil
default:
return nil, fmt.Errorf("unsupported client: %s", clientType)
}
}
+57
View File
@@ -0,0 +1,57 @@
package httpclient
import (
"sync"
"github.com/valyala/fasthttp"
)
// FastHTTPClient 使用 fasthttp 实现 HTTPClient 接口
type FastHTTPClient struct {
client *fasthttp.Client
reqPool *sync.Pool
respPool *sync.Pool
}
// NewFastHTTPClient 返回一个初始化的 FastHTTPClient
func NewFastHTTPClient() *FastHTTPClient {
return &FastHTTPClient{
client: &fasthttp.Client{},
reqPool: &sync.Pool{New: func() interface{} { return new(fasthttp.Request) }},
respPool: &sync.Pool{New: func() interface{} { return new(fasthttp.Response) }},
}
}
// Do 发送非流式请求
func (c *FastHTTPClient) Do(req *Request) (*Response, error) {
fr := c.reqPool.Get().(*fasthttp.Request)
defer c.reqPool.Put(fr)
fr.Header.SetMethod(req.Method)
fr.SetRequestURI(req.URL)
if len(req.Body) > 0 {
fr.SetBody(req.Body)
}
for k, v := range req.Headers {
fr.Header.Set(k, v)
}
fresp := c.respPool.Get().(*fasthttp.Response)
defer c.respPool.Put(fresp)
if err := c.client.Do(fr, fresp); err != nil {
return nil, err
}
resp := &Response{
StatusCode: fresp.StatusCode(),
Body: append([]byte(nil), fresp.Body()...),
Headers: make(map[string]string),
}
fresp.Header.VisitAll(func(k, v []byte) {
resp.Headers[string(k)] = string(v)
})
return resp, nil
}
// Stream 发送流式请求,逐块通过 callback 回调 SSE 数据
// 目前使用 net/http 实现 SSE 解析,后续可优化为 fasthttp 原生实现
func (c *FastHTTPClient) Stream(req *Request, callback func(chunk SSEChunk) error) error {
return NewNetHTTPClient().Stream(req, callback)
}
+38
View File
@@ -0,0 +1,38 @@
package httpclient
// Request 表示 HTTP 请求
// 包含方法、URL、Body 和 Header
// 可在后续实现中扩展 Field
type Request struct {
Method string
URL string
Body []byte
Headers map[string]string
}
// Response 表示 HTTP 响应
// 包含状态码、Body 和 Header
type Response struct {
StatusCode int
Body []byte
Headers map[string]string
}
// SSEChunk 表示 SSE 流中的一块数据
// Data 为 JSON 数据,Timestamp 记录接收时间,IsDone 标记 [DONE]
type SSEChunk struct {
Data []byte // JSON 数据
Timestamp int64 // 接收时间戳(UnixNano)
IsDone bool // 是否为 [DONE]
}
// HTTPClient 定义通用的 Do 和 Stream 方法接口
// 后续根据 client 类型实现 fasthttp 或 net/http
type HTTPClient interface {
Do(req *Request) (*Response, error)
Stream(req *Request, callback func(chunk SSEChunk) error) error
}
+90
View File
@@ -0,0 +1,90 @@
package httpclient
import (
"bufio"
"bytes"
"io"
"net/http"
"strings"
"time"
)
// NetHTTPClient 使用 net/http 实现 HTTPClient 接口
type NetHTTPClient struct {
client *http.Client
// 可根据需要添加对象池
}
// NewNetHTTPClient 返回一个初始化的 NetHTTPClient
func NewNetHTTPClient() *NetHTTPClient {
return &NetHTTPClient{client: &http.Client{}}
}
// Do 发送非流式请求
func (c *NetHTTPClient) Do(req *Request) (*Response, error) {
r, err := http.NewRequest(req.Method, req.URL, bytes.NewReader(req.Body))
if err != nil {
return nil, err
}
for k, v := range req.Headers {
r.Header.Set(k, v)
}
resp, err := c.client.Do(r)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, err
}
headers := make(map[string]string)
for k, v := range resp.Header {
headers[k] = v[0]
}
return &Response{StatusCode: resp.StatusCode, Body: body, Headers: headers}, nil
}
// Stream 发送流式请求,逐块通过 callback 回调 SSE 数据
func (c *NetHTTPClient) Stream(req *Request, callback func(chunk SSEChunk) error) error {
r, err := http.NewRequest(req.Method, req.URL, bytes.NewReader(req.Body))
if err != nil {
return err
}
for k, v := range req.Headers {
r.Header.Set(k, v)
}
resp, err := c.client.Do(r)
if err != nil {
return err
}
defer resp.Body.Close()
scanner := bufio.NewScanner(resp.Body)
for scanner.Scan() {
text := scanner.Text()
if text == "" {
continue
}
const prefix = "data: "
if strings.HasPrefix(text, prefix) {
payload := text[len(prefix):]
isDone := payload == "[DONE]"
var dataBytes []byte
if !isDone {
dataBytes = []byte(payload)
}
chunk := SSEChunk{
Data: dataBytes,
Timestamp: time.Now().UnixNano(),
IsDone: isDone,
}
if err := callback(chunk); err != nil {
return err
}
}
}
if err := scanner.Err(); err != nil {
return err
}
return nil
}
+73
View File
@@ -0,0 +1,73 @@
package prompt
import (
"fmt"
"math/rand"
"strings"
"time"
"github.com/tiktoken-go/tokenizer"
"mingor/llm-api-benchmark-tool/internal/config"
)
// PromptGenerator 生成短/长提示词
// 使用 tiktoken-go tokenizer 计算 token 数
type PromptGenerator struct {
cfg *config.Config
tok *tokenizer.Tokenizer
}
// NewPromptGenerator 初始化生成器,model 用于 tokenizer
func NewPromptGenerator(model string, cfg *config.Config) (*PromptGenerator, error) {
tok, err := tokenizer.NewTokenizer(model)
if err != nil {
return nil, err
}
rand.Seed(time.Now().UnixNano())
return &PromptGenerator{cfg: cfg, tok: tok}, nil
}
// Generate 根据类型(tp)和占位值(values)生成提示词
// tp 可为 "short" 或 "long" 等配置中的键
func (g *PromptGenerator) Generate(tp string, values map[string]string) (string, error) {
pt, ok := g.cfg.PromptTemplates[tp]
if !ok {
return "", fmt.Errorf("unknown prompt type: %s", tp)
}
if len(pt.Templates) == 0 {
return "", fmt.Errorf("no templates for type: %s", tp)
}
tpl := pt.Templates[rand.Intn(len(pt.Templates))]
prompt := fillTemplate(tpl, values)
// 计算 token 数
toks, err := g.tok.Encode(prompt)
if err != nil {
return "", err
}
target := pt.TargetTokens
tol := int(float64(target) * 0.05)
cnt := len(toks)
if cnt < target-tol || cnt > target+tol {
// 长度不在范围,用户可根据需要调整
}
return prompt, nil
}
// CountTokens 返回文本的 token 数
func (g *PromptGenerator) CountTokens(text string) (int, error) {
toks, err := g.tok.Encode(text)
if err != nil {
return 0, err
}
return len(toks), nil
}
// fillTemplate 用 map[string]string 替换模板中的 {key}
func fillTemplate(tpl string, values map[string]string) string {
out := tpl
for k, v := range values {
out = strings.ReplaceAll(out, "{"+k+"}", v)
}
return out
}