Upload 7 files

.gitignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+
+# Logs
+logs/
+*.log
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS specific
+.DS_Store
+Thumbs.db 

Procfile

@@ -0,0 +1 @@
+web: uvicorn app:app --host 0.0.0.0 --port $PORT 

README.md

@@ -1,11 +1,52 @@
----
-title: Dify1
-emoji: 📈
-colorFrom: pink
-colorTo: purple
-sdk: docker
-pinned: false
-short_description: dify
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Dify API 中转服务
+
+这是一个简单的API中转服务，用于将请求转发到Dify API。
+
+## API文档
+
+部署后，可以通过 `/docs` 或 `/redoc` 路径访问API文档。
+
+## 使用方法
+
+### 健康检查
+
+```
+GET /health
+```
+
+返回服务状态。
+
+### 中转API
+
+```
+POST /dify_api
+```
+
+#### 请求头
+
+- `dify_url`: Dify API的基础URL (必需)
+- `dify_key`: Dify API密钥 (必需)
+
+#### 请求体
+
+```json
+{
+  "query": "您的问题或指令",
+  "conversation_id": "可选的会话ID",
+  "user": "用户标识，默认为'user'",
+  "response_mode": "请求模式，'blocking'或'streaming'，默认为'blocking'"
+}
+```
+
+#### 示例请求
+
+```bash
+curl -X POST "https://your-app-url/dify_api" \
+  -H "Content-Type: application/json" \
+  -H "dify_url: https://api.dify.ai/v1" \
+  -H "dify_key: your-dify-api-key" \
+  -d '{
+    "query": "请告诉我关于人工智能的信息",
+    "response_mode": "blocking"
+  }'
+``` 

app.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Dify API 中转服务
+提供REST API端点，转发请求到Dify API
+"""
+
+import os
+import json
+import logging
+from typing import Dict, Any, Optional
+from fastapi import FastAPI, Header, Request, HTTPException, Response
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+import configparser
+from dify_api_client import DifyAPIClient, setup_logging
+
+# 创建FastAPI应用
+app = FastAPI(
+    title="Dify API 中转服务",
+    description="提供REST API端点，转发请求到Dify API",
+    version="1.0.0"
+)
+
+# 添加CORS中间件
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # 允许所有来源
+    allow_credentials=True,
+    allow_methods=["*"],  # 允许所有方法
+    allow_headers=["*"],  # 允许所有头
+)
+
+# 配置日志
+setup_logging(debug=False)
+
+# 请求模型
+class QueryRequest(BaseModel):
+    query: str
+    conversation_id: Optional[str] = None
+    user: Optional[str] = "user"
+    response_mode: Optional[str] = "blocking"  # 'blocking' 或 'streaming'
+
+# 健康检查端点
+@app.get("/health")
+def health_check():
+    return {"status": "ok"}
+
+# Dify API中转端点
+@app.post("/dify_api")
+async def dify_api(
+    request: Request,
+    query_request: QueryRequest,
+    dify_url: Optional[str] = Header(None),
+    dify_key: Optional[str] = Header(None)
+):
+    # 检查必要的头信息
+    if not dify_url:
+        raise HTTPException(status_code=400, detail="缺少必要的请求头: dify_url")
+    if not dify_key:
+        raise HTTPException(status_code=400, detail="缺少必要的请求头: dify_key")
+    
+    logging.info(f"接收到API请求，目标URL: {dify_url}")
+    
+    try:
+        # 创建Dify客户端
+        client = DifyAPIClient(api_key=dify_key, base_url=dify_url)
+        
+        # 根据请求模式处理
+        if query_request.response_mode == "streaming":
+            # 对于流式响应，我们需要使用StreamingResponse
+            # 但由于原始客户端不支持异步流式返回，这里我们先返回完整响应
+            # 在实际生产环境中，应该重构客户端代码以支持异步流式响应
+            response_text = client.send_request_streaming(
+                content=query_request.query,
+                conversation_id=query_request.conversation_id,
+                user=query_request.user
+            )
+            return {"answer": response_text}
+        else:
+            # 阻塞模式
+            response_data = client.send_request_blocking(
+                content=query_request.query,
+                conversation_id=query_request.conversation_id,
+                user=query_request.user
+            )
+            return response_data
+            
+    except Exception as e:
+        logging.error(f"处理请求时出错: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"处理请求时出错: {str(e)}")
+
+# 主函数
+def main():
+    # 在本地运行时使用
+    uvicorn.run("app:app", host="0.0.0.0", port=8000, reload=True)
+
+if __name__ == "__main__":
+    main() 

config.ini

@@ -0,0 +1,11 @@
+[API]
+# 替换为您的Dify API密钥
+api_key = app-besh0Rt34xVTMiKWoZeKD1HN
+# Dify API基础URL
+base_url = http://114.132.220.127:8088/v1
+
+[SETTINGS]
+# 默认请求模式：streaming(流式) 或 blocking(阻塞)
+default_mode = streaming
+# 默认用户标识
+default_user = user 

dify_api_client.py

@@ -0,0 +1,424 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Dify API 客户端
+从本地txt文件读取内容，发送到Dify API
+支持阻塞模式和流式模式
+"""
+
+import os
+import sys
+import json
+import argparse
+import requests
+import sseclient
+import logging
+import configparser
+from typing import Dict, Any, Optional, Union
+from datetime import datetime
+
+
+# 配置日志
+def setup_logging(debug: bool = False) -> None:
+    """
+    设置日志记录
+    
+    Args:
+        debug: 是否启用调试模式
+    """
+    log_level = logging.DEBUG if debug else logging.INFO
+    log_format = '%(asctime)s - %(levelname)s - %(message)s'
+    
+    # 创建logs目录（如果不存在）
+    os.makedirs('logs', exist_ok=True)
+    
+    # 设置文件日志
+    log_file = f'logs/dify_api_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log'
+    
+    # 配置日志记录器
+    logging.basicConfig(
+        level=log_level,
+        format=log_format,
+        handlers=[
+            logging.FileHandler(log_file, encoding='utf-8'),
+            logging.StreamHandler()
+        ]
+    )
+
+# 加载配置文件
+def load_config(config_path='config.ini'):
+    """
+    从配置文件加载设置
+    
+    Args:
+        config_path: 配置文件路径
+        
+    Returns:
+        配置对象
+    """
+    config = configparser.ConfigParser()
+    
+    # 检查配置文件是否存在
+    if os.path.exists(config_path):
+        config.read(config_path, encoding='utf-8')
+        logging.debug(f"已加载配置文件: {config_path}")
+    else:
+        logging.warning(f"配置文件不存在: {config_path}, 将使用默认值或命令行参数")
+    
+    return config
+
+
+class DifyAPIClient:
+    """Dify API 客户端类"""
+    
+    DEFAULT_BASE_URL = "http://114.132.220.127:8088/v1"
+    
+    def __init__(self, api_key: str, base_url: str = None):
+        """
+        初始化Dify API客户端
+        
+        Args:
+            api_key: API密钥
+            base_url: API基础URL，如果未提供则使用默认值
+        """
+        self.api_key = api_key
+        self.base_url = base_url or self.DEFAULT_BASE_URL
+        self.headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        logging.debug(f"初始化Dify客户端，BASE_URL: {self.base_url}")
+    
+    def read_content_from_file(self, file_path: str) -> str:
+        """
+        从文件中读取内容
+        
+        Args:
+            file_path: 文件路径
+            
+        Returns:
+            文件内容
+        """
+        try:
+            logging.info(f"正在读取文件: {file_path}")
+            with open(file_path, 'r', encoding='utf-8') as file:
+                content = file.read().strip()
+                logging.debug(f"成功读取文件，内容长度: {len(content)} 字符")
+                return content
+        except FileNotFoundError:
+            logging.error(f"文件不存在: {file_path}")
+            print(f"错误: 文件 '{file_path}' 不存在")
+            sys.exit(1)
+        except PermissionError:
+            logging.error(f"没有权限访问文件: {file_path}")
+            print(f"错误: 没有权限读取文件 '{file_path}'")
+            sys.exit(1)
+        except Exception as e:
+            logging.error(f"读取文件时出错: {str(e)}", exc_info=True)
+            print(f"读取文件时出错: {str(e)}")
+            sys.exit(1)
+    
+    def send_request_blocking(self, content: str, conversation_id: str = None, user: str = "user") -> Dict[str, Any]:
+        """
+        发送阻塞模式请求
+        
+        Args:
+            content: 请求内容
+            conversation_id: 会话ID
+            user: 用户标识
+            
+        Returns:
+            API响应
+        """
+        url = f"{self.base_url}/chat-messages"
+        
+        payload = {
+            "query": content,
+            "inputs": {},
+            "response_mode": "blocking",
+            "user": user
+        }
+        
+        if conversation_id:
+            payload["conversation_id"] = conversation_id
+            
+        logging.info(f"发送阻塞模式请求，用户: {user}")
+        if conversation_id:
+            logging.info(f"会话ID: {conversation_id}")
+        
+        logging.debug(f"请求URL: {url}")
+        logging.debug(f"请求负载: {json.dumps(payload, ensure_ascii=False)}")
+        
+        try:
+            response = requests.post(url, headers=self.headers, json=payload)
+            response.raise_for_status()
+            response_data = response.json()
+            logging.info("API请求成功")
+            logging.debug(f"API响应: {json.dumps(response_data, ensure_ascii=False)}")
+            return response_data
+        except requests.exceptions.HTTPError as e:
+            logging.error(f"HTTP错误: {e}")
+            if hasattr(response, 'text'):
+                logging.error(f"API响应内容: {response.text}")
+            print(f"HTTP错误: {e}")
+            if hasattr(response, 'text') and response.text:
+                print(f"API响应: {response.text}")
+            sys.exit(1)
+        except requests.exceptions.ConnectionError:
+            logging.error("连接错误: 无法连接到API服务器")
+            print("连接错误: 无法连接到API服务器")
+            sys.exit(1)
+        except requests.exceptions.Timeout:
+            logging.error("超时错误: API请求超时")
+            print("超时错误: API请求超时")
+            sys.exit(1)
+        except requests.exceptions.RequestException as e:
+            logging.error(f"请求错误: {str(e)}", exc_info=True)
+            print(f"请求错误: {e}")
+            sys.exit(1)
+        except json.JSONDecodeError:
+            logging.error("解析错误: API返回的响应不是有效的JSON格式")
+            if hasattr(response, 'text'):
+                logging.error(f"API响应内容: {response.text}")
+            print("解析错误: API返回的响应不是有效的JSON格式")
+            if hasattr(response, 'text'):
+                print(f"API响应: {response.text}")
+            sys.exit(1)
+        except Exception as e:
+            logging.error(f"未知错误: {str(e)}", exc_info=True)
+            print(f"发送请求时发生未知错误: {str(e)}")
+            sys.exit(1)
+    
+    def send_request_streaming(self, content: str, conversation_id: str = None, user: str = "user") -> str:
+        """
+        发送流式模式请求
+        
+        Args:
+            content: 请求内容
+            conversation_id: 会话ID
+            user: 用户标识
+            
+        Returns:
+            完整的响应文本
+        """
+        url = f"{self.base_url}/chat-messages"
+        
+        payload = {
+            "query": content,
+            "inputs": {},
+            "response_mode": "streaming",
+            "user": user
+        }
+        
+        if conversation_id:
+            payload["conversation_id"] = conversation_id
+        
+        logging.info(f"发送流式模式请求，用户: {user}")
+        if conversation_id:
+            logging.info(f"会话ID: {conversation_id}")
+        
+        logging.debug(f"请求URL: {url}")
+        logging.debug(f"请求负载: {json.dumps(payload, ensure_ascii=False)}")
+        
+        try:
+            # 使用流式请求
+            response = requests.post(url, headers=self.headers, json=payload, stream=True)
+            response.raise_for_status()
+            
+            # 创建SSE客户端
+            client = sseclient.SSEClient(response)
+            
+            # 初始化变量，用于累积回答
+            full_answer = ""
+            conversation_id = None
+            
+            # 处理每个事件
+            for event in client.events():
+                try:
+                    # 解析事件数据
+                    data = json.loads(event.data)
+                    event_type = data.get("event")
+                    
+                    # 记录会话ID（如果存在且我们尚未捕获它）
+                    if not conversation_id and "conversation_id" in data:
+                        conversation_id = data["conversation_id"]
+                        logging.debug(f"获取到会话ID: {conversation_id}")
+                    
+                    if event_type == "message":
+                        # 提取回答文本并打印
+                        answer_chunk = data.get("answer", "")
+                        full_answer += answer_chunk
+                        print(answer_chunk, end="", flush=True)
+                        logging.debug(f"接收到消息事件: {answer_chunk}")
+                    
+                    elif event_type == "message_end":
+                        # 消息结束事件
+                        print("\n\n--- 消息结束 ---")
+                        logging.info("消息流结束")
+                        
+                        # 输出元数据
+                        if "metadata" in data:
+                            usage = data["metadata"].get("usage", {})
+                            if usage:
+                                print(f"\n使用情况统计:")
+                                print(f"  总Token数: {usage.get('total_tokens', 'N/A')}")
+                                print(f"  提示Token数: {usage.get('prompt_tokens', 'N/A')}")
+                                print(f"  补全Token数: {usage.get('completion_tokens', 'N/A')}")
+                                print(f"  总费用: {usage.get('total_price', 'N/A')} {usage.get('currency', 'USD')}")
+                                
+                                logging.info(f"使用统计 - 总Token数: {usage.get('total_tokens', 'N/A')}, " 
+                                            f"总费用: {usage.get('total_price', 'N/A')} {usage.get('currency', 'USD')}")
+                    
+                    elif event_type == "workflow_started":
+                        logging.info("工作流开始")
+                    
+                    elif event_type == "node_started":
+                        node_id = data.get("data", {}).get("node_id", "unknown")
+                        logging.debug(f"节点开始执行: {node_id}")
+                    
+                    elif event_type == "node_finished":
+                        node_id = data.get("data", {}).get("node_id", "unknown")
+                        status = data.get("data", {}).get("status", "unknown")
+                        logging.debug(f"节点执行完成: {node_id}, 状态: {status}")
+                    
+                    elif event_type == "workflow_finished":
+                        status = data.get("data", {}).get("status", "unknown")
+                        logging.info(f"工作流完成，状态: {status}")
+                    
+                    elif event_type == "error":
+                        # 错误事件
+                        error_message = data.get("message", "未知错误")
+                        logging.error(f"API错误: {error_message}")
+                        print(f"\n错误: {error_message}")
+                        break
+                        
+                except json.JSONDecodeError:
+                    logging.error(f"解析错误: 无法解析事件数据: {event.data}")
+                    print(f"\n解析错误: 无法解析事件数据: {event.data}")
+                except Exception as e:
+                    logging.error(f"处理事件时出错: {str(e)}", exc_info=True)
+                    print(f"\n处理事件时出错: {str(e)}")
+                
+            # 如果获取到了会话ID，显示给用户
+            if conversation_id:
+                print(f"\n会话ID: {conversation_id}")
+                
+            return full_answer
+            
+        except requests.exceptions.HTTPError as e:
+            logging.error(f"HTTP错误: {e}")
+            if hasattr(response, 'text'):
+                logging.error(f"API响应内容: {response.text}")
+            print(f"HTTP错误: {e}")
+            if hasattr(response, 'text') and response.text:
+                print(f"API响应: {response.text}")
+            sys.exit(1)
+        except requests.exceptions.ConnectionError:
+            logging.error("连接错误: 无法连接到API服务器")
+            print("连接错误: 无法连接到API服务器")
+            sys.exit(1)
+        except requests.exceptions.Timeout:
+            logging.error("超时错误: API请求超时")
+            print("超时错误: API请求超时")
+            sys.exit(1)
+        except requests.exceptions.RequestException as e:
+            logging.error(f"请求错误: {str(e)}", exc_info=True)
+            print(f"请求错误: {e}")
+            sys.exit(1)
+        except Exception as e:
+            logging.error(f"处理流式响应时出错: {str(e)}", exc_info=True)
+            print(f"处理流式响应时出错: {str(e)}")
+            sys.exit(1)
+
+
+def main():
+    """主函数"""
+    # 加载配置文件
+    config = load_config()
+    
+    # 从配置文件获取默认值
+    default_api_key = config.get('API', 'api_key', fallback=None) 
+    default_mode = config.get('SETTINGS', 'default_mode', fallback='streaming')
+    default_user = config.get('SETTINGS', 'default_user', fallback='user')
+    default_base_url = config.get('API', 'base_url', fallback=None)
+    
+    # 设置默认文件
+    default_file = 'example_query.txt'
+    
+    parser = argparse.ArgumentParser(description='Dify API 客户端 - 从本地txt文件读取内容发送到API')
+    parser.add_argument('file_path', nargs='?', default=default_file, 
+                      help=f'本地txt文件路径 (默认: {default_file})')
+    parser.add_argument('--api-key', help='Dify API密钥（如果未指定，将从config.ini读取）')
+    parser.add_argument('--base-url', help='Dify API基础URL（如果未指定，将从config.ini读取）')
+    parser.add_argument('--mode', choices=['blocking', 'streaming'], default=default_mode,
+                       help=f'请求模式: blocking(阻塞) 或 streaming(流式), 默认为 {default_mode}')
+    parser.add_argument('--conversation-id', help='会话ID，用于继续已有对话')
+    parser.add_argument('--user', default=default_user, help=f'用户标识, 默认为 {default_user}')
+    parser.add_argument('--debug', action='store_true', help='启用调试日志')
+    
+    args = parser.parse_args()
+    
+    # 设置日志
+    setup_logging(args.debug)
+    
+    logging.info("Dify API客户端启动")
+    logging.info(f"模式: {args.mode}")
+    
+    # 确定API密钥
+    api_key = args.api_key or default_api_key
+    
+    if api_key is None or api_key == 'your_api_key_here':
+        logging.error("未提供API密钥，请在命令行参数中使用--api-key指定，或在config.ini中配置")
+        print("错误: 未提供API密钥，请使用--api-key参数提供，或在config.ini中配置")
+        sys.exit(1)
+    
+    # 确定API基础URL
+    base_url = args.base_url or default_base_url
+    
+    try:
+        # 创建客户端实例
+        client = DifyAPIClient(api_key, base_url)
+        
+        # 从文件读取内容
+        content = client.read_content_from_file(args.file_path)
+        
+        if not content:
+            logging.error("文件内容为空")
+            print("错误: 文件内容为空")
+            sys.exit(1)
+        
+        print(f"正在使用 {args.mode} 模式发送请求...")
+        
+        # 根据模式发送请求
+        if args.mode == 'blocking':
+            response = client.send_request_blocking(content, args.conversation_id, args.user)
+            print("\n响应:")
+            print(f"{response['answer']}")
+            
+            if 'metadata' in response and 'usage' in response['metadata']:
+                usage = response['metadata']['usage']
+                print(f"\n使用情况统计:")
+                print(f"  总Token数: {usage.get('total_tokens', 'N/A')}")
+                print(f"  提示Token数: {usage.get('prompt_tokens', 'N/A')}")
+                print(f"  补全Token数: {usage.get('completion_tokens', 'N/A')}")
+                print(f"  总费用: {usage.get('total_price', 'N/A')} {usage.get('currency', 'USD')}")
+            
+            print(f"\n会话ID: {response.get('conversation_id', 'N/A')}")
+        else:
+            client.send_request_streaming(content, args.conversation_id, args.user)
+        
+        logging.info("请求执行完毕")
+    
+    except KeyboardInterrupt:
+        logging.info("用户中断操作")
+        print("\n操作被用户中断")
+        sys.exit(0)
+    except Exception as e:
+        logging.error(f"未捕获的异常: {str(e)}", exc_info=True)
+        print(f"发生未知错误: {str(e)}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main() 

requirements.txt

@@ -0,0 +1,6 @@
+requests>=2.28.0
+sseclient-py>=1.7.2
+fastapi>=0.95.0
+uvicorn>=0.21.0
+python-multipart>=0.0.6
+pydantic>=1.10.7