Merge branch 'development' of https://linyinghao.cn/gitlab/clark/fastapi-for-apex into development

README.md

+# Fastapi for APEX
+

credential/credential.json

-{
-    "oss": {
-        "<qcloud oss bucket name>": {
-            "oss-program": {
-                "secret_id": "<qcloud oss secret_id>",
-                "secret_key": "<qcloud oss secret_key>",
-                "description": "object-storage-all"
-            }
-        }
-    },
-    "ocr": {
-        "ocr-program": {
-            "secret_id": "<qcloud ocr secret_id>",
-            "secret_key": "<qcloud ocr secret_key>",
-            "description": "文字识别 (ocr)"
-        }
-    },
-    "asr": {
-        "asr-program": {
-            "app_id": "<qcloud ASR app id>",
-            "secret_id": "<qcloud ASR secret_id>",
-            "secret_key": "<qcloud ASR secret_key>",
-            "description": "语音识别 (asr)"
-        }
-    },
-    "paddle": {
-        "aliyun_ecs": {
-            "base_url": "https://xxx.xxx.xxx.xxx:xxxx",
-            "client_id": "<OP fastapi client_id>",
-            "client_secret": "<OP fastapi client_secret>"
-        },
-        "ctyun_ecs": {
-            "base_url": "https://xxx.xxx.xxx.xxx:xxxx",
-            "client_id": "<OP fastapi client_id>",
-            "client_secret": "<OP fastapi client_secret>"
-        }
-    },
-    "whisper": {
-        "aliyun_ecs": {
-            "base_url": "https://xxx.xxx.xxx.xxx:xxxx",
-            "client_id": "<OP fastapi client_id>",
-            "client_secret": "<OP fastapi client_secret>"
-        },
-        "ctyun_ecs": {
-            "base_url": "https://xxx.xxx.xxx.xxx:xxxx",
-            "client_id": "<OP fastapi client_id>",
-            "client_secret": "<OP fastapi client_secret>"
-        }
-    },
-    "gen-ai": {
-        "aliyun":{
-            "api_key": "<Gen AI api_key>",
-            "description": "Tongyi"
-        }
-    }
-}
-
-
+{
+    "oss": {
+        "<qcloud oss bucket name>": {
+            "oss-program": {
+                "secret_id": "<qcloud oss secret_id>",
+                "secret_key": "<qcloud oss secret_key>",
+                "description": "object-storage-all"
+            }
+        }
+    },
+    "ocr": {
+        "ocr-program": {
+            "secret_id": "<qcloud ocr secret_id>",
+            "secret_key": "<qcloud ocr secret_key>",
+            "description": "文字识别 (ocr)"
+        }
+    },
+    "asr": {
+        "asr-program": {
+            "app_id": "<qcloud ASR app id>",
+            "secret_id": "<qcloud ASR secret_id>",
+            "secret_key": "<qcloud ASR secret_key>",
+            "description": "语音识别 (asr)"
+        }
+    },
+    "paddle": {
+        "aliyun_ecs": {
+            "base_url": "https://xxx.xxx.xxx.xxx:xxxx",
+            "client_id": "<OP fastapi client_id>",
+            "client_secret": "<OP fastapi client_secret>"
+        },
+        "ctyun_ecs": {
+            "base_url": "https://xxx.xxx.xxx.xxx:xxxx",
+            "client_id": "<OP fastapi client_id>",
+            "client_secret": "<OP fastapi client_secret>"
+        }
+    },
+    "whisper": {
+        "aliyun_ecs": {
+            "base_url": "https://xxx.xxx.xxx.xxx:xxxx",
+            "client_id": "<OP fastapi client_id>",
+            "client_secret": "<OP fastapi client_secret>"
+        },
+        "ctyun_ecs": {
+            "base_url": "https://xxx.xxx.xxx.xxx:xxxx",
+            "client_id": "<OP fastapi client_id>",
+            "client_secret": "<OP fastapi client_secret>"
+        }
+    },
+    "gen-ai": {
+        "aliyun":{
+            "api_key": "<Gen AI api_key>",
+            "description": "Tongyi"
+        }
+    }
+}
+

credential/oauth2.json

+{
+    "oauth2_secret_key": "<generate random value by openssl rand -hex 32>",
+    "client_db": {
+        "client_id: generate random value by openssl rand -hex 32": {
+            "hashed_client_secret": "<generate by CryptContext(schemes=["bcrypt"], deprecated="auto").hash(password)>",
+            "name": "fastapi_service_test",
+            "description": "This client is for fastapi service test"
+        }
+    }
+}
+

fastapi_security_util.py

+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+# File Name: fastapi_security_util.py
+# Original Author: Clark Lin
+# Email: clark_lin@outlook.com
+#
+# Change History
+# Version   Date        By          Description
+# 0.01      2024-04-24  Clark Lin   Initial version
+# 
+# Main features summary:
+# - Implementation of OAuth2 Authentication
+# 
+# Copyright Information:
+# Copyright © 2024 Oasis
+# Licensed TBD
+# ------------------------------------------------------------------------------
+from datetime import datetime, timedelta, timezone
+from typing import Annotated
+from pydantic import BaseModel
+from fastapi import Depends, FastAPI, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+
+# Import your custom logging manager
+import os
+import logging
+from common.script.logging_manager import LoggingManager
+
+import json
+
+# Initialize logging manager
+curr_module = os.path.basename(__file__)
+# lm = LoggingManager()
+lm = LoggingManager.get_instance()
+
+
+# ------------------------------------------------
+# Init Global Variables
+# ------------------------------------------------
+# Credential file
+credential_file = './credential/oauth2.json'
+
+# to get a string like this run:
+# openssl rand -hex 32
+secret_key = ""
+algorithm = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+# Init crypt context
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# Init Oauth2 schema, specify token endpoint
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+# ------------------------------------------------
+# Sample Repository for Client Verification
+# ------------------------------------------------
+client_db = {}
+
+
+# ------------------------------------------------
+# Get credentials
+# ------------------------------------------------
+def get_credentials(file: str) -> tuple:
+
+    global secret_key
+    global client_db
+
+    try:
+        # Open and read the JSON file
+        with open(file, "r") as credential_file:
+            data = json.load(credential_file)
+
+        # Access data from the JSON
+        secret_key = data['oauth2_secret_key']
+        client_db = data['client_db']
+
+        return secret_key, client_db
+
+    except Exception as e:
+
+        print(e)
+        return None, None
+
+
+# ------------------------------------------------
+# Model Definition
+# ------------------------------------------------
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+
+# ------------------------------------------------
+# Sub Function - Verify Password
+# ------------------------------------------------
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+# ------------------------------------------------
+# Sub Function - Use Cript Context to Get Hash
+# ------------------------------------------------
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+
+# ------------------------------------------------
+# Sub Function - Get Client from Dict by Client ID
+# ------------------------------------------------
+def get_client(db: dict, client_id: str):
+    if client_id in db:
+        client_dict = db[client_id]
+        return client_dict
+
+
+# ------------------------------------------------
+# Sub Function - Authentication Process
+# ------------------------------------------------
+def authenticate_client(client_db: dict, client_id: str, client_secret: str):
+    client = get_client(client_db, client_id)
+    if not client:
+        return False
+    if not verify_password(client_secret, client["hashed_client_secret"]):
+        return False
+    return client
+
+
+# ------------------------------------------------
+# Sub Function - Generate Access Token
+# ------------------------------------------------
+def create_access_token(data: dict, expires_delta: timedelta | None = None):
+    
+    global secret_key
+
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.now(timezone.utc) + expires_delta
+    else:
+        expire = datetime.now(timezone.utc) + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+
+    encoded_jwt = jwt.encode(to_encode, secret_key, algorithm=algorithm)
+    return encoded_jwt
+
+
+# ------------------------------------------------
+# Sub Function - Generate Access Token
+# ------------------------------------------------
+def get_access_token(
+        form_data: OAuth2PasswordRequestForm,
+        without_credential: bool = False) -> Token:
+
+    global secret_key
+    global client_db
+
+    # Get credentials
+    secret_key, client_db = get_credentials(credential_file)
+    if secret_key == None or client_db == None:
+        lm.log(logging.INFO, curr_module, "Failed to get credentials from file [" + credential_file + "]")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to get credentials from file [" + credential_file + "]",
+        )
+
+    # Call authentication process
+    if (not without_credential):
+        client = authenticate_client(client_db, form_data.username, form_data.password)
+        if not client:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Incorrect username or password",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+
+    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    if (not without_credential):
+        access_token = create_access_token(
+            data = {
+                "sub": form_data.username,
+                "name": client["name"],
+                "description": client["description"]
+            },
+            expires_delta = access_token_expires
+        )
+    else:
+        client_id = list(client_db.keys())[0]
+        access_token = create_access_token(
+            data = {
+                "sub": client_id,
+                "name": client_db[client_id]["name"],
+                "description": client_db[client_id]["description"]
+            },
+            expires_delta = access_token_expires
+        )
+    lm.log(logging.INFO, curr_module, 'get_access_token completed with normal')
+
+    return Token(access_token=access_token, token_type="bearer")
+
+
+# ------------------------------------------------
+# Sub Function - Generate Access Token
+# ------------------------------------------------
+def get_access_token_without_credential() -> Token:
+
+    return get_access_token(None, True);
+
+

fastapi_service.py

+# Import FastAPI Libs
+from fastapi import FastAPI, Query
+from pydantic import BaseModel
+import qcloud_cos_service
+import qcloud_ocr_service
+import tongyi_genai_service
+from fastapi.responses import StreamingResponse
+
+from fastapi.middleware.cors import CORSMiddleware
+
+from typing import Annotated
+from fastapi import Depends
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+import fastapi_security_util
+from fastapi_security_util import Token
+
+# ------------------------------------------------
+# Init Global Variables
+# ------------------------------------------------
+# Init Oauth2 schema, specify token endpoint
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+
+# ------------------------------------------------
+# Define FastAPI
+# ------------------------------------------------
+app = FastAPI()
+
+
+# ------------------------------------------------
+# Call Token Service
+# ------------------------------------------------
+@app.post("/token")
+def get_access_token(form_data: Annotated[OAuth2PasswordRequestForm, Depends()]) -> Token:
+
+    return fastapi_security_util.get_access_token(form_data)
+
+
+# ------------------------------------------------
+# Call Token Service without Credential
+# ------------------------------------------------
+@app.post("/token_without_credential")
+def get_access_token_without_credential() -> Token:
+
+    return fastapi_security_util.get_access_token_without_credential()
+
+
+# ------------------------------------------------
+# Define CORS Options
+# ------------------------------------------------
+# origins = [
+#     "http://localhost",
+#     "http://localhost:8000",
+#     "https://yourdomain.com",
+#     # Add more origins if needed
+# ]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # List of allowed origins
+    allow_credentials=True,  # Whether to allow credentials (cookies, authorization headers, etc.)
+    allow_methods=["*"],  # List of allowed methods (GET, POST, PUT, DELETE, etc.)
+    allow_headers=["*"],  # List of allowed headers
+)
+
+# ------------------------------------------------
+# Call File Upload Service Process
+# ------------------------------------------------
+@app.post("/upload/")
+async def upload(file_uplaod_req: qcloud_cos_service.file_upload_req_basemodel):
+
+    return qcloud_cos_service.upload(file_uplaod_req)
+
+
+# ------------------------------------------------
+# Call File Download URL Service Process
+# ------------------------------------------------
+@app.post("/get_download_url/")
+async def get_download_url(file_download_req: qcloud_cos_service.file_download_req_basemodel):
+
+    return qcloud_cos_service.get_download_url(file_download_req)
+
+
+# ------------------------------------------------
+# Call OCR Service Process
+# ------------------------------------------------
+@app.post("/get_detected_text/")
+async def get_detected_text(ocr_req: qcloud_ocr_service.ocr_req_basemodel):
+
+    if ocr_req.tool == 'Q':
+        # Call Qcloud API
+        return qcloud_ocr_service.get_qcloud_detected_text(ocr_req)
+    elif ocr_req.tool == 'LP':
+        # Call Local PaddleOCR API
+        return qcloud_ocr_service.get_paddleocr_detected_text(ocr_req)
+
+
+# ------------------------------------------------
+# Call Gen AI Service Process
+# ------------------------------------------------
+@app.post("/send_message_to_gen_ai/tongyi/")
+async def send_message(send_message_req: tongyi_genai_service.send_message_req_basemodel):
+
+    return tongyi_genai_service.send_message(send_message_req)
+
+
+# ------------------------------------------------
+# Call Gen AI Service Process (send question)
+# ------------------------------------------------
+@app.post("/send_message_to_gen_ai_async/tongyi/send_question")
+async def send_question(
+    token: Annotated[str, Depends(oauth2_scheme)],
+    send_message_req: tongyi_genai_service.send_message_req_basemodel):
+
+    print('token', token)
+    return tongyi_genai_service.send_question(token, send_message_req)
+
+
+# ------------------------------------------------
+# Call Gen AI Service Process (get answer)
+# ------------------------------------------------
+@app.get("/send_message_to_gen_ai_async/tongyi/get_answer")
+async def get_answer(
+    uuid: str = Query(None, title="UUID", description="UUID linked to request payload")):
+
+    return StreamingResponse(tongyi_genai_service.get_answer(uuid), media_type="text/event-stream")

local_paddle_ocr_service.py

@@ -203,4 +203,3 @@ def get_detected_text(ocr_req: ocr_req_basemodel) -> tuple:
 
         return ocr_res
 
-

local_whisper_asr_service.py

@@ -203,4 +203,3 @@ def get_detected_text(asr_req: asr_req_basemodel) -> tuple:
 
         return asr_res
 
-

qcloud_asr_service.py

-# Import FastAPI Libs
-from pydantic import BaseModel
-
-# Import Qcloud OCR Service Libs
-import sys
-# sys.path.append("../qcloud")
-from qcloud.common import credential
-from qcloud.asr import flash_recognizer
-
-# Common log part
-import os
-import logging
-from common.script.logging_manager import LoggingManager
-
-curr_module = os.path.basename(__file__)    # Initialize logging manager
-lm = LoggingManager.get_instance()          # lm = LoggingManager()
-
-# Import Other Common Libs
-import json
-import base64
-import os
-import random
-import string
-
-# ------------------------------------------------
-# Define constants
-# ------------------------------------------------
-c_ret_code_success = 0
-c_ret_code_error = 1
-
-user_name = 'asr-program'
-credential_file = 'credential/credential.json'
-
-
-# ------------------------------------------------
-# Define OCR Request Service Request and Response
-# ------------------------------------------------
-class asr_req_basemodel(BaseModel):
-    asr_tool: str # W: Whisper; Q: Qcloud
-    model: str
-    audio_b64_string: str
-    initial_prompt: str
-
-class asr_res_basemodel(BaseModel):
-    result: int
-    result_message: str
-    detected_text: str
-
-
-# ------------------------------------------------
-# Get credentials
-# ------------------------------------------------
-def get_credentials(file: str, user_name: str) -> tuple:
-
-    try:
-        # Open and read the JSON file
-        with open(file, "r") as credential_file:
-            data = json.load(credential_file)
-
-        # Access data from the JSON
-        app_id = data['asr'][user_name]['app_id']
-        secret_id = data['asr'][user_name]['secret_id']
-        secret_key = data['asr'][user_name]['secret_key']
-
-        return app_id, secret_id, secret_key
-
-    except Exception as e:
-
-        lm.log(logging.INFO, curr_module, str(e))
-        return None, None, None
-
-
-# ------------------------------------------------
-# Function of ASR request to Qcloud COS
-# ------------------------------------------------
-def get_detected_text(asr_req: asr_req_basemodel) -> tuple:
-
-    lm.log(logging.INFO, curr_module, "qcloud get_detected_text start")
-
-    # 初始化处理结果
-    ret_code = c_ret_code_success
-    err_msg = ""
-
-    # 初始化ID
-    app_id = ""
-    secret_id = ""
-    secret_key = ""
-    engine_type = "16k_en"
-
-    # 初始化返回对象
-    asr_resp = asr_res_basemodel(
-        result = c_ret_code_success,
-        result_message = '',
-        detected_text = ''
-    )
-
-    try:
-        app_id, secret_id, secret_key = get_credentials(credential_file, user_name)
-        cred = credential.Credential(secret_id, secret_key)
-
-        if (app_id == None or secret_id == None or secret_key == None):
-            lm.log(logging.ERROR, curr_module, 'Failed to get credential')
-            asr_resp.result = c_ret_code_error
-            asr_resp.detected_text = ''
-            asr_resp.result_message = 'Failed to get credential'
-            return asr_resp
-
-
-        # 新建FlashRecognizer，一个recognizer可以执行N次识别请求
-        recognizer = flash_recognizer.FlashRecognizer(app_id, cred)
-
-        # 新建识别请求
-        req = flash_recognizer.FlashRecognitionRequest(engine_type)
-        req.set_filter_modal(0)
-        req.set_filter_punc(0)
-        req.set_filter_dirty(0)
-        # 目前aac格式可用于解码MacOS Safari/Chrome的录音文件，IOS Safari待确认
-        # req.set_voice_format("wav")
-        req.set_voice_format("aac")
-        req.set_word_info(0)
-        req.set_convert_num_mode(1)
-
-        # 将Base64字符串写到临时文件
-        # Decode base64 string
-        decoded_data = base64.b64decode(asr_req.audio_b64_string)
-
-        # Write the decoded data to a file
-        characters = string.ascii_letters + string.digits
-        random_string = ''.join(random.choice(characters) for i in range(16))
-        tmp_file = '/tmp/whisper_' + random_string
-        with open(tmp_file, 'wb') as file:
-            file.write(decoded_data)
-
-        with open(tmp_file, 'rb') as f:
-            #读取音频数据
-            data = f.read()
-            #执行识别
-            resultData = recognizer.recognize(req, data)
-            resp = json.loads(resultData)
-            request_id = resp["request_id"]
-            code = resp["code"]
-            if code != 0:
-                lm.log(logging.ERROR, curr_module, "recognize faild! request_id: ", request_id, " code: ", code, ", message: ", resp["message"])
-                resp.result = c_ret_code_error
-                resp.detected_text = ''
-                resp.result_message = 'Recognize faild! Please find detail in log.'
-                return resp
-    
-            lm.log(logging.INFO, curr_module, "request_id: ", request_id)
-
-            #一个channl_result对应一个声道的识别结果
-            #大多数音频是单声道，对应一个channl_result
-            for channl_result in resp["flash_result"]:
-
-                lm.log(logging.INFO, curr_module, "channel_id: " + str(channl_result["channel_id"]))
-                lm.log(logging.INFO, curr_module, channl_result["text"])
-
-                asr_resp.result = c_ret_code_success
-                asr_resp.detected_text = channl_result["text"]
-                asr_resp.result_message = ''
-
-                return asr_resp
-
-        lm.log(logging.INFO, curr_module, "qcloud get_detected_text complete")
-
-    except Exception as e:
-
-        lm.log(logging.ERROR, curr_module, str(e))
-
-        asr_resp.result = c_ret_code_error
-        asr_resp.detected_text = ''
-        asr_resp.result_message = str(e)
-        return asr_resp
-
+# Import FastAPI Libs
+from pydantic import BaseModel
+
+# Import Qcloud OCR Service Libs
+import sys
+# sys.path.append("../qcloud")
+from qcloud.common import credential
+from qcloud.asr import flash_recognizer
+
+# Common log part
+import os
+import logging
+from common.script.logging_manager import LoggingManager
+
+curr_module = os.path.basename(__file__)    # Initialize logging manager
+lm = LoggingManager.get_instance()          # lm = LoggingManager()
+
+# Import Other Common Libs
+import json
+import base64
+import os
+import random
+import string
+
+# ------------------------------------------------
+# Define constants
+# ------------------------------------------------
+c_ret_code_success = 0
+c_ret_code_error = 1
+
+user_name = 'asr-program'
+credential_file = 'credential/credential.json'
+
+
+# ------------------------------------------------
+# Define OCR Request Service Request and Response
+# ------------------------------------------------
+class asr_req_basemodel(BaseModel):
+    asr_tool: str # W: Whisper; Q: Qcloud
+    model: str
+    audio_b64_string: str
+    initial_prompt: str
+
+class asr_res_basemodel(BaseModel):
+    result: int
+    result_message: str
+    detected_text: str
+
+
+# ------------------------------------------------
+# Get credentials
+# ------------------------------------------------
+def get_credentials(file: str, user_name: str) -> tuple:
+
+    try:
+        # Open and read the JSON file
+        with open(file, "r") as credential_file:
+            data = json.load(credential_file)
+
+        # Access data from the JSON
+        app_id = data['asr'][user_name]['app_id']
+        secret_id = data['asr'][user_name]['secret_id']
+        secret_key = data['asr'][user_name]['secret_key']
+
+        return app_id, secret_id, secret_key
+
+    except Exception as e:
+
+        lm.log(logging.INFO, curr_module, str(e))
+        return None, None, None
+
+
+# ------------------------------------------------
+# Function of ASR request to Qcloud COS
+# ------------------------------------------------
+def get_detected_text(asr_req: asr_req_basemodel) -> tuple:
+
+    lm.log(logging.INFO, curr_module, "qcloud get_detected_text start")
+
+    # 初始化处理结果
+    ret_code = c_ret_code_success
+    err_msg = ""
+
+    # 初始化ID
+    app_id = ""
+    secret_id = ""
+    secret_key = ""
+    engine_type = "16k_en"
+
+    # 初始化返回对象
+    asr_resp = asr_res_basemodel(
+        result = c_ret_code_success,
+        result_message = '',
+        detected_text = ''
+    )
+
+    try:
+        app_id, secret_id, secret_key = get_credentials(credential_file, user_name)
+        cred = credential.Credential(secret_id, secret_key)
+
+        if (app_id == None or secret_id == None or secret_key == None):
+            lm.log(logging.ERROR, curr_module, 'Failed to get credential')
+            asr_resp.result = c_ret_code_error
+            asr_resp.detected_text = ''
+            asr_resp.result_message = 'Failed to get credential'
+            return asr_resp
+
+
+        # 新建FlashRecognizer，一个recognizer可以执行N次识别请求
+        recognizer = flash_recognizer.FlashRecognizer(app_id, cred)
+
+        # 新建识别请求
+        req = flash_recognizer.FlashRecognitionRequest(engine_type)
+        req.set_filter_modal(0)
+        req.set_filter_punc(0)
+        req.set_filter_dirty(0)
+        # 目前aac格式可用于解码MacOS Safari/Chrome的录音文件，IOS Safari待确认
+        # req.set_voice_format("wav")
+        req.set_voice_format("aac")
+        req.set_word_info(0)
+        req.set_convert_num_mode(1)
+
+        # 将Base64字符串写到临时文件
+        # Decode base64 string
+        decoded_data = base64.b64decode(asr_req.audio_b64_string)
+
+        # Write the decoded data to a file
+        characters = string.ascii_letters + string.digits
+        random_string = ''.join(random.choice(characters) for i in range(16))
+        tmp_file = '/tmp/whisper_' + random_string
+        with open(tmp_file, 'wb') as file:
+            file.write(decoded_data)
+
+        with open(tmp_file, 'rb') as f:
+            #读取音频数据
+            data = f.read()
+            #执行识别
+            resultData = recognizer.recognize(req, data)
+            resp = json.loads(resultData)
+            request_id = resp["request_id"]
+            code = resp["code"]
+            if code != 0:
+                lm.log(logging.ERROR, curr_module, "recognize faild! request_id: ", request_id, " code: ", code, ", message: ", resp["message"])
+                resp.result = c_ret_code_error
+                resp.detected_text = ''
+                resp.result_message = 'Recognize faild! Please find detail in log.'
+                return resp
+    
+            lm.log(logging.INFO, curr_module, "request_id: ", request_id)
+
+            #一个channl_result对应一个声道的识别结果
+            #大多数音频是单声道，对应一个channl_result
+            for channl_result in resp["flash_result"]:
+
+                lm.log(logging.INFO, curr_module, "channel_id: " + str(channl_result["channel_id"]))
+                lm.log(logging.INFO, curr_module, channl_result["text"])
+
+                asr_resp.result = c_ret_code_success
+                asr_resp.detected_text = channl_result["text"]
+                asr_resp.result_message = ''
+
+                return asr_resp
+
+        lm.log(logging.INFO, curr_module, "qcloud get_detected_text complete")
+
+    except Exception as e:
+
+        lm.log(logging.ERROR, curr_module, str(e))
+
+        asr_resp.result = c_ret_code_error
+        asr_resp.detected_text = ''
+        asr_resp.result_message = str(e)
+        return asr_resp
+

qcloud_ocr_service.py

-# Import FastAPI Libs
-from pydantic import BaseModel
-
-# Import Qcloud OCR Service Libs
-from tencentcloud.common import credential
-from tencentcloud.common.profile.client_profile import ClientProfile
-from tencentcloud.common.profile.http_profile import HttpProfile
-from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
-from tencentcloud.ocr.v20181119 import ocr_client, models
-
-# Import Other Common Libs
-import json
-import base64
-import os
-
-# ------------------------------------------------
-# Define constants
-# ------------------------------------------------
-c_ret_code_success = 0
-c_ret_code_error = 1
-
-region = 'ap-shanghai'
-user_name = 'ocr-program'
-credential_file = '/home/oracle/python/apex/credential/credential.json'
-# credential_file = 'C://PyCharmProjects//qcloud-service//config//credential.json'
-
-
-# ------------------------------------------------
-# Define OCR Request Service Request and Response
-# ------------------------------------------------
-class ocr_req_basemodel(BaseModel):
-    ocr_tool: str # Q: Qcloud, LP: Local PaddleOCR
-    dir: str
-    file_name: str
-
-class ocr_res_basemodel(BaseModel):
-    result: int
-    result_message: str
-    detected_text: list
-
-
-# ------------------------------------------------
-# Get credentials
-# ------------------------------------------------
-def get_credentials(file: str, user_name: str) -> tuple:
-
-    try:
-        # Open and read the JSON file
-        with open(file, "r") as credential_file:
-            data = json.load(credential_file)
-
-        # Access data from the JSON
-        secret_id = data['ocr'][user_name]['secret_id']
-        secret_key = data['ocr'][user_name]['secret_key']
-
-        return secret_id, secret_key
-
-    except Exception as e:
-
-        print(e)
-        return None, None
-
-
-# ------------------------------------------------
-# Function of OCR request to Qcloud COS
-# ------------------------------------------------
-def get_detected_text(ocr_req: ocr_req_basemodel) -> tuple:
-
-    ret_code = c_ret_code_success
-    err_msg = ""
-
-    try:
-        secret_id, secret_key = get_credentials(credential_file, user_name)
-        # 实例化一个认证对象，入参需要传入腾讯云账户 SecretId 和 SecretKey，此处还需注意密钥对的保密
-        # 代码泄露可能会导致 SecretId 和 SecretKey 泄露，并威胁账号下所有资源的安全性。以下代码示例仅供参考，建议采用更安全的方式来使用密钥，请参见：https://cloud.tencent.com/document/product/1278/85305
-        # 密钥可前往官网控制台 https://console.cloud.tencent.com/cam/capi 进行获取
-        cred = credential.Credential(secret_id, secret_key)
-        # 实例化一个http选项，可选的，没有特殊需求可以跳过
-        httpProfile = HttpProfile()
-        httpProfile.endpoint = "ocr.tencentcloudapi.com"
-
-        # 实例化一个client选项，可选的，没有特殊需求可以跳过
-        clientProfile = ClientProfile()
-        clientProfile.httpProfile = httpProfile
-        # 实例化要请求产品的client对象,clientProfile是可选的
-        client = ocr_client.OcrClient(cred, region, clientProfile)
-
-        # 打开文件
-        file_location = os.path.normpath(os.path.join(ocr_req.dir, ocr_req.file_name))
-        with open(file_location, "rb") as image_file:
-            encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
-            # print(encoded_string)
-        # Remove file
-        os.remove(file_location)
-
-        # 实例化一个请求对象,每个接口都会对应一个request对象
-        req = models.GeneralHandwritingOCRRequest()
-        params = {
-            "ImageBase64": encoded_string
-        }
-        req.from_json_string(json.dumps(params))
-
-        # 返回的resp是一个GeneralHandwritingOCRResponse的实例，与请求对象对应
-        resp = client.GeneralHandwritingOCR(req)
-        # 输出json格式的字符串回包
-        # print(resp.to_json_string())
-
-        list_detected_text = []
-
-        for text_detection in (json.loads(resp.to_json_string()))['TextDetections']:
-            # print(text_detection['DetectedText'])
-            list_detected_text.append(text_detection['DetectedText'])
-
-        ocr_res = ocr_res_basemodel(
-            result          = ret_code,
-            result_message  = err_msg,
-            detected_text   = list_detected_text
-        )
-
-        return ocr_res
-
-    except TencentCloudSDKException as err:
-
-        ret_code = c_ret_code_error
-        err_msg = str(err)
-
-        ocr_res = ocr_res_basemodel(
-            result          = ret_code,
-            result_message  = err_msg,
-            detected_text   = []
-        )
-
-        return ocr_res
-
-
-
+# Import FastAPI Libs
+from pydantic import BaseModel
+
+# Import Qcloud OCR Service Libs
+from tencentcloud.common import credential
+from tencentcloud.common.profile.client_profile import ClientProfile
+from tencentcloud.common.profile.http_profile import HttpProfile
+from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
+from tencentcloud.ocr.v20181119 import ocr_client, models
+
+# Import Other Common Libs
+import json
+import base64
+import os
+
+# ------------------------------------------------
+# Define constants
+# ------------------------------------------------
+c_ret_code_success = 0
+c_ret_code_error = 1
+
+region = 'ap-shanghai'
+user_name = 'ocr-program'
+credential_file = '/home/oracle/python/apex/credential/credential.json'
+# credential_file = 'C://PyCharmProjects//qcloud-service//config//credential.json'
+
+
+# ------------------------------------------------
+# Define OCR Request Service Request and Response
+# ------------------------------------------------
+class ocr_req_basemodel(BaseModel):
+    ocr_tool: str # Q: Qcloud, LP: Local PaddleOCR
+    dir: str
+    file_name: str
+
+class ocr_res_basemodel(BaseModel):
+    result: int
+    result_message: str
+    detected_text: list
+
+
+# ------------------------------------------------
+# Get credentials
+# ------------------------------------------------
+def get_credentials(file: str, user_name: str) -> tuple:
+
+    try:
+        # Open and read the JSON file
+        with open(file, "r") as credential_file:
+            data = json.load(credential_file)
+
+        # Access data from the JSON
+        secret_id = data['ocr'][user_name]['secret_id']
+        secret_key = data['ocr'][user_name]['secret_key']
+
+        return secret_id, secret_key
+
+    except Exception as e:
+
+        print(e)
+        return None, None
+
+
+# ------------------------------------------------
+# Function of OCR request to Qcloud COS
+# ------------------------------------------------
+def get_detected_text(ocr_req: ocr_req_basemodel) -> tuple:
+
+    ret_code = c_ret_code_success
+    err_msg = ""
+
+    try:
+        secret_id, secret_key = get_credentials(credential_file, user_name)
+        # 实例化一个认证对象，入参需要传入腾讯云账户 SecretId 和 SecretKey，此处还需注意密钥对的保密
+        # 代码泄露可能会导致 SecretId 和 SecretKey 泄露，并威胁账号下所有资源的安全性。以下代码示例仅供参考，建议采用更安全的方式来使用密钥，请参见：https://cloud.tencent.com/document/product/1278/85305
+        # 密钥可前往官网控制台 https://console.cloud.tencent.com/cam/capi 进行获取
+        cred = credential.Credential(secret_id, secret_key)
+        # 实例化一个http选项，可选的，没有特殊需求可以跳过
+        httpProfile = HttpProfile()
+        httpProfile.endpoint = "ocr.tencentcloudapi.com"
+
+        # 实例化一个client选项，可选的，没有特殊需求可以跳过
+        clientProfile = ClientProfile()
+        clientProfile.httpProfile = httpProfile
+        # 实例化要请求产品的client对象,clientProfile是可选的
+        client = ocr_client.OcrClient(cred, region, clientProfile)
+
+        # 打开文件
+        file_location = os.path.normpath(os.path.join(ocr_req.dir, ocr_req.file_name))
+        with open(file_location, "rb") as image_file:
+            encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
+            # print(encoded_string)
+        # Remove file
+        os.remove(file_location)
+
+        # 实例化一个请求对象,每个接口都会对应一个request对象
+        req = models.GeneralHandwritingOCRRequest()
+        params = {
+            "ImageBase64": encoded_string
+        }
+        req.from_json_string(json.dumps(params))
+
+        # 返回的resp是一个GeneralHandwritingOCRResponse的实例，与请求对象对应
+        resp = client.GeneralHandwritingOCR(req)
+        # 输出json格式的字符串回包
+        # print(resp.to_json_string())
+
+        list_detected_text = []
+
+        for text_detection in (json.loads(resp.to_json_string()))['TextDetections']:
+            # print(text_detection['DetectedText'])
+            list_detected_text.append(text_detection['DetectedText'])
+
+        ocr_res = ocr_res_basemodel(
+            result          = ret_code,
+            result_message  = err_msg,
+            detected_text   = list_detected_text
+        )
+
+        return ocr_res
+
+    except TencentCloudSDKException as err:
+
+        ret_code = c_ret_code_error
+        err_msg = str(err)
+
+        ocr_res = ocr_res_basemodel(
+            result          = ret_code,
+            result_message  = err_msg,
+            detected_text   = []
+        )
+
+        return ocr_res
+

tongyi_genai_service.py

 # Import FastAPI Libs
 from pydantic import BaseModel
+<<<<<<< HEAD
+=======
+import fastapi_security_util
+from jose import JWTError, jwt
+from fastapi import HTTPException, status
+>>>>>>> 753bfe8e87baa5e77942adc934d18c6febdf34fa
 
 # Import Dashscope Service Libs
 from http import HTTPStatus
@@ -8,6 +14,11 @@ from dashscope.api_entities.dashscope_response import Role
 import dashscope
 import json
 import os
+<<<<<<< HEAD
+=======
+import asyncio
+import uuid
+>>>>>>> 753bfe8e87baa5e77942adc934d18c6febdf34fa
 
 # Import your custom logging manager
 import logging
@@ -47,6 +58,25 @@ def get_credentials(file: str, gen_ai_id: str) -> str:
         return None
 
 
+# ------------------------------------------------
+# Sub Function - Verify Access Token
+# ------------------------------------------------
+def verify_token(token: str):
+
+    secret_key, client_db = fastapi_security_util.get_credentials(fastapi_security_util.credential_file)
+
+    try:
+        payload = jwt.decode(token, secret_key, algorithms=[fastapi_security_util.algorithm])
+        lm.log(logging.ERROR, curr_module, 'payload: ', str(payload))
+        username: str = payload.get("sub")
+        if username is None:
+            return False
+        return True
+    except JWTError:
+        lm.log(logging.ERROR, curr_module, 'JWTError: ', str(JWTError))
+        return False
+
+
 # ------------------------------------------------
 # Define GenAI Message Service Request and Response
 # ------------------------------------------------
@@ -62,6 +92,10 @@ class send_message_res_basemodel(BaseModel):
     result: int
     result_message: str
     message_res: str
+<<<<<<< HEAD
+=======
+    uuid: str
+>>>>>>> 753bfe8e87baa5e77942adc934d18c6febdf34fa
 
 
 # ------------------------------------------------
@@ -89,7 +123,11 @@ def send_message(messages_req: send_message_req_basemodel) -> send_message_res_b
             dashscope.api_key = api_key
 
         # Set system prompt
+<<<<<<< HEAD
         messages = [{'role': Role.SYSTEM, 'content': 'You are a helpful assistant.'}]
+=======
+        messages = [{'role': Role.SYSTEM, 'content': 'You are a helpful assistant. If you are not sure the answer, please don''t reply with wrong answer.'}]
+>>>>>>> 753bfe8e87baa5e77942adc934d18c6febdf34fa
 
         # Loop input message list
         for message in messages_req.messages:
@@ -109,11 +147,34 @@ def send_message(messages_req: send_message_req_basemodel) -> send_message_res_b
                 model = Generation.Models.qwen_plus
 
         # Use SDK to get answer
+<<<<<<< HEAD
         response = Generation.call(
             model,                  # Generation.Models.qwen_turbo,
             messages=messages,
             result_format='message',  # set the result to be 'message' format.
         )
+=======
+        responses = Generation.call(
+            model,                  # Generation.Models.qwen_turbo,
+            messages=messages,
+            result_format='message',  # set the result to be 'message' format.
+            # Use stream style
+            stream=True,
+            incremental_output=True
+        )
+
+        for debug_response in responses:
+            lm.log(logging.INFO, curr_module, 'Normal response', str(debug_response.output))
+            response = debug_response
+            # if response.status_code == HTTPStatus.OK:
+            #     print(response.output.choices[0]['message']['content'],end='')
+            # else:
+            #     print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (
+            #         response.request_id, response.status_code,
+            #         response.code, response.message
+            #     ))
+
+>>>>>>> 753bfe8e87baa5e77942adc934d18c6febdf34fa
         if response.status_code == HTTPStatus.OK:
 
             lm.log(logging.INFO, curr_module, 'Normal response', str(response))
@@ -151,3 +212,150 @@ def send_message(messages_req: send_message_req_basemodel) -> send_message_res_b
 
         return send_message_res
 
+<<<<<<< HEAD
+=======
+
+# ------------------------------------------------
+# Function to store question (async)
+# ------------------------------------------------
+def send_question(token: str, send_message_req: send_message_req_basemodel):
+
+    if not verify_token(token = token):
+        raise HTTPException(
+            status_code = status.HTTP_401_UNAUTHORIZED,
+            detail = "Authentication Failed",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    result = c_ret_code_success
+    result_message = ""
+
+    # Store questions and uuid at somewhere
+    # Write to file named by UUID
+    uuid_value = str(uuid.uuid4())
+    uuid_file = os.path.join('/tmp/genai-stage', uuid_value)
+    with open(uuid_file, 'w') as file:
+        file.write(json.dumps(send_message_req.dict()))
+
+    send_message_res = send_message_res_basemodel(
+        result          = result,
+        result_message  = result_message,
+        message_res     = '',
+        uuid            = uuid_value
+    )
+
+    return send_message_res
+
+
+# ------------------------------------------------
+# Function to call dashscope SDK (async)
+# ------------------------------------------------
+async def get_answer(uuid: str):
+
+    result = c_ret_code_success
+    result_message = ""
+
+    # Try to read uuid file
+    uuid_file = os.path.join('/tmp/genai-stage', uuid)
+    with open(uuid_file, 'r') as file:
+        content = file.read()
+        lm.log(logging.INFO, curr_module, 'content: ', content)
+        file.close()
+
+    # Init basemodel
+    messages = []
+    messages_req = send_message_req_basemodel(
+        model = "",
+        messages = messages
+    )
+    # Try to deserialize
+    try:
+        data = json.loads(content)
+        messages_req = send_message_req_basemodel(**data)
+        lm.log(logging.INFO, curr_module, 'Deserilized: ', str(messages_req))
+    except json.JSONDecodeError as e:
+        lm.log(logging.INFO, curr_module, 'Failed to decode JSON: ', str(e))
+    except Exception as e:
+        lm.log(logging.INFO, curr_module, 'Failed to create model instance: ', str(e))
+
+    try:
+
+        # Get API Key
+        api_key = get_credentials(credential_file, gen_ai_id)
+        if (api_key == None):
+            result = c_ret_code_error
+            # Set return tuple for normal result
+            send_message_res = send_message_res_basemodel(
+                result          = result,
+                result_message  = 'Failed to get API key',
+                message_res     = ''
+            )
+            # return send_message_res
+            yield send_message_res
+            return
+        else:
+            dashscope.api_key = api_key
+
+        # Set system prompt
+        messages = [{'role': Role.SYSTEM, 'content': 'You are a helpful assistant. If you are not sure the answer, please don''t reply with wrong answer.'}]
+
+        # Loop input message list
+        for message in messages_req.messages:
+            # Set user and assistant prompt
+            messages.append({'role': message.role, 'content': message.text})
+
+        lm.log(logging.INFO, curr_module, 'message: ', str(messages))
+
+        # Get Model
+        # model = Models()
+        match messages_req.model:
+            case 'qwen-max':
+                model = Generation.Models.qwen_max
+            case 'qwen-turbo':
+                model = Generation.Models.qwen_turbo
+            case 'qwen-plus':
+                model = Generation.Models.qwen_plus
+
+        # Use SDK to get answer
+        responses = Generation.call(
+            model,                  # Generation.Models.qwen_turbo,
+            messages=messages,
+            result_format='message',  # set the result to be 'message' format.
+            # Use stream style
+            stream=True,
+            incremental_output=True
+        )
+
+        for debug_response in responses:
+            lm.log(logging.INFO, curr_module, 'Normal response', str(debug_response.output))
+            # yield f"data: {debug_response.output.choices[0]['message']['content']}\n\n"
+            raw_data = debug_response.output.choices[0]['message']['content']
+            # 针对Markdown格式进行优化
+            raw_data = raw_data.replace('\n\n', '\n')
+            raw_data = raw_data.replace('\n', '\n\n')
+            if raw_data.startswith('\n'):
+                raw_data = raw_data[1:]
+            lines = raw_data.splitlines()
+            for line in lines:
+                yield f"data: {line}\n\n"
+            # response = debug_response
+            await asyncio.sleep(0.1)
+            # if response.status_code == HTTPStatus.OK:
+            #     print(response.output.choices[0]['message']['content'],end='')
+            # else:
+            #     print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (
+            #         response.request_id, response.status_code,
+            #         response.code, response.message
+            #     ))
+        
+        # yield 'data: null\n\n'
+        yield 'event: end\ndata: The stream is about to end\n\n'
+
+        os.remove(uuid_file)
+
+    except Exception as e:
+        result = c_ret_code_error
+        result_message = str(e)
+        lm.log(logging.ERROR, 'Exception', result_message)
+        yield f"data: Exception - {result_message}\n\n"
+>>>>>>> 753bfe8e87baa5e77942adc934d18c6febdf34fa