update sth. at 2025-01-16 23:44:43

app.py1

@@ -0,0 +1,146 @@
+import asyncio
+import logging
+import torch
+import gradio as gr
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Dict
+from functools import lru_cache
+import numpy as np
+from threading import Lock
+import uvicorn
+
+class EmbeddingRequest(BaseModel):
+    input: str
+    model: str = "jinaai/jina-embeddings-v3"
+
+class EmbeddingResponse(BaseModel):
+    status: str
+    embeddings: List[List[float]]
+
+class EmbeddingService:
+    def __init__(self):
+        self.model_name = "jinaai/jina-embeddings-v3"
+        self.max_length = 512
+        self.device = torch.device("cpu")
+        self.model = None
+        self.tokenizer = None
+        self.lock = Lock()
+        self.setup_logging()
+        torch.set_num_threads(4)  # CPU优化
+
+    def setup_logging(self):
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s'
+        )
+        self.logger = logging.getLogger(__name__)
+
+    async def initialize(self):
+        try:
+            from transformers import AutoTokenizer, AutoModel
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.model_name,
+                trust_remote_code=True
+            )
+            self.model = AutoModel.from_pretrained(
+                self.model_name,
+                trust_remote_code=True
+            ).to(self.device)
+            self.model.eval()
+            torch.set_grad_enabled(False)
+            self.logger.info(f"模型加载成功，使用设备: {self.device}")
+        except Exception as e:
+            self.logger.error(f"模型初始化失败: {str(e)}")
+            raise
+
+    @lru_cache(maxsize=1000)
+    def get_embedding(self, text: str) -> List[float]:
+        """同步生成嵌入向量，带缓存"""
+        with self.lock:
+            try:
+                inputs = self.tokenizer(
+                    text,
+                    return_tensors="pt",
+                    truncation=True,
+                    max_length=self.max_length,
+                    padding=True
+                )
+
+                with torch.no_grad():
+                    outputs = self.model(**inputs).last_hidden_state.mean(dim=1)
+                    return outputs.numpy().tolist()[0]
+            except Exception as e:
+                self.logger.error(f"生成嵌入向量失败: {str(e)}")
+                raise
+
+embedding_service = EmbeddingService()
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.post("/generate_embeddings", response_model=EmbeddingResponse)
+@app.post("/api/v1/embeddings", response_model=EmbeddingResponse)
+@app.post("/hf/v1/embeddings", response_model=EmbeddingResponse)
+@app.post("/api/v1/chat/completions", response_model=EmbeddingResponse)
+@app.post("/hf/v1/chat/completions", response_model=EmbeddingResponse)
+async def generate_embeddings(request: EmbeddingRequest):
+    try:
+        # 使用run_in_executor避免事件循环问题
+        embedding = await asyncio.get_running_loop().run_in_executor(
+            None,
+            embedding_service.get_embedding,
+            request.input
+        )
+        return EmbeddingResponse(
+            status="success",
+            embeddings=[embedding]
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/")
+async def root():
+    return {
+        "status": "active",
+        "model": embedding_service.model_name,
+        "device": str(embedding_service.device)
+    }
+
+def gradio_interface(text: str) -> Dict:
+    try:
+        embedding = embedding_service.get_embedding(text)
+        return {
+            "status": "success",
+            "embeddings": [embedding]
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e)
+        }
+
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=gr.Textbox(lines=3, label="输入文本"),
+    outputs=gr.JSON(label="嵌入向量结果"),
+    title="Jina Embeddings V3",
+    description="使用jina-embeddings-v3模型生成文本嵌入向量",
+    examples=[["这是一个测试句子。"]]
+)
+
+@app.on_event("startup")
+async def startup_event():
+    await embedding_service.initialize()
+
+if __name__ == "__main__":
+    asyncio.run(embedding_service.initialize())
+    gr.mount_gradio_app(app, iface, path="/ui")
+    uvicorn.run(app, host="0.0.0.0", port=7860, workers=1)

demo/README.md

@@ -0,0 +1,38 @@
+# 网络请求示例
+
+简单HTTP请求：requests/httpx
+异步操作：aiohttp/httpx
+浏览器自动化：selenium/playwright
+表单处理：mechanize
+实时通信：websockets
+底层控制：socket/pycurl
+
+## 对比
+
+| 库名         | 同步/异步 | 易用性(1-5) | 性能(1-5) | 适用场景     | 特点             | 优点                  | 缺点        | 额外依赖 | 维护成本(1-5) |
+| ------------ | --------- | ----------- | --------- | ------------ | ---------------- | --------------------- | ----------- | -------- | ------------- |
+| requests     | 同步      | 5           | 3         | 一般HTTP请求 | 简单直观         | API友好，文档丰富     | 不支持异步  | 是       | 1             |
+| aiohttp      | 异步      | 4           | 5         | 高并发       | 原生异步         | 高性能，WebSocket支持 | 配置较复杂  | 是       | 3             |
+| httpx        | 两者      | 5           | 4         | 现代应用     | 同时支持同步异步 | 类型提示，HTTP/2      | 相对较新    | 是       | 2             |
+| httpcore     | 两者      | 2           | 5         | 底层控制     | 底层实现         | 精细控制，高性能      | API复杂     | 是       | 4             |
+| h11          | 同步      | 1           | 5         | 协议实现     | 最底层           | 完全控制              | 使用复杂    | 是       | 5             |
+| urllib3      | 同步      | 3           | 3         | 基础功能     | 连接池管理       | 稳定可靠              | API不够现代 | 否       | 2             |
+| urllib       | 同步      | 2           | 2         | 基础功能     | 标准库           | 无需安装              | API复杂     | 否       | 3             |
+| pycurl       | 同步      | 2           | 5         | 多协议支持   | libcurl绑定      | 高性能，多协议        | 配置复杂    | 是       | 4             |
+| grequests    | 异步      | 4           | 4         | 并发请求     | 并发封装         | 易用的并发            | 功能局限    | 是       | 2             |
+| cloudscraper | 同步      | 4           | 3         | 反爬虫       | 绕过保护         | 特殊场景支持          | 依赖较多    | 是       | 3             |
+| treq         | 异步      | 3           | 4         | Twisted项目  | 事件驱动         | 集成Twisted           | 生态局限    | 是       | 4             |
+
+补充说明：
+1. 易用性：1分最难，5分最易用
+2. 性能：1分最低，5分最高
+3. 维护成本：1分最低，5分最高
+4. 同步/异步：标明库的请求方式
+5. 额外依赖：是否需要安装额外的包
+ 
+这个表格可以帮助你：
+1. 快速选择适合项目的HTTP库
+2. 评估使用成本
+3.  了解各个库的优缺点
+4.  预估维护难度
+

demo/aiohttp_demo.py

@@ -0,0 +1,49 @@
+import aiohttp
+import asyncio
+import json
+
+async def embeddings_run_async(input, url="https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings", model="jinaai/jina-embeddings-v3"):
+    headers = {
+        'Content-Type': 'application/json'
+    }
+    
+    data = {
+        "input": input,
+        "model": model
+    }
+    
+    async with aiohttp.ClientSession() as session:
+        async with session.post(url, headers=headers, json=data) as response:
+            if response.status == 200:
+                return await response.json()
+            else:
+                response.raise_for_status()
+
+# 示例如何使用这个异步函数
+async def main():
+    input_text = "Your text string goes here"
+    result = await embeddings_run_async(input_text)
+    print(f"---{result}")
+
+# 运行异步函数
+if __name__ == "__main__":
+    asyncio.run(main())
+
+# 如果需要批量处理多个请求，可以这样使用：
+async def batch_process():
+    inputs = [
+        "First text to process",
+        "Second text to process",
+        "Third text to process"
+    ]
+    
+    # 并发执行多个请求
+    tasks = [embeddings_run_async(text) for text in inputs]
+    results = await asyncio.gather(*tasks)
+    
+    for i, result in enumerate(results):
+        print(f"Result {i+1}: {result}")
+
+# 运行批量处理
+if __name__ == "__main__":
+    asyncio.run(batch_process())

demo/cloudscraper_demo.py

@@ -0,0 +1,28 @@
+import cloudscraper
+import json
+
+
+def embeddings_run(input,url= "https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings",model="jinaai/jina-embeddings-v3"):
+
+ 
+    headers = {
+        "Content-Type": "application/json"
+    }
+
+    data = {
+        "input": input,
+        "model":model
+    }
+
+    scraper = cloudscraper.create_scraper()
+    response = scraper.post(url, headers=headers, data=json.dumps(data))
+    response.encoding="utf-8"
+    response.raise_for_status()
+
+    if response.status_code == 200:
+        return response.json()
+
+if __name__ == "__main__":
+    input = "Your text string goes here"
+    print(f"---{embeddings_run(input)}")
+

demo/general_curl_curlify_demo.py

@@ -0,0 +1,16 @@
+import requests
+import curlify
+
+def get_curl_command(input_text, url="https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings"):
+    headers = {
+        "Content-Type": "application/json"
+    }
+    data = {
+        "input": input_text,
+        "model": "jinaai/jina-embeddings-v3"
+    }
+    
+    r = requests.post(url, headers=headers, json=data)
+    return curlify.to_curl(r.request)
+
+print(get_curl_command("Your text string goes here"))

demo/grequests_demo.py

@@ -0,0 +1,35 @@
+import grequests
+import json
+
+def embeddings_run(inputs, url="https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings", model="jinaai/jina-embeddings-v3"):
+    headers = {
+        "Content-Type": "application/json"
+    }
+    
+    # 支持单个或批量请求
+    if isinstance(inputs, str):
+        inputs = [inputs]
+    
+    # 创建请求列表
+    requests = [
+        grequests.post(
+            url,
+            headers=headers,
+            json={"input": input, "model": model}
+        ) for input in inputs
+    ]
+    
+    # 并发执行请求
+    responses = grequests.map(requests)
+    
+    # 处理响应
+    results = []
+    for response in responses:
+        if response and response.status_code == 200:
+            results.append(response.json())
+            
+    return results[0] if len(inputs) == 1 else results
+
+if __name__ == "__main__":
+    input_text = "Your text string goes here"
+    print(f"---{embeddings_run(input_text)}")

demo/h11_demo.py

@@ -0,0 +1,63 @@
+import h11
+import socket
+import json
+import ssl
+import urllib.parse
+
+def embeddings_run_h11(input_text, url="https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings"):
+    parsed_url = urllib.parse.urlparse(url)
+    
+    # 创建SSL上下文
+    context = ssl.create_default_context()
+    
+    # 创建普通socket
+    sock = socket.create_connection((parsed_url.hostname, 443))
+    
+    # 包装成SSL socket
+    sock = context.wrap_socket(sock, server_hostname=parsed_url.hostname)
+    
+    conn = h11.Connection(our_role=h11.CLIENT)
+    
+    data = json.dumps({
+        "input": input_text,
+        "model": "jinaai/jina-embeddings-v3"
+    })
+    
+    request = h11.Request(
+        method="POST",
+        target=parsed_url.path,
+        headers=[
+            ("Host", parsed_url.hostname),
+            ("Content-Type", "application/json"),
+            ("Content-Length", str(len(data))),
+            ("Connection", "close")  # 添加这个头
+        ]
+    )
+    
+    sock.send(conn.send(request))
+    sock.send(conn.send(h11.Data(data=data.encode())))
+    sock.send(conn.send(h11.EndOfMessage()))
+    
+    response = b""
+    while True:
+        event = conn.next_event()
+        if event is h11.NEED_DATA:
+            data = sock.recv(2048)
+            if not data:  # 连接关闭
+                break
+            conn.receive_data(data)
+            continue
+        if isinstance(event, h11.EndOfMessage):
+            break
+        if isinstance(event, h11.Data):
+            response += event.data
+    
+    sock.close()
+    return json.loads(response)
+
+if __name__ == "__main__":
+    try:
+        result = embeddings_run_h11("Your text string goes here")
+        print(f"---{result}")
+    except Exception as e:
+        print(f"Error: {e}")

demo/httpcore_demo.py

@@ -0,0 +1,38 @@
+import httpcore
+import json
+import asyncio
+import ssl
+from urllib.parse import urlparse
+
+async def embeddings_run_httpcore(input_text, url="https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings"):
+    ssl_context = ssl.create_default_context()
+    async with httpcore.AsyncConnectionPool(ssl_context=ssl_context) as http:
+        data = {
+            "input": input_text,
+            "model": "jinaai/jina-embeddings-v3"
+        }
+        
+        response = await http.request(
+            method=b"POST",
+            url=url.encode(),
+            headers=[
+                (b"content-type", b"application/json"),
+                (b"accept", b"application/json"),
+            ],
+            content=json.dumps(data).encode()
+        )
+        
+        if response.status == 200:
+            return json.loads(response.content)
+        else:
+            raise Exception(f"Request failed with status {response.status}")
+
+async def main():
+    try:
+        result = await embeddings_run_httpcore("Your text string goes here")
+        print(f"---{result}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(main())

demo/httpx_demo.py

@@ -0,0 +1,75 @@
+import httpx
+import asyncio
+import json
+from typing import List, Union
+
+# 同步版本
+def embeddings_run_sync(input: Union[str, List[str]], 
+                       url: str = "https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings", 
+                       model: str = "jinaai/jina-embeddings-v3") -> dict:
+    headers = {
+        'Content-Type': 'application/json'
+    }
+    
+    data = {
+        "input": input,
+        "model": model
+    }
+    
+    with httpx.Client() as client:
+        response = client.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        return response.json()
+
+# 异步版本
+async def embeddings_run_async(input: Union[str, List[str]], 
+                             url: str = "https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings", 
+                             model: str = "jinaai/jina-embeddings-v3") -> dict:
+    headers = {
+        'Content-Type': 'application/json'
+    }
+    
+    data = {
+        "input": input,
+        "model": model
+    }
+    
+    async with httpx.AsyncClient() as client:
+        response = await client.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        return response.json()
+
+# 批量处理的异步函数
+async def batch_process_async(texts: List[str]) -> List[dict]:
+    async with httpx.AsyncClient() as client:
+        tasks = []
+        for text in texts:
+            task = embeddings_run_async(text)
+            tasks.append(task)
+        return await asyncio.gather(*tasks)
+
+# 使用示例
+if __name__ == "__main__":
+    # 1. 同步方式使用
+    input_text = "Your text string goes here"
+    result = embeddings_run_sync(input_text)
+    print(f"Sync result: {result}")
+    
+    # 2. 异步方式使用
+    async def main():
+        # 单个异步请求
+        result = await embeddings_run_async(input_text)
+        print(f"Async single result: {result}")
+        
+        # 批量异步请求
+        texts = [
+            "First text to process",
+            "Second text to process",
+            "Third text to process"
+        ]
+        results = await batch_process_async(texts)
+        for i, result in enumerate(results):
+            print(f"Batch result {i+1}: {result}")
+    
+    # 运行异步函数
+    asyncio.run(main())

demo/pycurl_demo.py

@@ -0,0 +1,46 @@
+import pycurl
+from io import BytesIO
+import json
+
+def embeddings_run(input, url="https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings", model="jinaai/jina-embeddings-v3"):
+    # 准备数据
+    data = json.dumps({
+        "input": input,
+        "model": model
+    })
+    
+    # 创建缓冲区存储响应
+    buffer = BytesIO()
+    
+    # 初始化 pycurl
+    c = pycurl.Curl()
+    
+    # 设置请求参数
+    c.setopt(c.URL, url)
+    c.setopt(c.WRITEDATA, buffer)
+    c.setopt(c.POST, 1)
+    c.setopt(c.POSTFIELDS, data)
+    c.setopt(c.HTTPHEADER, [
+        'Content-Type: application/json',
+        f'Content-Length: {len(data)}'
+    ])
+    
+    try:
+        # 执行请求
+        c.perform()
+        
+        # 检查状态码
+        status_code = c.getinfo(pycurl.HTTP_CODE)
+        if status_code == 200:
+            # 获取响应数据
+            response_data = buffer.getvalue().decode('utf-8')
+            return json.loads(response_data)
+        else:
+            raise Exception(f"Request failed with status code: {status_code}")
+    finally:
+        c.close()
+        buffer.close()
+
+if __name__ == "__main__":
+    input_text = "Your text string goes here"
+    print(f"---{embeddings_run(input_text)}")

demo/requests_demo.py

@@ -0,0 +1,27 @@
+import requests
+import json
+
+
+def embeddings_run(input,url= "https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings",model="jinaai/jina-embeddings-v3"):
+
+ 
+    headers = {
+        "Content-Type": "application/json"
+    }
+
+    data = {
+        "input": input,
+        "model":model
+    }
+
+    response = requests.post(url, headers=headers, data=json.dumps(data))
+    response.encoding="utf-8"
+    response.raise_for_status()
+
+    if response.status_code == 200:
+        return response.json()
+
+if __name__ == "__main__":
+    input = "Your text string goes here"
+    print(f"---{embeddings_run(input)}")
+

demo/requirements.txt

@@ -0,0 +1,14 @@
+requests
+cloudscraper
+aiohttp
+asyncio
+httpx
+selenium
+mechanize
+grequests
+pycurl
+playwright
+twisted
+treq
+h11
+curlify

demo/treq_demo.py

@@ -0,0 +1,30 @@
+from twisted.internet import reactor, defer
+from treq import post
+import json
+
+@defer.inlineCallbacks
+def embeddings_run_treq(input_text, url="https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings"):
+    headers = {
+        "Content-Type": "application/json"
+    }
+    data = {
+        "input": input_text,
+        "model": "jinaai/jina-embeddings-v3"
+    }
+    
+    response = yield post(
+        url,
+        headers=headers,
+        json=data
+    )
+    content = yield response.json()
+    defer.returnValue(content)
+
+def main():
+    d = embeddings_run_treq("Your text string goes here")
+    d.addCallback(lambda result: print(f"---{result}"))
+    d.addBoth(lambda _: reactor.stop())
+    reactor.run()
+
+if __name__ == "__main__":
+    main()

demo/urllib3_demo.py

@@ -0,0 +1,33 @@
+import urllib3
+import json
+
+def embeddings_run(input, url="https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings", model="jinaai/jina-embeddings-v3"):
+    # 创建 PoolManager 实例
+    http = urllib3.PoolManager()
+    
+    headers = {
+        'Content-Type': 'application/json'
+    }
+    
+    data = {
+        "input": input,
+        "model": model
+    }
+    
+    # 发送 POST 请求
+    response = http.request(
+        'POST',
+        url,
+        headers=headers,
+        body=json.dumps(data).encode('utf-8')
+    )
+    
+    # 检查响应状态
+    if response.status == 200:
+        return json.loads(response.data.decode('utf-8'))
+    else:
+        response.raise_for_status()
+
+if __name__ == "__main__":
+    input = "Your text string goes here"
+    print(f"---{embeddings_run(input)}")

demo/urllib_demo.py

@@ -0,0 +1,32 @@
+from urllib.request import Request, urlopen
+import json
+
+def embeddings_run(input, url="https://sanbo1200-jina-embeddings-v3.hf.space/api/v1/embeddings", model="jinaai/jina-embeddings-v3"):
+    headers = {
+        "Content-Type": "application/json"
+    }
+    
+    data = {
+        "input": input,
+        "model": model
+    }
+    
+    # 创建请求
+    request = Request(
+        url,
+        headers=headers,
+        data=json.dumps(data).encode('utf-8'),
+        method='POST'
+    )
+    
+    # 发送请求并获取响应
+    try:
+        with urlopen(request) as response:
+            if response.status == 200:
+                return json.loads(response.read().decode('utf-8'))
+    except Exception as e:
+        raise Exception(f"Request failed: {str(e)}")
+
+if __name__ == "__main__":
+    input_text = "Your text string goes here"
+    print(f"---{embeddings_run(input_text)}")

requirements.txt

@@ -8,4 +8,5 @@ gradio
 numpy
 python-multipart
 sentencepiece
-safetensors
+safetensors
+