union-app-chat-stream 1.0.3

package/app/service/union_service.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+import os
+from typing import Optional, Dict, Any, List, Tuple
+from loguru import logger
+from app.utils import common_utils
+
+
+
+
+class UnionService:
+    """Union服务类，提供各类数据查询的通用接口"""
+
+    # 常量定义
+    API_MAX_RETRIES = 10  # API最大重试次数
+    BIGDATA_INTERFACE_FULL_LINK = "running_cnt.full_link_monthly"
+    BIGDATA_INTERFACE_BANK_MONTHLY = "running_cnt.bank_monthly"
+
+    def __init__(self):
+        """初始化服务实例"""
+        self._jira_url: Optional[str] = None
+        self._org_url: Optional[str] = None
+        self._bigdata_url: Optional[str] = None
+        self._union_base_url: Optional[str] = None
+        self._jira_url_token: Optional[str] = None
+        self._org_url_token: Optional[str] = None
+
+    def initialize(self, config) -> None:
+        """初始化服务配置"""
+        self._jira_url = config["GET_JIRA_INFO_URL"]
+        self._org_url = config["GET_ORG_INFO_URL"]
+        self._bigdata_url = config["GET_BIGDATA_URL"]
+        self._union_base_url = config.get("GET_UNION_BASE_URL")
+        self._jira_url_token = config["GET_JIRA_INFO_URL_TOKEN"]
+        self._org_url_token = config["GET_ORG_INFO_URL_TOKEN"]
+        logger.info("Union服务初始化完成")
+
+    def _get_jira_headers(self) -> Dict[str, str]:
+        """构建Jira API请求头"""
+        return {'token': str(self._jira_url_token)}
+
+    def _get_org_headers(self) -> Dict[str, str]:
+        """构建Org API请求头"""
+        return {'token': str(self._org_url_token)}
+
+    def _get_bigdata_headers(self, jsessionid: str) -> Dict[str, str]:
+        """构建BigData API请求头"""
+        return {'Cookie': f'CASSESSIONID={jsessionid}'}
+
+    def _get_union_headers(self, jsessionid: str) -> Dict[str, str]:
+        """构建联合运维 API 请求头"""
+        return {'Cookie': f'CASSESSIONID={jsessionid}'}
+
+    @staticmethod
+    def _build_union_url(base_url: Optional[str], path: str) -> Optional[str]:
+        if not base_url:
+            return None
+        normalized_base = base_url.rstrip("/") + "/"
+        normalized_path = str(path or "").lstrip("/")
+        return f"{normalized_base}{normalized_path}"
+
+    @staticmethod
+    def _extract_response_data(response: Dict[str, Any]) -> Any:
+        data = response.get("data") if isinstance(response, dict) else None
+        if isinstance(data, dict) and "data" in data:
+            return data["data"]
+        return data
+
+    def query_union(
+        self,
+        payload: Dict[str, Any],
+        jsessionid: str,
+        description: str = "查询联合运维数据",
+        path: str = "",
+    ) -> Tuple[Optional[Any], str]:
+        """按 tool definition 中配置的 path 和 JSON 参数查询联合运维 API。"""
+        url = self._build_union_url(self._union_base_url, path)
+        if not url:
+            return None, f"{description}失败: 接口URL未配置"
+        if not jsessionid:
+            return None, f"{description}失败: 登录态ID为空"
+
+        try:
+            response = common_utils.call_https_api(
+                url=url,
+                headers=self._get_union_headers(jsessionid),
+                json_data=payload,
+                max_retries=self.API_MAX_RETRIES,
+            )
+            logger.info(f"{description}成功")
+            return self._extract_response_data(response), "success"
+        except Exception as e:
+            logger.error(f"{description}失败: {e}")
+            return None, str(e)
+
+    def query_jirainfo(self, filtered_time_arrays: List[str]) -> Optional[List[Dict[str, Any]]]:
+        """
+        查询Jira故障信息
+
+        Args:
+            filtered_time_arrays: 过滤后的时间数组
+
+        Returns:
+            Jira故障信息列表，失败返回None
+        """
+        try:
+            response = common_utils.call_https_api(
+                url=self._jira_url,
+                headers=self._get_jira_headers(),
+                json_data=filtered_time_arrays
+            )
+            return response['data']['data']
+        except Exception as e:
+            logger.error(f"jirainfo调用失败: {e.args}")
+            return None
+
+    def query_orginfo(self, org_codes: List[str]) -> Optional[Dict[str, str]]:
+        """
+        查询机构信息
+
+        Args:
+            org_codes: 机构代码列表
+
+        Returns:
+            机构代码到名称的映射字典，失败返回None
+        """
+        try:
+            response = common_utils.call_https_api(
+                url=self._org_url,
+                headers=self._get_org_headers(),
+                json_data=org_codes
+            )
+            return {item['orgCode']: item['orgName'] for item in response['data']['data']}
+        except Exception as e:
+            logger.error(f"orginfo调用失败: {e.args}")
+            return None
+
+    def query_bigdata(
+        self,
+        interface_name: str,
+        params: Dict[str, Any],
+        jsessionid: str,
+        description: str = "大数据查询"
+    ) -> Tuple[Optional[List[Dict[str, Any]]], str]:
+        """
+        通用大数据查询方法
+
+        Args:
+            interface_name: 接口名称
+            params: 请求参数字典
+            jsessionid: 登录态ID，用于外部接口鉴权
+            description: 查询描述（用于日志）
+
+        Returns:
+            (数据列表, 消息)元组
+        """
+        logger.info(f"{description}: {params}")
+
+        data = {
+            "interfaceName": interface_name,
+            "params": str(params)
+        }
+
+        message = "success"
+        filtered_data = None
+
+        try:
+            response = common_utils.call_https_api(
+                url=self._bigdata_url,
+                headers=self._get_bigdata_headers(jsessionid),
+                data=data,
+                max_retries=self.API_MAX_RETRIES
+            )
+            filtered_data = response['data']['data']
+            logger.info(f"{description}成功，共 {len(filtered_data)} 条记录")
+
+        except Exception as e:
+            message = str(e)
+            logger.error(f"{description}失败: {e}")
+
+        return filtered_data, message
+
+    def parse_time_array(self, time_array_str: str) -> List[int]:
+        """
+        解析时间字符串数组为整数数组
+
+        Args:
+            time_array_str: 逗号分隔的时间字符串（格式：yyyy-MM）
+
+        Returns:
+            整数时间数组（格式：yyyyMM）
+        """
+        try:
+            time_array = time_array_str.split(",")
+            return [common_utils.parse_month(item_time) for item_time in time_array]
+        except Exception as e:
+            logger.error(f"解析时间数组失败: {e}")
+            return []
+
+
+# 全局单例实例
+union_service = UnionService()

package/app/utils/__init__.py

@@ -0,0 +1,5 @@
+from . import common_utils
+from . import jwt_utils
+from . import debug_context
+
+__all__ = ["common_utils", "jwt_utils", "debug_context"]

package/app/utils/common_utils.py

@@ -0,0 +1,169 @@
+import requests
+from typing import Optional, Dict, Any
+from requests.exceptions import RequestException, Timeout, ConnectionError
+import json
+import time
+from loguru import logger
+from flask import request as flask_request
+import calendar
+import os.path
+from datetime import datetime
+import re
+import curlify
+
+def get_client_ip():
+    x_forwarded = flask_request.headers.get('X-Forwarded-For')
+    if x_forwarded:
+        ip = x_forwarded.split(',')[0].strip()
+        return ip
+    x_real_ip = flask_request.headers.get('X_Real_Ip')
+    if x_real_ip:
+        return x_real_ip.strip()
+    remote = flask_request.remote_addr
+    return remote if remote else 'no_remote_ip'
+
+
+def call_https_api(
+        url: str,
+        method: str = 'POST',
+        params: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: int = 30,
+        verify_ssl: bool = False,
+        auth: Optional[tuple] = None,
+        proxies: Optional[Dict[str, Any]] = None,
+        max_retries: int = 0,
+        retry_delay: float = 1.0
+
+) -> Dict[str, Any]:
+    default_headers = {
+        'User-Agent': 'Python-HTTPS-Client/1.0'
+    }
+    if headers:
+        default_headers.update(headers)
+    requests_kwargs = {
+        'url': url,
+        'method': method.upper(),
+        'params': params,
+        'headers': default_headers,
+        'timeout': timeout,
+        'verify': verify_ssl
+    }
+    if method:
+        requests_kwargs['method'] = method
+    if data:
+        requests_kwargs['data'] = data
+    if json_data:
+        requests_kwargs['json'] = json_data
+    if auth:
+        requests_kwargs['auth'] = auth
+    if proxies:
+        requests_kwargs['proxies'] = proxies
+    for attempt in range(max_retries + 1):
+        try:
+            logger.info(f"请求{url},第{attempt + 1}次尝试，入参是:{data}|{json_data}，method:{method}")
+            response = requests.request(**requests_kwargs)
+            try:
+                logger.info(f"请求curl命令：{curlify.to_curl(response.request)}")
+            except Exception as e:
+                logger.error(f"curlify报错：{e}")
+            try:
+                json_response = response.json()
+            except json.JSONDecodeError:
+                json_response = {'raw_response': response.text}
+            result = {
+                'success': True,
+                'status_code': response.status_code,
+                'data': json_response
+            }
+            logger.info(f"请求成功：{response.status_code},返回值:{response.text}")
+            return result
+        except ConnectionError as e:
+            logger.error(f"连接失败：{e}")
+        except Timeout as e:
+            logger.error(f"请求超时：{e}")
+        except RequestException as e:
+            logger.error(f"请求异常：{e}")
+        except Exception as e:
+            logger.error(f"未知错误：{e}")
+        if attempt < max_retries:
+            time.sleep(retry_delay)
+        else:
+            break
+    return {
+        'success': False,
+        'status_code': response.status_code,
+        'error_msg': '请求失败'
+    }
+
+
+DATA_DIR = '/data/appLogs/'
+
+
+def read_data_from_txt(file_path):
+    full_path = os.path.join(DATA_DIR, file_path)
+    if not os.path.relpath(full_path).startswith(os.path.relpath(DATA_DIR)):
+        raise ValueError("非法文件路径，禁止访问")
+    if not os.path.exists(full_path):
+        raise FileNotFoundError(f"数据文件{file_path}不存在")
+    with open(full_path, 'r', encoding='utf-8') as f:
+        content = f.read().strip()
+        if not content:
+            return []
+        try:
+            data = json.loads(content)
+            if not isinstance(data, list):
+                raise ValueError("JSON 数据必须是一个数组 list")
+            return data
+        except json.JSONDecodeError as e:
+            logger.error(f"JSON 解析失败{str(e)}")
+            raise ValueError(f"文件内容不是合法的JSON格式：{str(e)}")
+
+
+def parse_month(month_str):
+    if not month_str or not isinstance(month_str, str):
+        raise ValueError("时间参数不能为空")
+    parts = month_str.strip().split('-')
+    if len(parts) == 1:
+        year_str = parts[0]
+        month_str = "1"
+    elif len(parts) == 2:
+        year_str, month_str = parts
+    elif len(parts) == 3:
+        year_str, month_str, day_str = parts
+    else:
+        raise ValueError(f"无效月份格式：{month_str},应为yyyy-mm")
+    try:
+        year = int(year_str)
+        month = int(month_str)
+    except ValueError:
+        raise ValueError(f"年份或月份必须是数字：{month_str}")
+    if not (1 <= month <= 12):
+        raise ValueError(f"月份必须是数字1-12之间：{month_str}")
+    month_padded = f"{month:02d}"
+    return int(f"{year}{month_padded}")
+
+
+def get_days_in_month(yyyymm):
+    year = int(yyyymm[:4])
+    month = int(yyyymm[4:6])
+    _, num_days = calendar.monthrange(year, month)
+    return num_days
+
+
+# current_time_format_by('%Y-%m-%d')
+def current_time_format_by(format_str):
+    current_time = datetime.now().strftime(format_str)
+    return current_time
+
+
+def remove_think_tag(llm_response):
+    # 匹配并移除 <think> 标签及其内容
+    result = re.sub(r'.*?</think>', '', llm_response, flags=re.DOTALL)
+    result = re.sub(r'^\s*```(?:json)?\s*', '', result, flags=re.IGNORECASE)
+    result = re.sub(r'\s*```\s*$', '', result)
+    # 去除多余的空白字符
+    result = re.sub(r'\s+', ' ', result).strip()
+    return result

package/app/utils/debug_context.py

@@ -0,0 +1,16 @@
+import traceback
+from flask import request
+
+
+def check_request_context():
+    try:
+        _ = request.method
+        return True
+    except RuntimeError as e:
+        print(f"runtime error:{e}")
+        traceback.print_stack()
+        return False
+    except Exception as e:
+        print(f"exception:{e}")
+        traceback.print_stack()
+        return False

package/app/utils/function_utils.py

@@ -0,0 +1,274 @@
+"""Tool registry and dispatcher for model function calls."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+import yaml
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+DEFAULT_TOOL_DEFINITIONS_PATH = PROJECT_ROOT / "tools" / "tool_definitions.yaml"
+
+
+@dataclass
+class ToolContext:
+    union_service: Optional[Any] = None
+    rag_service: Optional[Any] = None
+    jsessionid: str = ""
+
+
+ToolFunction = Callable[[Dict[str, Any], ToolContext], Dict[str, Any]]
+
+ALLOWED_BACKEND_METHODS = {
+    "union_service": {"query_union"},
+    "rag_service": {"knowledge_search"},
+}
+
+
+class _MissingOptional:
+    pass
+
+
+MISSING_OPTIONAL = _MissingOptional()
+
+
+def _load_yaml(path: Path) -> Dict[str, Any]:
+    if not path.exists():
+        return {}
+    with path.open("r", encoding="utf-8") as f:
+        data = yaml.safe_load(f) or {}
+    return data if isinstance(data, dict) else {}
+
+
+@lru_cache(maxsize=1)
+def _tool_definition_config() -> Dict[str, Any]:
+    path = Path(os.environ.get("TOOL_DEFINITIONS_PATH", DEFAULT_TOOL_DEFINITIONS_PATH))
+    return _load_yaml(path)
+
+
+def reload_tool_configs():
+    _tool_definition_config.cache_clear()
+
+
+def _raw_tool_definitions() -> List[Dict[str, Any]]:
+    tools_config = _tool_definition_config().get("tools", [])
+    if not isinstance(tools_config, list):
+        return []
+    return [
+        item
+        for item in tools_config
+        if isinstance(item, dict) and str(item.get("name", "")).strip()
+    ]
+
+
+def _schema_properties(schema: Dict[str, Any]) -> Dict[str, Any]:
+    properties = schema.get("properties")
+    return properties if isinstance(properties, dict) else {}
+
+
+def _output_schema_summary(schema: Dict[str, Any]) -> str:
+    if not schema:
+        return ""
+
+    lines = []
+    schema_type = schema.get("type")
+    description = str(schema.get("description") or "").strip()
+    if schema_type or description:
+        header = f"返回结果结构: {schema_type or 'object'}"
+        if description:
+            header = f"{header}，{description}"
+        lines.append(header)
+
+    properties = _schema_properties(schema)
+    if schema.get("type") == "array" and isinstance(schema.get("items"), dict):
+        properties = _schema_properties(schema["items"])
+
+    for name, prop in properties.items():
+        if not isinstance(prop, dict):
+            continue
+        prop_type = str(prop.get("type") or "any")
+        prop_desc = str(prop.get("description") or "").strip()
+        lines.append(f"- {name} ({prop_type}): {prop_desc}")
+
+    return "\n".join(lines)
+
+
+def _to_model_tool(spec: Dict[str, Any]) -> Dict[str, Any]:
+    input_schema = spec.get("input_schema") if isinstance(spec.get("input_schema"), dict) else {}
+    output_schema = spec.get("output_schema") if isinstance(spec.get("output_schema"), dict) else {}
+    description_parts = [
+        str(spec.get("description") or "").strip(),
+        str(spec.get("trigger") or "").strip(),
+        _output_schema_summary(output_schema),
+    ]
+    description = "\n".join(part for part in description_parts if part)
+    parameters = {
+        "type": "object",
+        "properties": _schema_properties(input_schema),
+    }
+    if isinstance(input_schema.get("required"), list):
+        parameters["required"] = input_schema["required"]
+
+    return {
+        "type": "function",
+        "function": {
+            "name": spec["name"],
+            "description": description or str(spec.get("display_name") or spec["name"]),
+            "parameters": parameters,
+        },
+    }
+
+
+def _parse_arguments(arguments: str) -> Dict[str, Any]:
+    if not arguments:
+        return {}
+    parsed = json.loads(arguments)
+    return parsed if isinstance(parsed, dict) else {}
+
+
+def _validate_required_args(spec: Dict[str, Any], args: Dict[str, Any]) -> None:
+    input_schema = spec.get("input_schema") if isinstance(spec.get("input_schema"), dict) else {}
+    required = input_schema.get("required")
+    if not isinstance(required, list):
+        return
+    missing = [name for name in required if args.get(name) in (None, "")]
+    if missing:
+        raise ValueError(f"缺少必填工具参数: {', '.join(str(name) for name in missing)}")
+
+
+def _render_value(value: Any, args: Dict[str, Any], *, allow_missing: bool = False) -> Any:
+    if isinstance(value, str):
+        placeholder_match = re.fullmatch(r"\{([A-Za-z_][A-Za-z0-9_]*)}", value)
+        if placeholder_match:
+            key = placeholder_match.group(1)
+            if key in args:
+                return args[key]
+            if allow_missing:
+                return MISSING_OPTIONAL
+            raise ValueError(f"缺少工具参数: {key}")
+        try:
+            return value.format(**args)
+        except KeyError as exc:
+            if allow_missing:
+                return MISSING_OPTIONAL
+            missing = exc.args[0]
+            raise ValueError(f"缺少工具参数: {missing}") from exc
+    if isinstance(value, dict):
+        rendered = {}
+        for key, item in value.items():
+            rendered_item = _render_value(item, args, allow_missing=allow_missing)
+            if rendered_item is MISSING_OPTIONAL:
+                continue
+            rendered[key] = rendered_item
+        return rendered
+    if isinstance(value, list):
+        rendered_items = []
+        for item in value:
+            rendered_item = _render_value(item, args, allow_missing=allow_missing)
+            if rendered_item is not MISSING_OPTIONAL:
+                rendered_items.append(rendered_item)
+        return rendered_items
+    return value
+
+
+def _base_result(spec: Dict[str, Any], args: Dict[str, Any]) -> Dict[str, Any]:
+    result = {
+        "tool_name": spec["name"],
+        "display_name": spec.get("display_name", spec["name"]),
+        "arguments": args,
+    }
+    output_schema = spec.get("output_schema")
+    if isinstance(output_schema, dict):
+        result["output_schema"] = output_schema
+    return result
+
+
+def _run_backend_tool(
+    spec: Dict[str, Any],
+    args: Dict[str, Any],
+    context: ToolContext,
+) -> Dict[str, Any]:
+    _validate_required_args(spec, args)
+    backend = spec.get("backend") if isinstance(spec.get("backend"), dict) else {}
+    service_name = str(backend.get("service") or "").strip()
+    method_name = str(backend.get("method") or "").strip()
+
+    allowed_methods = ALLOWED_BACKEND_METHODS.get(service_name, set())
+    if method_name not in allowed_methods:
+        raise ValueError(f"工具 {spec['name']} 后端方法未在白名单中: {service_name}.{method_name}")
+    raw_params = backend.get("params") if isinstance(backend.get("params"), dict) else {}
+    payload = _render_value(raw_params, args, allow_missing=True)
+    raw_path = backend.get("path")
+    path = _render_value(raw_path, args, allow_missing=True) if raw_path is not None else ""
+    if path is MISSING_OPTIONAL:
+        path = ""
+    description = str(backend.get("description") or spec.get("display_name") or spec["name"])
+    if service_name == "union_service":
+        if context.union_service is None:
+            raise ValueError("Union服务未初始化")
+        method = getattr(context.union_service, method_name)
+        data, message = method(payload, context.jsessionid, description=description, path=path)
+    elif service_name == "rag_service":
+        if context.rag_service is None:
+            raise ValueError("知识库检索服务未初始化")
+        method = getattr(context.rag_service, method_name)
+        data, message = method(payload.get("query", ""), top_k=payload.get("topK"))
+    else:
+        raise ValueError(f"工具 {spec['name']} 后端服务未支持: {service_name}")
+
+    result = _base_result(spec, args)
+    result.update({
+        "status": "success" if message == "success" else "api_failed",
+        "backend": {
+            "service": service_name,
+            "method": method_name,
+            "description": description,
+        },
+        "payload": payload,
+        "data": data,
+        "message": message,
+    })
+    if path:
+        result["backend"]["path"] = path
+    return result
+
+
+def _make_tool_function(spec: Dict[str, Any]) -> ToolFunction:
+    if isinstance(spec.get("backend"), dict):
+        return lambda args, context: _run_backend_tool(spec, args, context)
+    raise ValueError(f"工具 {spec.get('name')} 已定义但没有可执行实现")
+
+
+TOOL_DEFINITIONS = {
+    str(item.get("name", "")).strip(): item
+    for item in _raw_tool_definitions()
+}
+FUNCTION_MAP: Dict[str, ToolFunction] = {
+    name: _make_tool_function(spec)
+    for name, spec in TOOL_DEFINITIONS.items()
+}
+tools = [_to_model_tool(spec) for name, spec in TOOL_DEFINITIONS.items() if name in FUNCTION_MAP]
+
+
+def call_function(name: str, arguments: str, context: Optional[ToolContext] = None) -> str:
+    tool_function = FUNCTION_MAP.get(name)
+    if tool_function is None:
+        return json.dumps({"error": f"未知函数: {name}"}, ensure_ascii=False)
+
+    try:
+        args = _parse_arguments(arguments)
+        result = tool_function(args, context or ToolContext())
+        return json.dumps(result, ensure_ascii=False)
+    except json.JSONDecodeError as exc:
+        return json.dumps(
+            {"error": f"工具参数不是合法JSON: {str(exc)}", "raw_arguments": arguments},
+            ensure_ascii=False,
+        )
+    except Exception as exc:
+        return json.dumps({"error": f"函数执行异常: {str(exc)}"}, ensure_ascii=False)