db

.gitignore

@@ -1 +1,2 @@
-__pycache__/
+__pycache__/
+.env

app.py

@@ -1,19 +1,54 @@
 # uvicorn app:app --host 0.0.0.0 --port 7860 --reload
 
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, Response, Depends
 from starlette.requests import Request
 
+from routers.webtools_v1 import router as webtools_router
+from routers.users_v1 import router as users_router
+from routers.openai_v1 import router as openai_router
+
+from db import Db
+
+from dotenv import load_dotenv
+import os
+
+# 加载.env文件
+load_dotenv()
+
+DB_PATH = os.getenv("DB_PATH")
+
+# 依赖注入，获取 DB_PATH
+def get_db_path():
+    return DB_PATH
+
 app = FastAPI()
 
+app.include_router(webtools_router, prefix="/airs/v1", tags=["webtools"])
+app.include_router(users_router, prefix="/airs/v1", tags=["users"])
+app.include_router(openai_router, prefix="/airs/v1", tags=["openai"])
+
 @app.get("/")
-def greet_json():
-    return {"Hello": "World!"}
-
-@app.post("/airs/v1/chat/completions")
-async def chat_completions(request:Request):
-    auth_header = request.headers['authorization']
-    api_key = auth_header.split()[1]  # 分割字符串并取第二个元素
-    if api_key != "iam-tanbushi":
-        raise HTTPException(status_code=401, detail="Invalid API Key")
-    data = await request.json()
-    return {"data": data}
+def greet_json(db_path: str = Depends(get_db_path)):
+    print(DB_PATH)
+    return {"Hello": "World!"}  
+@app.get("/init_db")
+def init_db():
+    sql = """
+CREATE TABLE api_keys (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    api_key TEXT NOT NULL,
+    type TEXT NOT NULL,
+    status INTEGER NOT NULL,
+    idx INTEGER NOT NULL,
+    dest_api_key TEXT NOT NULL
+);
+"""
+    Db('api_keys.db').execute_query(sql)
+
+# def create_user_api_key(user_id, api_key, type, status, idx, dest_api_key):
+#     sql = f"""
+# INSERT INTO api_keys (api_key, type, status, idx, dest_api_key)
+# """
+#     Db('api_keys.db').execute_query(sql)
+
+# create_user_api_key('i_am_tanbushi', 'llm', '1', '0', 'dest_api_key')

db.py

@@ -0,0 +1,64 @@
+import sqlite3
+import json
+
+class Db():
+    def __init__(self, db_path):
+        self.db_path = db_path
+        # print(self.db_path)
+
+    def list_query(self, query):
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute(query)
+        conn.commit()
+
+        rows = cursor.fetchall()
+        # print('results')
+        # print(results)
+        cursor.close()
+        conn.close()
+
+        json_rows = []
+        # 为每一行结果创建一个字典，并添加到列表中
+        for row in rows:
+            # 使用cursor.description获取列名和相关信息
+            columns = dict(zip([col[0] for col in cursor.description], row))
+            json_rows.append(columns)
+
+        return json_rows
+    
+    def insert_query(self, query):
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute(query)
+        conn.commit()
+        rowcount = cursor.rowcount
+        
+        return f"插入的行数: {rowcount}"
+    
+    def update_query(self, query):
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute(query)
+        conn.commit()
+        rowcount = cursor.rowcount
+        
+        return f"影响的行数: {rowcount}"
+# from fastapi import FastAPI
+
+# # 依赖注入，获取 FastAPI 应用实例
+# def get_app() -> FastAPI:
+#     return FastAPI()
+
+# def execute_query(query):
+
+
+
+
+# CREATE TABLE api_keys (
+#     api_key TEXT NOT NULL,
+#     type TEXT NOT NULL,
+#     status INTEGER NOT NULL,
+#     idx INTEGER NOT NULL,
+#     PRIMARY KEY (api_key, type, status, idx)
+# );

requirements.txt

@@ -1,2 +1,6 @@
 fastapi
-uvicorn[standard]
+uvicorn[standard]
+captcha
+python-dotenv
+langchain_google_genai==1.0.10
+langchain-openai==0.1.25 # 使用 openai 或兼容 openai

routers/openai_v1.py

@@ -0,0 +1,86 @@
+from fastapi import APIRouter, Request, HTTPException
+from db import Db
+from dotenv import load_dotenv
+import os, json
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+
+# 加载.env文件
+load_dotenv()
+
+router = APIRouter()
+
+@router.post("/chat/completions")
+async def chat_completions(request:Request):
+    print('chat_completions')
+    auth_header = request.headers['authorization']
+    user_api_key = auth_header.split()[1]  # 分割字符串并取第二个元素
+    data = await request.json()
+    try:
+        model = data['model']
+    except:
+        model = ''
+    if model=='':
+        model = await get_default_model()
+    api_key_info = await get_api_key(model)
+    api_key = api_key_info['api_key']
+    group_name = api_key_info['group_name']
+
+
+    # 下面是google api
+    if group_name=='gemini': 
+        from langchain_google_genai import ChatGoogleGenerativeAI
+        # 初始化模型
+        llm = ChatGoogleGenerativeAI(
+            api_key = api_key,
+            model = model,
+        )
+
+    
+    # 下面就是 chatgpt 兼容 api
+    if group_name=='glm':
+        from langchain_openai import ChatOpenAI
+        # 初始化 ChatOpenAI 模型
+        llm = ChatOpenAI(
+            model = model,
+            api_key = api_key,
+            base_url = 'https://open.bigmodel.cn/api/paas/v4', # 下一步将base_url 写到数据库里
+        )
+
+    messages = data['messages']
+    rslt = [(item["role"], item["content"]) for item in messages] # 转换为所需的元组列表格式
+    parser = StrOutputParser()
+    prompt_template = ChatPromptTemplate.from_messages(rslt)
+
+    chain = prompt_template | llm | parser
+    result = chain.invoke({})
+    return result
+
+async def get_default_model():
+    results = Db(os.getenv("DB_PATH")).list_query("SELECT * FROM api_names order by default_order limit 1")
+    try:
+        result = results[0]['api_name']
+    except:
+        result = ''
+    return result
+
+async def get_api_key(model):
+    sql = f"""
+SELECT an.api_name, ak.api_key, ag.group_name
+FROM api_keys ak
+JOIN api_groups ag ON ak.api_group_id = ag.id
+JOIN api_names an ON an.api_group_id = ag.id
+WHERE ak.category='LLM' and an.api_name='{model}' and disabled=0
+ORDER BY ak.last_call_at
+limit 1
+"""
+    results = Db(os.getenv("DB_PATH")).list_query(sql)
+    try:
+        result = results[0]
+        api_key = result['api_key']
+    except:
+        api_key = ''
+    
+    sql = f"update api_keys set last_call_at=datetime('now') where api_key='{api_key}'"
+    Db(os.getenv("DB_PATH")).update_query(sql)
+    return result

routers/users_v1.py

@@ -0,0 +1,48 @@
+from fastapi import APIRouter, Request, FastAPI, Depends
+from dotenv import load_dotenv
+import os
+import uuid
+from db import Db
+
+router = APIRouter()
+
+# 加载.env文件
+load_dotenv()
+
+DB_PATH = os.getenv("DB_PATH")
+
+# 依赖注入，获取 DB_PATH
+def get_db_path():
+    return DB_PATH
+
+@router.get("/users")
+async def read_users(db_path: str = Depends(get_db_path)):
+    # print('\n\n\n\n\n')
+    # print(db_path)
+    result = Db(db_path).list_query("SELECT * FROM users")
+    return result
+
+@router.post("/users")
+async def create_user(request: Request, b_path: str = Depends(get_db_path)):
+    request_json = await request.json()
+    username = request_json.get('username')
+    password = request_json.get('password')
+    email = request_json.get('email')
+    nikename = request_json.get('nikename')
+    if nikename==None:
+        nikename = ''
+    # print(nikename)
+    api_key = f'airs-{uuid.uuid4()}'
+    # result = api_key
+    # print(api_key)
+    result = Db(b_path).insert_query(f"INSERT INTO users (username, password, email, nikename, api_key) VALUES ('{username}', '{password}', '{email}', '{nikename}', '{api_key}')")
+    return result
+
+@router.get("/users/{id}")
+async def read_user(request: Request, id:int, db_path: str = Depends(get_db_path)):
+    result = Db(db_path).list_query(f"SELECT * FROM users where id={id}")
+    if len(result)>0:
+        return result[0]
+    else:
+        return None
+

routers/webtools_v1.py

@@ -0,0 +1,29 @@
+from fastapi import FastAPI, APIRouter, Response, Depends
+from captcha.image import ImageCaptcha
+from io import BytesIO
+
+router = APIRouter()
+
+# 依赖注入，获取 FastAPI 应用实例
+def get_app() -> FastAPI:
+    return FastAPI()
+
+@router.get("/webtools/captcha")
+async def get_captcha(app: FastAPI = Depends(get_app)):
+    # 生成随机验证码字符串
+    captcha_text = "123456"  # 这里只是一个示例，实际应用中应该生成一个随机字符串
+    # 创建验证码图片
+    image = ImageCaptcha(width=280, height=90)
+    image.write(captcha_text, "captcha.png")
+    
+    # 将验证码字符串存储在内存中，以便后续验证
+    # 注意：实际应用中应该使用更安全的方式存储验证码，例如使用会话或数据库
+    app.captcha_text = captcha_text
+    
+    # 读取图片内容并返回
+    image_buffer = BytesIO()
+    image.write(captcha_text, image_buffer)
+    image_buffer.seek(0)
+    
+    # 返回图片数据
+    return Response(content=image_buffer.getvalue(), media_type="image/png")

sql.md

@@ -0,0 +1,88 @@
+当然，以下是完整的SQL语句，用于创建`api_names`、`api_keys`表，以及可选的`api_usage`表。这些表将支持存储API名称、API-KEY信息，并可选地记录API的使用情况。
+
+### SQL 创建表的语句
+
+```sql
+-- 创建 users 表
+DROP TABLE IF EXISTS "users";
+CREATE TABLE "users" (
+  "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+  "username" TEXT NOT NULL,
+  "password" TEXT NOT NULL,
+  "email" TEXT NOT NULL,
+  "nikename" TEXT,
+  "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
+  "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE ("username" ASC),
+  UNIQUE ("email" ASC)
+);
+
+-- 创建api_groups表
+CREATE TABLE api_groups (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  group_name TEXT NOT NULL UNIQUE,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 创建api_names表
+CREATE TABLE api_names (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  api_name TEXT NOT NULL UNIQUE,
+  api_group_id INTEGER,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (api_group_id) REFERENCES api_groups(id) ON DELETE SET NULL
+);
+
+-- 创建api_keys表
+CREATE TABLE api_keys (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  api_group_id INTEGER NOT NULL,
+  api_key TEXT NOT NULL,
+  category TEXT NOT NULL,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (api_group_id) REFERENCES api_groups(id) ON DELETE CASCADE
+);
+
+-- 创建user_api_keys表
+CREATE TABLE user_api_keys (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  user_api_key TEXT NOT NULL,
+  user_id INTEGER,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 创建api_usage表（如果需要）
+CREATE TABLE api_usage (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  user_api_key_id INTEGER,
+  api_key_id INTEGER,
+  request_count INTEGER DEFAULT 0,
+  last_used DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (user_api_key_id) REFERENCES user_api_keys(id),
+  FOREIGN KEY (api_key_id) REFERENCES api_keys(id)
+);
+```
+
+### 说明
+
+- **`api_names` 表**：存储唯一的API名称。
+- **`api_keys` 表**：存储每个API名称对应的多个API-KEY，包括分类信息。`api_names_id`作为外键，关联到`api_names`表。
+- **`user_api_keys` 表**：存储用户的API-KEY。
+- **`api_usage` 表**（可选）：记录API的使用情况，包括请求次数和最后使用时间。这个表可以用来监控API的使用情况，帮助管理API-KEY的使用限额。
+
+这些SQL语句假设你使用的是MySQL数据库。如果你使用的是其他类型的数据库（如PostgreSQL、SQLite等），可能需要对SQL语句进行适当的调整。如果有任何问题或需要进一步的帮助，请随时告诉我。
+
+
+
+### 通过 api_name 查询 api_key 的 SQL 语句
+```sql
+SELECT ak.api_key
+FROM api_keys ak
+JOIN api_groups ag ON ak.api_group_id = ag.id
+JOIN api_names an ON an.api_group_id = ag.id
+WHERE an.api_name = 'your_api_name';
+```

test_db.py

@@ -0,0 +1,22 @@
+# PC上数据库的位置为：/mnt/f/微云同步目录/1913864316/dev/projects/api-mapper
+
+from db import Db
+from dotenv import load_dotenv
+import os
+
+# 加载.env文件
+load_dotenv()
+
+db = Db(os.getenv("DB_PATH"))
+
+results = db.execute_query("""
+SELECT an.api_name, ak.api_key
+FROM api_keys ak
+JOIN api_groups ag ON ak.api_group_id = ag.id
+JOIN api_names an ON an.api_group_id = ag.id
+WHERE an.api_name = 'glm-4-flash';
+""")
+
+
+for row in results:
+    print(row)

users.sql

@@ -0,0 +1,41 @@
+/*
+ Navicat Premium Dump SQL
+
+ Source Server         : api_keys
+ Source Server Type    : SQLite
+ Source Server Version : 3045000 (3.45.0)
+ Source Schema         : main
+
+ Target Server Type    : SQLite
+ Target Server Version : 3045000 (3.45.0)
+ File Encoding         : 65001
+
+ Date: 03/11/2024 20:45:36
+*/
+
+PRAGMA foreign_keys = false;
+
+-- ----------------------------
+-- Table structure for users
+-- ----------------------------
+DROP TABLE IF EXISTS "users";
+CREATE TABLE "users" (
+  "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+  "username" TEXT NOT NULL,
+  "password" TEXT NOT NULL,
+  "email" TEXT NOT NULL,
+  "nikename" TEXT,
+  "api_key" TEXT,
+  "config" TEXT,
+  "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
+  "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE ("username" ASC),
+  UNIQUE ("email" ASC)
+);
+
+-- ----------------------------
+-- Auto increment value for users
+-- ----------------------------
+UPDATE "sqlite_sequence" SET seq = 5 WHERE name = 'users';
+
+PRAGMA foreign_keys = true;