bella-openapi 1.0.0__py3-none-any.whl

ait_openapi/__init__.py

@@ -0,0 +1,22 @@
+from .authorize import validate_token, support_model, account_balance_enough, check_configuration
+from .log import operation_log, submit_log
+from .openapi_contexvar import trace_id_context, caller_id_context, request_url_context
+from .auth_billing import ErrorInfo, async_authenticate_decorator_args, authenticate_user, print_context, \
+get_context, set_context, clean_context, report
+__all__ = ["validate_token", "operation_log",
+           "support_model",
+           "account_balance_enough",
+           "check_configuration",
+           "trace_id_context",
+           "caller_id_context",
+           "request_url_context",
+           "submit_log",
+           "ErrorInfo",
+           "async_authenticate_decorator_args",
+           "authenticate_user",
+           "print_context",
+           "get_context",
+           "set_context",
+           "clean_context",
+           "report"
+           ]

ait_openapi/auth_billing.py

@@ -0,0 +1,91 @@
+from .log import operation_log
+from .authorize import validate_token, check_configuration, account_balance_enough
+from .openapi_contexvar import trace_id_context, caller_id_context, request_url_context
+from pydantic import BaseModel
+import uuid
+from fastapi import Request
+import logging
+# 创建一个日志记录器
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)  # 设置日志级别为INFO
+
+# 创建一个控制台处理器，并设置其级别和格式
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.INFO)
+formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+console_handler.setFormatter(formatter)
+
+# 将处理器添加到日志记录器
+logger.addHandler(console_handler)
+
+class ErrorInfo(BaseModel):
+    task_id: str = ""
+    result: str = ""
+    status: int = 40000001
+    message: str = ""
+
+def async_authenticate_decorator_args(end_point):
+    def async_authenticate_decorator(func):
+        async def wrapper(*args, **kwargs):
+            request_arg = None
+            for arg in args:
+                if type(arg) == Request:
+                    request_arg = arg
+                    break
+            if request_arg is not None:
+                task_id = str(uuid.uuid4())
+                supported, error_json, caller_id = authenticate_user(request_arg.headers.get("Authorization"), task_id)
+                if not supported:
+                    return error_json
+                t_token, c_token, r_token = set_context(task_id, caller_id, end_point)
+                result = await func(*args, **kwargs)
+                clean_context(t_token, c_token, r_token)
+                return result
+            else:
+                logger.warn("please check your request param,have not a param's type is Request of fastapi!")
+            return func(*args, **kwargs)
+        return wrapper
+    return async_authenticate_decorator
+
+
+def authenticate_user(token, task_id):
+    if check_configuration():
+        if token is None:
+            return False, ErrorInfo(task_id=task_id, result="", status=40000001, message="token is missing").dict(), ""
+        try:
+            caller_id = validate_token(token)
+            balance = account_balance_enough(token, cost=1.0)
+
+        except Exception as e:
+            return False, ErrorInfo(task_id=task_id, result="", status=40000001, message=str(e)[:100]).dict(), ""
+        return balance, ErrorInfo(task_id=task_id, result="", status=40000001, message="Insufficient balance").dict(), caller_id
+    else:
+        return True, "", ""
+
+
+@operation_log(op_type='upload_cost_log', is_cost_log=True, ucid_key="ucid")
+def upload_cost_log(result_obejct, ucid):
+    response = result_obejct.dict()
+    return response
+
+def print_context(log):
+    logger.info(f"{log} trace_id:{trace_id_context.get()}, caller_id:{caller_id_context.get()}, end_point:{request_url_context.get()}")
+
+def get_context():
+    return trace_id_context.get(), caller_id_context.get(), request_url_context.get()
+
+def set_context(trace_id, caller_id, end_point):
+    t_token = trace_id_context.set(trace_id)
+    c_token = caller_id_context.set(caller_id)
+    r_token = request_url_context.set(end_point)
+    return t_token, c_token, r_token
+
+def clean_context(t_token, c_token, r_token):
+    trace_id_context.reset(t_token)
+    caller_id_context.reset(c_token)
+    request_url_context.reset(r_token)
+
+def report(result_obejct, ucid = ""):
+    if not check_configuration():
+        return
+    upload_cost_log(result_obejct, ucid)

ait_openapi/authorize.py

@@ -0,0 +1,61 @@
+import httpx
+import logging
+from .config import openapi_config
+from .exception import AuthorizationException
+
+
+def check_configuration() -> bool:
+    res = openapi_config.OPENAPI_HOST is not None
+    return res
+
+
+def validate_token(token: str) -> str:
+    """
+    根据传入token， 解析用户身份
+    :param token:
+    :return: 用户身份，返回账户id
+    :raises: AuthorizationException 如果token无效， 抛出异常
+    """
+    return _validate_token_request(token)
+
+
+def support_model(token: str, model: str) -> bool:
+    """
+    根据传入token，判断用户是否有对应的模型权限
+    :param token: 用户token
+    :param model: 模型名
+    :return: bool
+    """
+    url = openapi_config.OPENAPI_HOST + "/v1/openapi/support/model"
+    # 使用httpx发送get请求
+    response = httpx.get(url, headers={"Authorization": token}, params={"model": model})
+    if response.status_code == 200:
+        return response.json()['data']
+    else:
+        raise AuthorizationException(response.text, response.status_code)
+
+
+def account_balance_enough(token: str, cost: float = 0) -> bool:
+    """
+    账户余额判断，支持传入指定判断阈值，服务方可以在每次用户请求前，根据本次预估花费，对用户余额进行校验，若余额不足，则可拒绝请求
+    :param token: 用户token
+    :param cost: 消耗金额, 单位：元/RMB
+    :return: bool
+    """
+    url = openapi_config.OPENAPI_HOST + "/v1/openapi/check/account/balance"
+    # 使用httpx发送get请求
+    response = httpx.get(url, headers={"Authorization": token}, params={"cost": cost})
+    if response.status_code == 200:
+        return response.json()['data']
+    else:
+        raise AuthorizationException(response.text, response.status_code)
+
+
+def _validate_token_request(token: str) -> str:
+    url = openapi_config.OPENAPI_HOST + "/v1/openapi/validate/tokens"
+    # 使用httpx发送get请求
+    response = httpx.get(url, headers={"Authorization": token})
+    if response.status_code == 200:
+        return response.json()['data']
+    else:
+        raise AuthorizationException(response.text, response.status_code)

ait_openapi/bella_trace/__init__.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+# ======================
+# Date    : 2024/12/30
+# Author  : Liu Yuchen
+# Content : 
+# 协议规范：https://doc.weixin.qq.com/doc/w3_AagAxwZdAD4dsCIEHU3RL26Knh1x8?scode=AJMA1Qc4AAwYUI6MJrAAEASgZXANE
+# ======================
+from ._context import TraceContext, TRACE_ID
+from .fastapi_interceptor import FastapiBellaTraceMiddleware
+import ait_openapi.bella_trace.trace_requests as requests
+from .record_log import trace, BellaTraceHandler
+
+__all__ = ["TraceContext", "TRACE_ID", "FastapiBellaTraceMiddleware", "requests", "trace", "BellaTraceHandler"]

ait_openapi/bella_trace/_context.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+# ======================
+# Date    : 2024/12/30
+# Author  : Liu Yuchen
+# Content : 
+# 
+# ======================
+import os
+import uuid
+from contextvars import ContextVar
+
+__all__ = ["TraceContext", "TRACE_ID"]
+
+
+_trace_id = ContextVar("bella_trace_id", default="")
+_mock_request = ContextVar("mock_request", default="false")
+
+
+TRACE_ID = "X-BELLA-TRACE-ID"
+MOCK_REQUEST = "X-BELLA-MOCK-REQUEST"
+
+
+class _TraceContext(object):
+    @property
+    def trace_id(self) -> str:
+        return _trace_id.get()
+    
+    @trace_id.setter
+    def trace_id(self, value):
+        _trace_id.set(value)
+    
+    @property
+    def service_id(self) -> str:
+        return _get_service_id()
+    
+    @staticmethod
+    def generate_trace_id() -> str:
+        return f"{_get_service_id()}-{uuid.uuid4().hex}"
+    
+    @property
+    def mock_request(self):
+        return _mock_request.get()
+    
+    @mock_request.setter
+    def mock_request(self, value: str):
+        _mock_request.set(value)
+    
+    @property
+    def is_mock_request(self) -> bool:
+        return self.mock_request.lower() == "true"
+    
+    @property
+    def headers(self) -> dict:
+        return {TRACE_ID: self.trace_id, MOCK_REQUEST: self.mock_request}
+
+
+TraceContext = _TraceContext()
+
+
+def _get_service_id() -> str:
+    return os.environ.get("SERVICE_ID", "")

ait_openapi/bella_trace/fastapi_interceptor.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+# ======================
+# Date    : 2024/12/30
+# Author  : Liu Yuchen
+# Content : 
+# 
+# ======================
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from ._context import TraceContext, TRACE_ID, MOCK_REQUEST
+
+__all__ = ["FastapiBellaTraceMiddleware"]
+
+
+class FastapiBellaTraceMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request, call_next):
+        # 设置 trace_id
+        if trace_id_h := request.headers.get(TRACE_ID):
+            TraceContext.trace_id = trace_id_h
+        else:
+            TraceContext.trace_id = TraceContext.generate_trace_id()
+        
+        if mock_request_h := request.headers.get(MOCK_REQUEST):
+            TraceContext.mock_request = mock_request_h
+        
+        # 继续处理请求
+        return await call_next(request)
+

ait_openapi/bella_trace/record_log.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+# ======================
+# Date    : 2024/12/30
+# Author  : Liu Yuchen
+# Content : 
+# 
+# ======================
+import functools
+import json
+import logging
+import time
+import traceback
+
+from ._context import TraceContext
+
+__all__ = ["trace", "BellaTraceHandler"]
+
+
+def trace(logger=logging):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            data = {
+                "trace_info": {
+                    "bellaTraceId": TraceContext.trace_id,
+                    "serviceId": TraceContext.service_id,
+                    "start": time.time()
+                },
+                "function": func.__name__,
+                "args": args,
+                "kwargs": kwargs
+            }
+            try:
+                result = func(*args, **kwargs)
+                data["result"] = result
+                data["trace_info"]["end"] = time.time()
+                logger.info(json.dumps(data, ensure_ascii=False))
+                return result
+            except Exception as e:
+                try:
+                    data["error_msg"] = traceback.format_exception(e)
+                    logger.error(json.dumps(data, ensure_ascii=False))
+                except Exception as i_e:
+                    logger.error(traceback.format_exception(i_e))
+                raise e
+        return wrapper
+    return decorator
+
+
+class BellaTraceHandler(logging.Handler):
+    
+    def __init__(self, fmt: str = "{name}={value}"):
+        super().__init__()
+        self.format = fmt
+    
+    def emit(self, record):
+        if trace_id := TraceContext.trace_id:
+            record.msg = f"{self.format.format(name='trace_id', value=trace_id)} {record.msg}"

ait_openapi/bella_trace/trace_requests.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+# ======================
+# Date    : 2024/12/30
+# Author  : Liu Yuchen
+# Content : 
+# 
+# ======================
+from requests import sessions
+from requests.adapters import HTTPAdapter
+
+from ._context import TraceContext
+
+
+__all__ = ["BellaTraceAdapter"]
+
+
+class BellaTraceAdapter(HTTPAdapter):
+    
+    def send(self, request, **kwargs):
+        request.headers.update(TraceContext.headers)
+        return super().send(request, **kwargs)
+
+
+def request(method, url, **kwargs):
+    with sessions.Session() as session:
+        session.mount("http://", BellaTraceAdapter())
+        session.mount("https://", BellaTraceAdapter())
+        return session.request(method=method, url=url, **kwargs)
+
+
+def get(url, params=None, **kwargs):
+    return request("get", url, params=params, **kwargs)
+
+
+def options(url, **kwargs):
+    return request("options", url, **kwargs)
+
+
+def head(url, **kwargs):
+    kwargs.setdefault("allow_redirects", False)
+    return request("head", url, **kwargs)
+
+
+def post(url, data=None, json=None, **kwargs):
+    return request("post", url, data=data, json=json, **kwargs)
+
+
+def put(url, data=None, **kwargs):
+    return request("put", url, data=data, **kwargs)
+
+
+def patch(url, data=None, **kwargs):
+    return request("patch", url, data=data, **kwargs)
+
+
+def delete(url, **kwargs):
+    return request("delete", url, **kwargs)
+

ait_openapi/config.py

@@ -0,0 +1,15 @@
+from typing import Optional
+import pydantic
+
+if pydantic.version.VERSION.startswith('1.'):
+    from pydantic import BaseSettings
+else:
+    from pydantic.v1 import BaseSettings
+
+
+class OpenAPIConfig(BaseSettings):
+    OPENAPI_HOST: Optional[str]
+    OPENAPI_CONSOLE_KEY: Optional[str]
+
+
+openapi_config = OpenAPIConfig()

ait_openapi/console/__init__.py

@@ -0,0 +1,3 @@
+from .models import get_model_list
+
+__all__ = ["get_model_list"]

ait_openapi/console/models.py

@@ -0,0 +1,45 @@
+from typing import Optional, Dict, Any, Mapping
+
+import httpx
+
+from ait_openapi.config import openapi_config
+
+
+def get_model_list(
+        token: str = openapi_config.OPENAPI_CONSOLE_KEY,
+        extra_headers: Optional[Mapping[str, str]] = None,
+        extra_query: Optional[Mapping[str, object]] = None,
+) -> Dict[str, Any]:
+    """
+    获取模型列表
+
+    Args:
+        token (str): 访问令牌
+        extra_headers: 额外的请求头
+        extra_query: 额外的查询参数，可以包含status、features等
+
+    Returns:
+        Dict[str, Any]: API响应的JSON数据
+
+    Examples:
+        >>> get_model_list(token='****',extra_query={"status": "active", "features": "vision"})
+    """
+    url = openapi_config.OPENAPI_HOST + '/console/model/list'
+    headers = {
+        'Authorization': token,
+        'Content-Type': 'application/json',
+    }
+    # 添加额外的请求头
+    if extra_headers:
+        headers.update(extra_headers)
+    # 构建查询参数
+    params = {}
+    # 添加额外的查询参数
+    if extra_query:
+        params.update(extra_query)
+    # 发送请求
+    response = httpx.get(url, headers=headers, params=params)
+    # 检查响应状态
+    response.raise_for_status()
+    # 返回JSON数据
+    return response.json()

ait_openapi/exception.py

@@ -0,0 +1,7 @@
+class AuthorizationException(Exception):
+    def __init__(self, message, http_status_code=None):
+        self.message = message
+        self.http_stauts_code = http_status_code
+
+    def __repr__(self):
+        return f"AuthorizationError(message={self.message}, http_status_code={self.http_stauts_code})"

ait_openapi/log.py

@@ -0,0 +1,222 @@
+import asyncio
+import functools
+import inspect
+import json
+import logging
+import traceback
+from asyncio import AbstractEventLoop, CancelledError
+from concurrent.futures import Future
+from threading import Thread
+
+import httpx
+
+from .config import openapi_config
+from .schema import OperationLog
+
+
+class operation_log:
+    """
+    当前操作日志装饰器，同时支持同步和异步协程
+
+    用法：
+    @operation_log(op_type='safety_check', is_cost_log=True, ucid_key="ucid")
+    def safety_check(request, *, validate_output: bool):
+        pass
+
+    @operation_log(op_type='safety_check', is_cost_log=True, ucid_key="ucid")
+    async def safety_check(request, *, validate_output: bool):
+        pass
+    """
+
+    def __init__(self, *, op_type: str = None, is_cost_log=False, ucid_key="ucid"):
+        """
+        :param op_type: 表示当前操作动作, 如果不传入则默认使用被装饰的函数名
+        :param is_cost_log: 表示当前日志是否是计费相关日志, 默认为False
+
+        """
+        self.op_type = op_type
+        self.is_cost_log = is_cost_log
+        self.ucid_key = ucid_key
+
+    def __call__(self, func):
+        if inspect.iscoroutinefunction(func):
+            return operation_log.async_log_decorator(func, op_type=self.op_type, is_cost_log=self.is_cost_log, ucid_key=self.ucid_key)
+        return operation_log.log_decorator(func, op_type=self.op_type, is_cost_log=self.is_cost_log, ucid_key=self.ucid_key)
+
+    @staticmethod
+    def log_decorator(func, *, op_type, is_cost_log, ucid_key):
+        """
+        日志装饰器，在函数调用前后记录日志
+        :param func:
+        :param op_type:
+        :param is_cost_log:
+        :return:
+        """
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            nonlocal op_type
+            op_type = op_type if op_type else func.__name__
+            ucid_value = operation_log._get_ucid(ucid_key, func, args, kwargs)
+            opt_in_log = OperationLog(opLogType='in', opType=op_type,
+                                      operationStatus='success',
+                                      request=[args, kwargs],
+                                      response=None,
+                                      isCostLog=is_cost_log,
+                                      ucid=ucid_value,
+                                      )
+
+            submit_log(opt_in_log)
+
+            opt_out_log = None
+            try:
+                resp = func(*args, **kwargs)
+                opt_out_log = OperationLog(opLogType='out', opType=op_type,
+                                           operationStatus='success',
+                                           request=[args, kwargs],
+                                           response=resp,
+                                           isCostLog=is_cost_log,
+                                           ucid=ucid_value,
+                                           )
+                return resp
+            except Exception as e:
+                opt_out_log = OperationLog(opLogType='out', opType=op_type,
+                                           operationStatus='failed',
+                                           request=[args, kwargs],
+                                           response=None,
+                                           errMsg=traceback.format_exc()[:1024],
+                                           isCostLog=is_cost_log,
+                                           ucid=ucid_value,
+                                           )
+                raise e
+            finally:
+                submit_log(opt_out_log)
+
+        return wrapper
+
+    @staticmethod
+    def async_log_decorator(func, *, op_type, is_cost_log, ucid_key):
+        """
+        日志装饰器，在函数调用前后记录日志
+        :param func:
+        :param op_type:
+        :param is_cost_log:
+        :return:
+        """
+
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            nonlocal op_type
+            op_type = op_type if op_type else func.__name__
+            ucid_value = operation_log._get_ucid(ucid_key, func, args, kwargs)
+            opt_in_log = OperationLog(opLogType='in', opType=op_type,
+                                      operationStatus='success',
+                                      request=[args, kwargs],
+                                      response=None,
+                                      isCostLog=is_cost_log,
+                                      ucid=ucid_value,
+                                      )
+
+            submit_log(opt_in_log)
+
+            opt_out_log = None
+            try:
+                resp = await func(*args, **kwargs)
+                opt_out_log = OperationLog(opLogType='out', opType=op_type,
+                                           operationStatus='success',
+                                           request=[args, kwargs],
+                                           response=resp,
+                                           isCostLog=is_cost_log,
+                                           ucid=ucid_value,
+                                           )
+                return resp
+            except Exception as e:
+                opt_out_log = OperationLog(opLogType='out', opType=op_type,
+                                           operationStatus='failed',
+                                           request=[args, kwargs],
+                                           response=None,
+                                           errMsg=traceback.format_exc()[:1024],
+                                           isCostLog=is_cost_log,
+                                           ucid=ucid_value,
+                                           )
+                raise e
+            finally:
+                submit_log(opt_out_log)
+
+        return wrapper
+    @staticmethod
+    def _get_ucid(ucid_key, func, args, kwargs):
+        # 尝试从关键字参数中获取 UCID
+        ucid = kwargs.get(ucid_key)
+        if ucid is None:
+            # 如果 UCID 不在关键字参数中，尝试从位置参数中获取
+            func_params = func.__code__.co_varnames
+            if ucid_key in func_params:
+                ucid_index = func_params.index(ucid_key)
+                if ucid_index < len(args):
+                    ucid = args[ucid_index]
+        return ucid
+
+def submit_log(log: OperationLog):
+    try:
+        task = asyncio.create_task(_async_log(log))
+        task.add_done_callback(log_callback)
+    except RuntimeError:
+        _submit_log_in_thread_event_log(log)
+
+
+# 监控任务日志执行结果
+def log_callback(future: Future):
+    try:
+        future.result()
+    except CancelledError:
+        logging.exception(f'openapi log report task cancelled')
+    except Exception:
+        logging.exception(f'openapi log report task failed')
+
+
+class ThreadedEventLoop(Thread):
+    """
+    如果当前线程没有event loop, 则使用独立线程中的async_log_event_loop
+    """
+
+    def __init__(self, loop: AbstractEventLoop):
+        super().__init__()
+        self.loop = loop
+        self.daemon = True
+
+    def run(self) -> None:
+        self.loop.run_forever()
+
+
+# 启动asyncio event loop， 如果用户当前线程没有event loop，则使用独立线程中的async_log_event_loop
+async_log_event_loop = asyncio.new_event_loop()
+asyncio_thread = ThreadedEventLoop(async_log_event_loop)
+asyncio_thread.start()
+
+
+def _submit_log_in_thread_event_log(log):
+    future = asyncio.run_coroutine_threadsafe(
+        _async_log(log), async_log_event_loop)
+    future.add_done_callback(log_callback)
+
+
+# 异步上报日志
+async_httpx_client = None
+
+
+async def _async_log(log: OperationLog):
+    global async_httpx_client
+    if async_httpx_client is None:
+        async_httpx_client = await httpx.AsyncClient(limits=httpx.Limits(max_connections=50)).__aenter__()
+    # 异步写入日志
+    url = openapi_config.OPENAPI_HOST + "/v1/openapi/report/log"
+    log_data = json.loads(json.dumps(log.dict(by_alias=True), default=lambda x: None))
+    logging.info(f'openapi链路日志上报:{log_data}')
+    response = await async_httpx_client.post(url, json=log_data)
+    if response.status_code != 200:
+        logging.warning(f'log failed, status_code: {response.status_code}, response: {response.text}')
+    return response.status_code
+
+
+__all__ = ['operation_log', 'OperationLog', 'submit_log']

ait_openapi/middleware/__init__.py

@@ -0,0 +1,3 @@
+from .context_middleware import HttpContextMiddleware, WebSocketHttpContextMiddleware
+
+__all__ = ['HttpContextMiddleware', 'WebSocketHttpContextMiddleware']

ait_openapi/middleware/context_middleware.py

@@ -0,0 +1,108 @@
+import uuid
+
+import werkzeug
+from werkzeug.routing import Map, Rule
+from starlette.datastructures import URL
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import JSONResponse
+
+from ait_openapi import caller_id_context, request_url_context, trace_id_context
+from ait_openapi import validate_token
+from ait_openapi.exception import AuthorizationException
+from urllib.parse import parse_qs
+
+
+class WebSocketHttpContextMiddleware:
+    def __init__(self, app, *, exclude_url: list[str] = None):
+        self.app = app
+        self.exclude_url = exclude_url or []
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] != "websocket":
+            return await self.app(scope, receive, send)
+
+        url = URL(scope=scope)
+        if match_url(self.exclude_url, url.path):
+            return await self.app(scope, receive, send)
+
+        query_params = parse_qs(url.query)
+        if not (query_params.get('token')) or query_params.get('token') == '':
+            # send  token required error
+            await send({
+                "type": "websocket.close",
+                "code": 1006,
+                "reason": "token required",
+            })
+            return
+        try:
+            token = query_params.get('token')
+            caller = validate_token(token[0])
+        except AuthorizationException as e:
+            await send({
+                "type": "websocket.close",
+                "code": 1006,
+                "reason": "token invalid",
+            })
+            return
+        else:
+            caller_context_token = caller_id_context.set(caller)
+            trace_id_context_token = trace_id_context.set(str(uuid.uuid4()))
+            request_url_context_token = request_url_context.set(url.path)
+            await self.app(scope, receive, send)
+            caller_id_context.reset(caller_context_token)
+            trace_id_context.reset(trace_id_context_token)
+            request_url_context.reset(request_url_context_token)
+
+
+def match_url(patterns, url):
+    if patterns is None:
+        return False
+    # 创建 URL 规则
+    rules = [Rule(pattern) for pattern in patterns]
+    # 匹配 URL
+    adapter = Map(rules).bind('')
+    try:
+        result = adapter.match(url)
+        return True
+    except werkzeug.exceptions.NotFound:
+        return False
+
+
+class HttpContextMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, *, exclude_url: list[str] = None, ):
+        """
+        :param app
+        :param exclude_url: 不需要验证token的url,
+        根据https://werkzeug.palletsprojects.com/en/2.2.x/routing/  规则进行配置
+        """
+        super().__init__(app)
+        self.exclude_url = exclude_url
+
+    async def dispatch(self, request, call_next):
+        if match_url(self.exclude_url, request.url.path):
+            return await call_next(request)
+
+        if request.url.path.startswith("/v1/actuator/health"):
+            return await call_next(request)
+        authorization = request.headers.get("Authorization")
+        if authorization is None:
+            return JSONResponse(status_code=401, content={"message": "empty Authorization header"})
+
+        try:
+            caller = validate_token(authorization)
+        except AuthorizationException as e:
+            return JSONResponse(status_code=401, content={"message": e.message})
+
+        caller_context_token = caller_id_context.set(caller)
+        trace_id_context_token = trace_id_context.set(str(uuid.uuid4()))
+        request_url_context_token = request_url_context.set(request.url.path)
+
+        # 继续处理请求
+        response = await call_next(request)
+
+        # 重置contextvars上下文
+        caller_id_context.reset(caller_context_token)
+        trace_id_context.reset(trace_id_context_token)
+        request_url_context.reset(request_url_context_token)
+
+        return response

ait_openapi/openapi_contexvar.py

@@ -0,0 +1,6 @@
+from contextvars import ContextVar
+from typing import Optional
+
+trace_id_context: ContextVar[Optional[str]] = ContextVar("trace_id", default=None)
+caller_id_context: ContextVar[Optional[str]] = ContextVar("caller_id", default=None)
+request_url_context: ContextVar[Optional[str]] = ContextVar("request_url", default=None)

ait_openapi/schema.py

@@ -0,0 +1,63 @@
+from datetime import datetime
+from typing import Optional
+
+import uuid
+
+import pydantic
+from pydantic import BaseModel, Field
+from .openapi_contexvar import trace_id_context, caller_id_context, request_url_context
+
+
+class BaseOperationLog(BaseModel):
+    uuid: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    request_id: Optional[str] = Field(default_factory=lambda: trace_id_context.get(),
+                                      alias='requestId')
+    caller_id: Optional[str] = Field(default_factory=lambda: caller_id_context.get(),
+                                     alias='callerId')
+    request_url: Optional[str] = Field(default_factory=lambda: request_url_context.get(),
+                                       alias='requestUrl')
+    op_log_type: str = Field(alias='opLogType')
+    op_type: str = Field(alias='opType')
+    is_cost_log: bool = Field(default=False, alias='isCostLog')
+    operation_status: str = Field(alias='operationStatus')
+    start_time_millis: int = Field(default_factory=lambda: int(datetime.now().timestamp() * 1000),
+                                   alias='startTimeMillis')
+    duration_millis: int = Field(default=0, alias='durationMillis')
+    request: object
+    response: object = Field(default=None)
+    err_msg: Optional[str] = Field(default=None, alias='errMsg')
+    extra_info: dict = Field(default={}, alias='extraInfo')
+    ucid: str = Field(default='ucid')
+
+    @staticmethod
+    def validate(values):
+        if 'request_id' not in values or values['request_id'] is None:
+            raise ValueError('request_id is required, please set trace_id_context')
+        if 'caller_id' not in values or values['caller_id'] is None:
+            raise ValueError('caller_id is required, please set caller_id_context')
+        if 'request_url' not in values or values['request_url'] is None:
+            raise ValueError('request_url is required, please set request_url_context')
+        return values
+
+
+if pydantic.version.VERSION.startswith('1.'):
+    from pydantic import root_validator
+
+
+    class OperationLog(BaseOperationLog):
+        @root_validator
+        def validate_duration_millis(cls, values):
+            super().validate(values)
+            return values
+
+
+else:
+    from pydantic import model_validator
+
+
+    class OperationLog(BaseOperationLog):
+
+        @model_validator(mode='after')
+        def validate_duration_millis(cls, values):
+            super().validate(values.dict())
+            return values

bella_openapi-1.0.0.dist-info/METADATA

@@ -0,0 +1,256 @@
+Metadata-Version: 2.4
+Name: bella-openapi
+Version: 1.0.0
+Summary: client for openapi service.
+Home-page: 
+Author: ['tangxiaolong', 'fanqiangwei', 'zhangxiaojia', 'liumin', 'wangyukun']
+Author-email: 
+Platform: any
+Classifier: Programming Language :: Python :: 3.5
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<=0.26.0,>=0.10.0
+Requires-Dist: Werkzeug==3.0.1
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: platform
+Dynamic: requires-dist
+Dynamic: summary
+
+OpenAPI网关服务客户端
+=======================
+
+## 功能列表
+
+1. 校验token，获取用户信息
+2. 统一上报操作日志至网关侧
+
+## 使用指南
+
+### 安装
+
+```shell
+pip install ait_openapi
+```
+
+### 配置网关域名
+
+通过环境变量设置网关域名
+
+```python
+OPENAPI_HOST = "https://***.com"
+# 需要调用console类接口获得元信息时候会默认取全局的此key，使用者也可根据场景选择不使用默认的KEY，更细粒度的传递指定key
+OPENAPI_CONSOLE_KEY = "************"  
+```
+
+### 配置校验
+
+```python
+from ait_openapi import check_configuration
+# 该函数判断是否所有配置ok，只有所有配置ok的情况下，才能调用鉴权计费等接口
+config_is_ok = check_configuration()
+```
+### token校验
+
+```python
+from ait_openapi import validate_token, support_model, account_balance_enough
+
+token = "****"
+# 根据token，解析用户身份
+user_name = validate_token(token)
+# 查询当前登陆用户，是否具有指定模型的权限
+supported = support_model(token, 'model_name')
+# 账户余额判断，支持传入指定判断阈值，服务方可以在每次用户请求前，根据本次预估花费，对用户余额进行校验，若余额不足，则可拒绝请求
+
+balance = account_balance_enough(token, cost=1.0)
+```
+
+如果token无效，抛出`AuthorizationException`异常
+
+### 上报操作日志
+
+为了追踪用户调用中间处理流程，建议在必要处理操作处，进行操作日志记录上报。操作日志记录分别在操作入口处
+（操作前）和操作出口处（操作后）进行记录上报。
+
+#### 1. 上报模式
+
+为降低上报操作日志延迟对业务逻辑的影响，上报操作日志采用异步上报模式
+
+##### async异步上报
+
+日志上报，将采用异步io的方式，上报操作日志，这种方式，可以在单线程中，同时处理多个并发非阻塞IO操作
+
+```python
+from ait_openapi import operation_log
+
+
+@operation_log()
+def safety_check(request, *, validate_output: bool):
+    pass
+```
+
+#### 2. 上报参数更新
+
+操作日志记录，需要传递一些动态参数，需导入预定义的contextvar，在请求起始处进行设置, 请求结束时清空contextvar
+
+```python
+from ait_openapi import trace_id_context, caller_id_context, request_url_context
+
+# 整个链路处理前，设置
+t_token = trace_id_context.set("*********")  # trace_id 当前请求链路唯一标识
+c_token = caller_id_context.set("*********")  # caller_id 调用方标识, 通过user_info.username获取
+r_token = request_url_context.set("*********")  # request_url 当前请求url
+# #
+# 请求处理
+# 清空contextvar
+trace_id_context.reset(t_token)
+caller_id_context.reset(c_token)
+request_url_context.reset(r_token)
+```
+
+##### 2.1 使用middleware设置contextvar, 将自动进行token解析，以及上下文设置
+
+如果当前url不需要进行拦截，可以配置exclude_path进行过滤
+
+```python
+from ait_openapi.middleware import HttpContextMiddleware, WebSocketHttpContextMiddleware
+from fastapi import FastAPI
+
+app = FastAPI()
+app.add_middleware(HttpContextMiddleware, exclude_path=["/v1/actuator/health/<pattern>"])
+```
+
+##### 2.2 跨线程上下文复制
+
+由于上下文变量是线程隔离的，因此如果需要在独立于设置上下文变量的其他线程中，进行日志记录操作，需要将上下文变量复制到新的线程中
+
+```python
+# 使用contextvars.copy_context(), 复制上下文，并在复制上下文中，执行方法
+import contextvars
+from functools import partial
+from threading import Thread
+
+
+class ThreadCopyContext(Thread):
+    def __init__(self, group=None, target=None, name=None,
+                 args=(), kwargs=None, *, daemon=None):
+        context = contextvars.copy_context()
+        super().__init__(group, context.run, name,
+                         [partial(target, *args, **kwargs if kwargs else {})],
+                         None, daemon=daemon)
+
+
+request_url_context = contextvars.ContextVar('request_url', default='empty')
+r_token = request_url_context.set('http://localhost:8000')
+
+
+def run():
+    print(request_url_context.get())
+
+
+# 未复制contextvar，新的线程中，上下文变量为默认值空
+t = Thread(target=run)
+t.start()
+t.join()
+# > empty
+# 复制contextvar，可以获取到复制的上下文变量
+t = ThreadCopyContext(target=run)
+t.start()
+t.join()
+# > http://localhost:8000
+```
+
+#### 3. 日志记录配置
+
+日志记录中，op_type字段默认取值为当前方法名称，可通过在装饰器中传入参数进行覆盖。该装饰器可同时用于同步方法以及异步协程的日志上报
+为了进行调用计费，如果当前操作日志中的信息，需要用于回调计费，则需要在装饰器中传入is_cost_log=True
+
+```python
+from ait_openapi import operation_log
+
+
+@operation_log(op_type='safety_check', is_cost_log=False, ucid="ucid")
+def safety_check(request, *, validate_output: bool):
+    pass
+
+
+@operation_log(is_cost_log=False, ucid="ucid")
+async def safety_check(request, *, validate_output: bool):
+    pass
+```
+
+#### 4. 直接上报链路日志
+##### 4.1 调用submit_log方法
+
+```python
+from ait_openapi import submit_log
+# construct log
+log = ...
+submit_log(log)
+```
+##### 4.2 http上报
+
+如果在特定场景下，通过装饰器进行链路日志上报不够灵活，您可直接通过调用对应的http 接口上传链路日志
+POST接口url：/v1/openapi/report/log
+
+接口参数：
+
+##### Params
+
+| Name            | Type    | Required | Title   | Description                              |
+|-----------------|---------|----------|---------|------------------------------------------|
+| uuid            | string  | yes      | 日志uuid  | 每条日志，使用不同uuid标识                          |
+| requestId       | string  | yes      | 链路id    | 一次用户请求中，后台多条处理日志，应该使用同一requestId进行串联     |
+| callerId        | string  | yes      | 调用房标识   | 调用token解析得到的当前调用方标识                      |
+| requestUrl      | string  | yes      | 能力端点    | 用户请求，接口url地址                             |
+| opLogType       | string  | yes      | 操作日志类型  | 如果日志在操作入口记录，则改                           |
+| opType          | string  | yes      | 操作类型    | 日志记录对应的操作名称                              |
+| isCostLog       | boolean | yes      | 是否计费日志  | 如果为true，且opLogType为out，该条日志将被用户计算用户调用的费用 |
+| operationStatus | string  | yes      | 操作状态    | none                                     |
+| startTimeMillis | integer | yes      | 操作起始时间戳 | none                                     |
+| durationMillis  | integer | yes      | 操作结束时间戳 | none                                     |
+| request         | object  | yes      | 操作入参    | none                                     |
+| response        | object  | no       | 操作出参    | none                                     |
+| errMsg          | string  | no       | 异常信息    | 如果操作失败，记录失败信息                            |
+| extraInfo       | object  | no       |         | 其他透传信息                                   |
+
+##### Enum
+
+| Name            | Value   | Description  |
+|-----------------|---------|--------------|
+| opLogType       | in      | 日志记录为操作入口处记录 |
+| opLogType       | out     | 日志记录为操作出口处记录 |
+| operationStatus | success | 当前操作成功       |
+| operationStatus | failed  | 当前操作失败       |
+#### 5. 链路日志查询
+get接口地址：/v1/openapi/log/{requestId}
+传入链路id，可查询当前链路下的所有日志信息
+
+### Trace SDK
+使用方法见：[Trace README](./src/ait_openapi/bella_trace/README.md)
+
+## release log
+
+* 0.0.1.2
+    * 修复pydantic 2.x版本，BaseModel校验问题
+* 0.0.1.3
+    * 修复account_balance_enough调用异常
+    * 操作日志中，时间戳记录单位改为毫秒
+    * README文档，增加日志记录contextvar跨线程复制说明, 操作日志上报http接口介绍
+* 0.0.1.4
+    * 修复log日志记录中，对象无法序列化问题
+* 0.0.1.5
+    * 暴露submit_log，支持直接上报日志
+* 0.0.1.8
+    * 支持不配置openapi_host的情况下，鉴权计费可以正常调通  
+* 0.0.1.16
+    * 提供配置检测接口 
+* 0.0.1.25
+    * 新增 Bella Trace 链路日志
+* 0.0.1.26
+    - 新增 console 模块，实现元数据获取
+* 1.0.0
+    - 项目发到python中央仓库

bella_openapi-1.0.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+ait_openapi/__init__.py,sha256=x4-zOWaFs2J7ca0I6e0kP2jPfajmBoRqAbzs6T9PC54,919
+ait_openapi/auth_billing.py,sha256=JbFnCU96NHmME19JXSTbHuqDTU6YDIGTpIDSwaY5WCk,3611
+ait_openapi/authorize.py,sha256=5-vxEUC1LeWd7BKDeCEbOGMluBWbgOJ3bgZhASAW7yY,2211
+ait_openapi/config.py,sha256=JOlLZIslOx6-gB1CRtDVqFK7Po96kO456Fog0p0J4og,334
+ait_openapi/exception.py,sha256=A9wc10ygVTaG0pNUiIc4Cg_kcUcsa9HELiI3htdY9yM,312
+ait_openapi/log.py,sha256=FP3LUNp2mBaAHaNI35_iGdkINNRdB9Q7orSQJgoPLrk,8596
+ait_openapi/openapi_contexvar.py,sha256=70zichjGa9c-8IZjJJyidOD3aHmKNrWlUWP8gulHLFA,327
+ait_openapi/schema.py,sha256=hWVaw9jVVTTiUAn5VXJQYc9idYeJx15-oA-CU_fbopQ,2537
+ait_openapi/bella_trace/__init__.py,sha256=ItVqtDZ79m4ByGSbutQhAOTQ9NjgXneaYx2tigZ_-hU,588
+ait_openapi/bella_trace/_context.py,sha256=mwaOjqMvMdSkFNWRTKKFvWctbvS412K4DNy29JoyL6w,1400
+ait_openapi/bella_trace/fastapi_interceptor.py,sha256=IAlU2JOAxu3WMTvvXv94w56_7B2IBWcVKVXqaR8jJCU,850
+ait_openapi/bella_trace/record_log.py,sha256=33vB3ZotpTltT4YRBP7awdK9-HCAZGaASNVAatKMx3M,1775
+ait_openapi/bella_trace/trace_requests.py,sha256=8R4QiTan8ruH3jBmipdDeNVd8HQIlYqF908I0huy4W8,1428
+ait_openapi/console/__init__.py,sha256=yUP83l7Hp-5qWT7uZ4QZoDfeWx7AjRguWBbPPfVd7Pw,66
+ait_openapi/console/models.py,sha256=HWn7AitLt73Ag2ROyKoUHK34QWtwQ9s_Vz9Wu4IB3cQ,1316
+ait_openapi/middleware/__init__.py,sha256=ZzvwJ9NjB7bKs3LtyVnTp8msHyxLVQoWcyAVmP0k-XA,160
+ait_openapi/middleware/context_middleware.py,sha256=RusQmPV0vLpPJnyH_hKSWYFMXG5n2QkbfRoHGmTQQco,3986
+bella_openapi-1.0.0.dist-info/licenses/LICENSE,sha256=56xiUFcFori4XRJ1nMyyS7DXMSjzaBKWRaZbqCffoY8,1075
+bella_openapi-1.0.0.dist-info/METADATA,sha256=pwC6bFKHFY4aAcKsBTjq48elDw1ufBMQttEqrnpylRw,9483
+bella_openapi-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bella_openapi-1.0.0.dist-info/top_level.txt,sha256=GfjeyDToGVkp5snTGNX7KVPp37VtVWikor-7Yzwr2Hc,12
+bella_openapi-1.0.0.dist-info/RECORD,,

bella_openapi-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bella_openapi-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bella_openapi-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ait_openapi