update

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,14 @@
+
+.git/
+.idea/
+
+/data/
+/dotenv/
+/logs/
+/trained_models
+/temp/
+
+**/__pycache__/
+
+#**/*.wav
+**/*.xlsx

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.12-slim
+
+WORKDIR /code
+
+COPY . /code
+
+RUN apt-get update
+RUN apt-get install -y wget unzip ffmpeg build-essential
+
+RUN pip install --upgrade pip
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+RUN useradd -m -u 1000 user
+
+USER user
+
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+RUN bash install.sh --stage 1 --stop_stage 1 --system_version ubuntu
+
+CMD ["python3", "main.py"]

README.md

@@ -0,0 +1,11 @@
+---
+title: Open Gemini API
+emoji: 🐨
+colorFrom: purple
+colorTo: pink
+sdk: docker
+pinned: false
+license: apache-2.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

examples/api_eval/eval_gemini.py

@@ -0,0 +1,120 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import json
+
+from openai import OpenAI
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--gemini_api_key",
+        default=environment.get(key="GEMINI_API_KEY"),
+        type=str
+    )
+    parser.add_argument(
+        "--model_name",
+        # default="gemini-2.5-pro",
+        default="gemini-2.5-flash",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data",
+        default=(project_path / "data/arc-easy.jsonl").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--eval_result",
+        default=(project_path / "data/eval_math_result.jsonl").as_posix(),
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    client = OpenAI(
+        api_key=args.gemini_api_key,
+        base_url="https://generativelanguage.googleapis.com/v1beta"
+    )
+
+    total = 0
+    total_correct = 0
+    with open(args.eval_data, "r", encoding="utf-8") as fin, open(args.eval_result, "a+", encoding="utf-8") as fout:
+        for row in fin:
+            row = json.loads(row)
+            idx = row["id"]
+            question = row["question"]
+            choices = row["choices"]
+            answer_key = row["answerkey"]
+
+            instruct = "Complete this single-choice question."
+
+            choices_str = ""
+            for choice in choices:
+                label = choice["label"]
+                text = choice["text"]
+                choices_str += f"If you think the answer is `{text}` output: `{label}`\n"
+
+            prompt = f"""
+{instruct}
+
+Question: 
+{question}
+
+Choices: 
+{choices_str}
+
+Remember to output ONLY the corresponding letter.
+Your output is:
+            """.strip()
+            # print(prompt)
+            response = client.chat.completions.create(
+                model="gemini-2.5-pro",
+                messages=[{"role": "user", "content": prompt}],
+                stream=False,
+                # max_tokens=1,
+                temperature=0.0,
+                # logit_bias={
+                #     32: 100,
+                #     33: 100,
+                #     34: 100,
+                #     35: 100,
+                #     36: 100,
+                # }
+            )
+
+            prediction = response.choices[0].message.content
+
+            correct = 1 if prediction == answer_key else 0
+
+            total += 1
+            total_correct += correct
+            score = total_correct / total
+
+            row_ = {
+                "id": idx,
+                "question": question,
+                "choices": choices,
+                "ground_true": answer_key,
+                "prediction": prediction,
+                "correct": correct,
+                "total": total,
+                "total_correct": total_correct,
+                "score": score,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+            print(f"score: {score}")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/api_eval/eval_gemini_google.py

@@ -0,0 +1,156 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import json
+import os
+import time
+
+from google import genai
+from google.genai import types
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--google_application_credentials",
+        default=(project_path / "dotenv/potent-veld-462405-t3-8091a29b2894.json").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--model_name",
+        # default="gemini-2.5-pro",
+        default="gemini-2.5-flash",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data",
+        default=(project_path / "data/arc-easy.jsonl").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--eval_result",
+        default=(project_path / "data/eval_math_result.jsonl").as_posix(),
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = args.google_application_credentials
+
+    client = genai.Client(
+        vertexai=True,
+        project="potent-veld-462405-t3",
+        location="global",
+    )
+    generate_content_config = types.GenerateContentConfig(
+        temperature=1,
+        top_p=0.95,
+        max_output_tokens=8192,
+        response_modalities=["TEXT"],
+    )
+
+    total = 0
+    total_correct = 0
+
+    # finished
+    finished_idx_set = set()
+    if os.path.exists(args.eval_result):
+        with open(args.eval_result, "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                idx = row["id"]
+                total = row["total"]
+                total_correct = row["total_correct"]
+                finished_idx_set.add(idx)
+    print(f"finished count: {len(finished_idx_set)}")
+
+    with open(args.eval_data, "r", encoding="utf-8") as fin, open(args.eval_result, "a+", encoding="utf-8") as fout:
+        for row in fin:
+            if total > 20:
+                break
+
+            row = json.loads(row)
+            idx = row["id"]
+            question = row["question"]
+            choices = row["choices"]
+            answer_key = row["answerkey"]
+
+            if idx in finished_idx_set:
+                continue
+            finished_idx_set.add(idx)
+
+            instruct = "Complete this single-choice question."
+
+            choices_str = ""
+            for choice in choices:
+                label = choice["label"]
+                text = choice["text"]
+                choices_str += f"If you think the answer is `{text}` output: `{label}`\n"
+
+            prompt = f"""
+{instruct}
+
+Question: 
+{question}
+
+Choices: 
+{choices_str}
+
+Remember to output ONLY the corresponding letter.
+Your output is:
+            """.strip()
+            # print(prompt)
+
+            contents = [
+                types.Content(
+                    role="user",
+                    parts=[
+                        types.Part.from_text(text=prompt)
+                    ]
+                )
+            ]
+            time_begin = time.time()
+            response: types.GenerateContentResponse = client.models.generate_content(
+                model=args.model_name,
+                contents=contents,
+                config=generate_content_config,
+            )
+            time_cost = time.time() - time_begin
+            try:
+                prediction = response.candidates[0].content.parts[0].text
+            except TypeError:
+                continue
+            correct = 1 if prediction == answer_key else 0
+
+            total += 1
+            total_correct += correct
+            score = total_correct / total
+
+            row_ = {
+                "id": idx,
+                "question": question,
+                "choices": choices,
+                "ground_true": answer_key,
+                "prediction": prediction,
+                "correct": correct,
+                "total": total,
+                "total_correct": total_correct,
+                "score": score,
+                "time_cost": time_cost,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+            print(f"score: {score}")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/api_eval/eval_openai.py

@@ -0,0 +1,162 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import asyncio
+import base64
+from enum import Enum
+import json
+import os
+import queue
+import threading
+import time
+from typing import Optional, Callable, List, Dict, Any
+import websockets
+
+import pyaudio
+import openai
+from openai import AzureOpenAI
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--api_key",
+        default=environment.get(key="OPENAI_API_KEY"),
+        type=str
+    )
+    parser.add_argument(
+        "--model_name",
+        default="gpt-4o",
+        # default="gpt-4o-mini",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data",
+        default=(project_path / "data/arc-easy.jsonl").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--eval_result",
+        default=(project_path / "data/eval_math_result.jsonl").as_posix(),
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    # gpt-4o: 82
+    # gemini: 89
+    client = AzureOpenAI(
+        # api_key=args.api_key,
+        api_key="Dqt75blRABmhgrwhfcupd1rq44YqNuEgku8FcFFDrEljMq6gltf0JQQJ99BCACYeBjFXJ3w3AAABACOG2njW",
+        api_version="2025-01-01-preview",
+        azure_endpoint="https://west-us-chatgpt.openai.azure.com"
+    )
+
+    total = 0
+    total_correct = 0
+
+    # finished
+    finished_idx_set = set()
+    if os.path.exists(args.eval_result):
+        with open(args.eval_result, "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                idx = row["id"]
+                total = row["total"]
+                total_correct = row["total_correct"]
+                finished_idx_set.add(idx)
+    print(f"finished count: {len(finished_idx_set)}")
+
+    with open(args.eval_data, "r", encoding="utf-8") as fin, open(args.eval_result, "a+", encoding="utf-8") as fout:
+        for row in fin:
+            if total > 20:
+                break
+
+            row = json.loads(row)
+            idx = row["id"]
+            question = row["question"]
+            choices = row["choices"]
+            answer_key = row["answerkey"]
+
+            if idx in finished_idx_set:
+                continue
+            finished_idx_set.add(idx)
+
+            instruct = "Complete this single-choice question."
+
+            choices_str = ""
+            for choice in choices:
+                label = choice["label"]
+                text = choice["text"]
+                choices_str += f"If you think the answer is `{text}` output: `{label}`\n"
+
+            prompt = f"""
+{instruct}
+
+Question: 
+{question}
+
+Choices: 
+{choices_str}
+
+Remember to output ONLY the corresponding letter.
+Your output is:
+            """.strip()
+            # print(prompt)
+            try:
+                time_begin = time.time()
+                response = client.chat.completions.create(
+                    model=args.model_name,
+                    messages=[{"role": "user", "content": prompt}],
+                    stream=False,
+                    # max_tokens=1,
+                    temperature=0.0,
+                    # logit_bias={
+                    #     32: 100,
+                    #     33: 100,
+                    #     34: 100,
+                    #     35: 100,
+                    #     36: 100,
+                    # }
+                )
+                time_cost = time.time() - time_begin
+            except openai.BadRequestError as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+
+            prediction = response.choices[0].message.content
+
+            correct = 1 if prediction == answer_key else 0
+
+            total += 1
+            total_correct += correct
+            score = total_correct / total
+
+            row_ = {
+                "id": idx,
+                "question": question,
+                "choices": choices,
+                "ground_true": answer_key,
+                "prediction": prediction,
+                "correct": correct,
+                "total": total,
+                "total_correct": total_correct,
+                "score": score,
+                "time_cost": time_cost,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+            print(f"score: {score}")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/live_api_native_audio.py

@@ -0,0 +1,299 @@
+"""
+https://ai.google.dev/gemini-api/docs/live?hl=zh-cn#python_1
+https://github.com/google-gemini/cookbook/blob/main/quickstarts/Get_started_LiveAPI_NativeAudio.py
+"""
+import asyncio
+import argparse
+import sys
+import traceback
+
+from google import genai
+from google.genai import types
+import pyaudio
+
+from project_settings import environment
+
+
+if sys.version_info < (3, 11, 0):
+    import taskgroup, exceptiongroup
+    asyncio.TaskGroup = taskgroup.TaskGroup
+    asyncio.ExceptionGroup = exceptiongroup.ExceptionGroup
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--gemini_api_key",
+        default=environment.get(key="GEMINI_API_KEY"),
+        type=str
+    )
+    parser.add_argument(
+        "--model_name",
+        default="gemini-2.5-flash-preview-native-audio-dialog",
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+class GeminiNativeAudio(object):
+    def __init__(self,
+                 gemini_api_key: str,
+                 model_name: str = "gemini-2.5-flash-preview-native-audio-dialog",
+                 system_instruction: str = None,
+                 ):
+        self.gemini_api_key = gemini_api_key
+        self.model_name = model_name
+        self.system_instruction = system_instruction
+
+        self.client = genai.Client(api_key=gemini_api_key)
+        self.gemini_config = types.LiveConnectConfig(
+            response_modalities=["AUDIO"],
+            # system_instruction=system_instruction,
+            # speech_config=types.SpeechConfig(
+            #     language_code="cmn-CN",
+            # )
+        )
+
+        self.pya = pyaudio.PyAudio()
+        self.pya_format = pyaudio.paInt16
+        self.pya_channels = 1
+        self.pya_send_sample_rate = 16000
+        self.pya_receive_sample_rate = 24000
+        self.pya_chunk_size = 1024
+
+        self.audio_bot_queue = asyncio.Queue()
+        self.audio_user_queue = asyncio.Queue(maxsize=5)
+
+        self.user_audio_stream = None
+        self.session = None
+
+    async def listen_audio(self):
+        mic_info = self.pya.get_default_input_device_info()
+        self.user_audio_stream = await asyncio.to_thread(
+            self.pya.open,
+            format=self.pya_format,
+            channels=self.pya_channels,
+            rate=self.pya_send_sample_rate,
+            input=True,
+            input_device_index=mic_info["index"],
+            frames_per_buffer=self.pya_chunk_size,
+        )
+        kwargs = {}
+        while True:
+            data = await asyncio.to_thread(self.user_audio_stream.read, self.pya_chunk_size, **kwargs)
+            await self.audio_user_queue.put({"data": data, "mime_type": "audio/pcm"})
+
+    async def send_realtime(self):
+        while True:
+            msg = await self.audio_user_queue.get()
+            await self.session.send_realtime_input(audio=msg)
+
+    async def receive_audio(self):
+        while True:
+            turn = self.session.receive()
+            async for response in turn:
+                if data := response.data:
+                    self.audio_bot_queue.put_nowait(data)
+                    continue
+                if text := response.text:
+                    print(text, end="")
+
+            # If you interrupt the model, it sends a turn_complete.
+            # For interruptions to work, we need to stop playback.
+            # So empty out the audio queue because it may have loaded
+            # much more audio than has played yet.
+            while not self.audio_bot_queue.empty():
+                self.audio_bot_queue.get_nowait()
+
+    async def play_audio(self):
+        stream = await asyncio.to_thread(
+            self.pya.open,
+            format=self.pya_format,
+            channels=self.pya_channels,
+            rate=self.pya_receive_sample_rate,
+            output=True,
+        )
+        while True:
+            bytestream = await self.audio_bot_queue.get()
+            await asyncio.to_thread(stream.write, bytestream)
+
+    async def run(self):
+        try:
+            async with (
+                self.client.aio.live.connect(model=self.model_name, config=self.gemini_config) as session,
+                asyncio.TaskGroup() as tg,
+            ):
+                self.session = session
+
+                await self.session.send_realtime_input(text=self.system_instruction)
+
+                tg.create_task(self.send_realtime())
+                tg.create_task(self.listen_audio())
+                tg.create_task(self.receive_audio())
+                tg.create_task(self.play_audio())
+
+        except asyncio.CancelledError:
+            pass
+        except ExceptionGroup as EG:
+            if self.user_audio_stream:
+                self.user_audio_stream.close()
+            traceback.print_exception(EG)
+
+
+INSTRUCTION = """
+<身份>
+您正在为客户提供中文学习服务。您来自全球最大的中文学习平台LingoAce，并且是一位资深销售。
+<工作>
+您正在通过电话与徐勋健交谈。
+您的工作是询问 徐勋健 他/她的孩子中文学习的近况，以及孩子是否愿意继续学习。
+如果您还不清楚，请继续提问。
+<知识库 FAQ>
+1.
+问： 号码是哪里来的
+答： 请您放心哈，因为您之前留过电话，所以我们才能联系到您，而且特地帮您争取了免费名额，您看要参加一下吗？；
+2.
+问： 询问价格
+答： 这次给您申请的是免费名额，不收费哈，来电就是想邀请孩子免费体验中问水平测试课程的，您让孩子来试试看吧？；
+3.
+问： 公司/上课地点
+答： 我们专业老师在线授课哦，宝贝在电脑、平板都可以学习，在家就可以上课，很方便的。；
+4.
+问： 是否机器人
+答： 哎，家长，我是LingoAce的约课老师呢，今天联系您也是想邀请您免费体验我们的全英文授课的新加坡数学试听课，您看要不要让孩子来体验一下呢？；
+5.
+问： 考虑商量
+答： 家长，我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的数学培优课程，新加坡数学注重扎实基础和应用能力的提升，可以提升孩子思维能力。现在有免费试听的机会，我先帮您约上，您看看是否适合孩子，可以吗；
+6.
+问：客户问AI是否听得到
+答：在听的，您接着说；
+7.
+问：赞美
+答：感谢感谢，谢谢您。那您看这次的活动可以给孩子报个名来体验下吗？；
+8.
+问：听不清楚AI说话
+答：现在您能听清楚吗？；
+9.
+问：课程教材
+答：只需要小朋友有电脑或者平板就可以体验了；
+10.
+问：怎么称呼
+答：家长您叫我静静老师就可以。；
+11.
+问：干什么的
+答：是这样的家长，我是LingoAce的老师，您还有一节免费试听的权益没有领取，是有真人老师一对一直播上课的，您让孩子来体验看看吧？；
+12.
+问：是不是诈骗
+答：家长您多虑了，我们是LingoAce的老师，这次也是根据您之前注册的信息来联系您的，您也可以登录我们app看一下的；
+13.
+问：平台名称
+答：我们是LingoAce，您之前有在我们平台给宝贝了解过数学课程的哈。；
+14.
+问：联系电话
+答：我们这个电话是不支持回拨的，您如果想要了解更多课程内容，稍后我们专属顾问会主动与您取得联系的；
+15.
+问：询问线下
+答：我们是线上授课的方式，线下是没有的，您可以先来体验下，有什么问题可以咨询我们专属顾问哈；
+16.
+问：调戏
+答：非常抱歉呢，跟工作不相关的问题上班时间我们是不允许聊的，咱们还是回归到宝贝课程的学习上来吧。；
+17.
+问：下载软件/APP
+答：稍后课程顾问会联系您，告诉您详细的操作流程的。；
+18.
+问：老师资质
+答：老师资质这块您是可以放心的，我们老师都是毕业于全球知名院校的专业科班老师，也都是经过我们层层筛选才能上任的呢；
+19.
+问：优惠活动
+答：这次帮您申请的是免费名额，您可以先体验一下，关于正式课程的优惠，我们专业的专属顾问稍后会给您全面介绍的；
+20.
+问：课程内容
+答：稍后会有课程顾问联系您，给您详细介绍的。；
+21.
+问：考虑商量
+答： 家长，我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的数学培优课程，新加坡数学注重扎实基础和应用能力的提升，可以提升孩子思维能力。现在有免费试听的机会，我先帮您约上，您看看是否适合孩子，可以吗；
+22.
+问：已经报班
+答：好的家长，您多考虑一下，我们的课程也是最新升级了，可以让孩子参与数学培优课程，提升孩子思维能力。这次给您争取的免费名额，您先让孩子体验一下，您看可以吗？；
+23.
+问：适合多大孩子学习
+答：我们的课程，主要针对的是3-18岁左右的孩子学习数学的哦。；
+24.
+问：一节课时长
+答：我们有25分钟和55分钟的课程，可以根据小朋友的实际情况进行灵活选择的；
+25.
+问：不在某地
+答：我们是真人老师在线一对一授课，更有趣味性，而且孩子在电脑、苹果Ipad都可以学习，您随时都可以预约上课，在家就能学，很方便的。；
+26.
+问：优势及区别
+答：哎，我们的课程是经过教育专家们精心编排过的，非常适合各个年龄段孩子的认知特点。而且是针对北美、澳洲、欧洲小学阶段的数学培优课程，新加坡数学注重扎实基础和应用能力的提升，可以提升孩子思维能力。您可以让孩子来体验看看的；
+27.
+问：有没有其他课程
+答：有的，比如国际数学竞赛类的，袋鼠竞赛，AMC8 等等课程，如果您感兴趣，我们可以让老师回电给您介绍一下；
+28.
+问：家长旁听
+答：旁听可以的，第一次上课我们也希望您可以陪同，可以更好的了解我们的课程，但是不建议您对孩子有太多���点呢~；
+29.
+问：正式报名详情
+答：您先和小朋友一起来体验哈，试听结束后，您觉得小朋友挺喜欢，具体的费用您可以到时候直接咨询我们老师哈；
+30.
+问：试听之后怎么收费
+答：这个后面会有专属顾问联系您，跟您说一下这个问题的；
+31.
+问：判断孩子基础
+答：我们这边有很多零基础的小朋友，而且我们的老师教学经验很丰富，注重扎实基础和应用能力的提升。这个您不用担心的，可以先试试，好吧？；
+32.
+问：活动时间限制
+答：这个是我们给宝贝争取的免费名额，现在登记一下，稍后就会有课程老师来跟您约具体时间的。；
+33.
+问：直播还是录播
+答：我们是真人老师授课哦，直播上课的，有互动有交流。；
+34.
+问：体验过了
+答：哎，是因为咱们课程又更新了，我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的数学培优课程，新加坡数学注重扎实基础和应用能力的提升，可以提升孩子思维能力。我们给您争取了一个免费名额，您让孩子再来试试看吧？；
+35.
+问：线上不考虑
+答：哎，家长，线上很方便的，孩子不用线下到处跑，在家就能学习，而且我们是一对一授课的模式，可以根据孩子基础有针对性地开展教学计划，而且我们课后还会生成专属的学习报告呢；
+36.
+问：上课方式
+答：我们是在线的一对一授课的形式，真人老师互动，现在可以免费体验，在电脑、苹果Ipad都可以学习，您随时都可以预约上课，在家就能学，很方便的。 ；
+37.
+问：固定老师
+答：是的，正式课我们是固定老师授课，可以熟悉孩子情况，熟悉学习进度，对孩子做到更针对的教学呢。；
+38.
+问：课程是几节课
+答：试听课是一节哦，现在邀请孩子免费体验。您看孩子有需要的话，稍后我让专属的顾问老师来帮您预约课程吧；
+39.
+问：老师是兼职的还是全职的
+答：我们的老师都是经过公司内部的培训加选拔制度选出来的，老师资质这块您是可以放心的；
+40.
+问：报了线下班
+答：那您正好可以利用这节体验检测下孩子目前的学习效果，我们可以全方位分析孩子哪一块比较薄弱，有针对性的提供学习建议。而且每家机构教学方法都不太一样，您可以先体验一下嘛。；
+41.
+问：孩子不想学
+答：家长，咱们孩子早晚都要接触数学的，这次安排的课程老师教学经验很丰富，会根据孩子情况调整授课方式的，很多小朋友反映说很有趣，您可以让孩子试试，也让我们老师给您一些建议，好吗？；
+范例：
+客户：“hi”
+客服：“Hello，您好”
+客户：“什么事”
+客服：“诶您好，我是LingoAce在线学中文的，先前一段时间咱们孩子有在我们这里学习，您还记得吧？”
+客户：“你是机器人吗？”
+客服：“哎，家长，我是LingoAce的约课老师呢，今天联系您也是想邀请您免费体验我们的全英文授课的新加坡数学试听课，您看要不要让孩子来体验一下呢？”
+<约束>
+"""
+
+
+async def main():
+    args = get_args()
+
+    gemini = GeminiNativeAudio(
+        gemini_api_key=args.gemini_api_key,
+        model_name=args.model_name,
+        system_instruction=INSTRUCTION,
+    )
+    await gemini.run()
+    return
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/quickstarts/Get_started_LiveAPI_NativeAudio.py

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+https://ai.google.dev/gemini-api/docs/live?hl=zh-cn#python_1
+https://github.com/google-gemini/cookbook/blob/main/quickstarts/Get_started_LiveAPI_NativeAudio.py
+
+## Setup
+
+To install the dependencies for this script, run:
+
+```
+brew install portaudio
+pip install -U google-genai pyaudio
+```
+
+## API key
+
+Ensure the `GOOGLE_API_KEY` environment variable is set to the api-key
+you obtained from Google AI Studio.
+
+## Run
+
+To run the script:
+
+```
+python Get_started_LiveAPI_NativeAudio.py
+```
+
+Start talking to Gemini
+"""
+import asyncio
+import os
+import sys
+import traceback
+
+import pyaudio
+
+from google import genai
+
+from project_settings import environment
+
+
+if sys.version_info < (3, 11, 0):
+    import taskgroup, exceptiongroup
+
+    asyncio.TaskGroup = taskgroup.TaskGroup
+    asyncio.ExceptionGroup = exceptiongroup.ExceptionGroup
+
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+SEND_SAMPLE_RATE = 16000
+RECEIVE_SAMPLE_RATE = 24000
+CHUNK_SIZE = 1024
+
+pya = pyaudio.PyAudio()
+
+GOOGLE_API_KEY = environment.get("GEMINI_API_KEY")
+os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
+client = genai.Client()  # GOOGLE_API_KEY must be set as env variable
+
+MODEL = "gemini-2.5-flash-preview-native-audio-dialog"
+CONFIG = {"response_modalities": ["AUDIO"]}
+
+
+class AudioLoop:
+    def __init__(self):
+        self.audio_in_queue = None
+        self.out_queue = None
+
+        self.session = None
+
+        self.audio_stream = None
+
+        self.receive_audio_task = None
+        self.play_audio_task = None
+
+
+    async def listen_audio(self):
+        mic_info = pya.get_default_input_device_info()
+        self.audio_stream = await asyncio.to_thread(
+            pya.open,
+            format=FORMAT,
+            channels=CHANNELS,
+            rate=SEND_SAMPLE_RATE,
+            input=True,
+            input_device_index=mic_info["index"],
+            frames_per_buffer=CHUNK_SIZE,
+        )
+        if __debug__:
+            kwargs = {"exception_on_overflow": False}
+        else:
+            kwargs = {}
+        while True:
+            data = await asyncio.to_thread(self.audio_stream.read, CHUNK_SIZE, **kwargs)
+            await self.out_queue.put({"data": data, "mime_type": "audio/pcm"})
+
+    async def send_realtime(self):
+        while True:
+            msg = await self.out_queue.get()
+            await self.session.send_realtime_input(audio=msg)
+
+    async def receive_audio(self):
+        "Background task to reads from the websocket and write pcm chunks to the output queue"
+        while True:
+            turn = self.session.receive()
+            async for response in turn:
+                if data := response.data:
+                    self.audio_in_queue.put_nowait(data)
+                    continue
+                if text := response.text:
+                    print(text, end="")
+
+            # If you interrupt the model, it sends a turn_complete.
+            # For interruptions to work, we need to stop playback.
+            # So empty out the audio queue because it may have loaded
+            # much more audio than has played yet.
+            while not self.audio_in_queue.empty():
+                self.audio_in_queue.get_nowait()
+
+    async def play_audio(self):
+        stream = await asyncio.to_thread(
+            pya.open,
+            format=FORMAT,
+            channels=CHANNELS,
+            rate=RECEIVE_SAMPLE_RATE,
+            output=True,
+        )
+        while True:
+            bytestream = await self.audio_in_queue.get()
+            await asyncio.to_thread(stream.write, bytestream)
+
+    async def run(self):
+        try:
+            async with (
+                client.aio.live.connect(model=MODEL, config=CONFIG) as session,
+                asyncio.TaskGroup() as tg,
+            ):
+                self.session = session
+
+                self.audio_in_queue = asyncio.Queue()
+                self.out_queue = asyncio.Queue(maxsize=5)
+
+                tg.create_task(self.send_realtime())
+                tg.create_task(self.listen_audio())
+                tg.create_task(self.receive_audio())
+                tg.create_task(self.play_audio())
+        except asyncio.CancelledError:
+            pass
+        except ExceptionGroup as EG:
+            if self.audio_stream:
+                self.audio_stream.close()
+            traceback.print_exception(EG)
+
+
+if __name__ == "__main__":
+    loop = AudioLoop()
+    asyncio.run(loop.run())

examples/qwen/quick_start/main.py

@@ -0,0 +1,133 @@
+# -- coding: utf-8 --
+"""
+https://help.aliyun.com/zh/model-studio/realtime#1234095db03g3
+"""
+import os, time, base64, asyncio
+from omni_realtime_client import OmniRealtimeClient, TurnDetectionMode
+import pyaudio
+import queue
+import threading
+
+from project_settings import environment
+DASHSCOPE_API_KEY = environment.get("QWEN_API_KEY")
+os.environ["DASHSCOPE_API_KEY"] = DASHSCOPE_API_KEY
+
+# 创建一个全局音频队列和播放线程
+audio_queue = queue.Queue()
+audio_player = None
+
+# 初始化PyAudio
+p = pyaudio.PyAudio()
+RATE = 16000  # 采样率 16kHz
+CHUNK = 3200  # 每个音频块的大小
+FORMAT = pyaudio.paInt16  # 16位PCM格式
+CHANNELS = 1  # 单声道
+
+def audio_player_thread():
+    """后台线程用于播放音频数据"""
+    stream = p.open(format=FORMAT,
+                    channels=CHANNELS,
+                    rate=24000,
+                    output=True,
+                    frames_per_buffer=CHUNK)
+    
+    try:
+        while True:
+            try:
+                # 从队列获取音频数据
+                audio_data = audio_queue.get(block=True, timeout=0.5)
+                if audio_data is None:  # 结束信号
+                    break
+                # 播放音频数据
+                stream.write(audio_data)
+                audio_queue.task_done()
+            except queue.Empty:
+                # 如果队列为空，继续等待
+                continue
+    finally:
+        # 清理
+        stream.stop_stream()
+        stream.close()
+
+def start_audio_player():
+    """启动音频播放线程"""
+    global audio_player
+    if audio_player is None or not audio_player.is_alive():
+        audio_player = threading.Thread(target=audio_player_thread, daemon=True)
+        audio_player.start()
+
+def handle_audio_data(audio_data):
+    """处理接收到的音频数据"""
+    # 打印接收到的音频数据长度（调试用）
+    print(f"\n接收到音频数据: {len(audio_data)} 字节")
+    # 将音频数据放入队列
+    audio_queue.put(audio_data)
+
+async def start_microphone_streaming(client: OmniRealtimeClient):
+    CHUNK = 3200
+    FORMAT = pyaudio.paInt16
+    CHANNELS = 1
+    RATE = 16000
+    
+    p = pyaudio.PyAudio()
+    stream = p.open(format=FORMAT,
+                    channels=CHANNELS,
+                    rate=RATE,
+                    input=True,
+                    frames_per_buffer=CHUNK)
+    
+    try:
+        print("开始录音，请讲话...")
+        while True:
+            audio_data = stream.read(CHUNK)
+            encoded_data = base64.b64encode(audio_data).decode('utf-8')
+            
+            eventd = {
+                "event_id": "event_" + str(int(time.time() * 1000)),
+                "type": "input_audio_buffer.append",
+                "audio": encoded_data
+            }
+            await client.send_event(eventd)
+            
+            # 保持较短的等待时间以模拟实时交互
+            await asyncio.sleep(0.05)
+    finally:
+        stream.stop_stream()
+        stream.close()
+        p.terminate()
+
+async def main():
+    # 启动音频播放线程
+    start_audio_player()
+
+    realtime_client = OmniRealtimeClient(
+        base_url="wss://dashscope.aliyuncs.com/api-ws/v1/realtime",
+        api_key=os.environ.get("DASHSCOPE_API_KEY"),
+        model="qwen-omni-turbo-realtime-2025-05-08",
+        voice="Chelsie",
+        on_text_delta=lambda text: print(f"\nAssistant: {text}", end="", flush=True),
+        on_audio_delta=handle_audio_data,
+        turn_detection_mode=TurnDetectionMode.SERVER_VAD
+    )
+    
+    try:
+        await realtime_client.connect()
+        # 启动消息处理和麦克风录音
+        message_handler = asyncio.create_task(realtime_client.handle_messages())
+        streaming_task = asyncio.create_task(start_microphone_streaming(realtime_client))
+
+        while True:
+            await asyncio.Queue().get()
+    except Exception as e:
+        print(f"Error: {e}")
+    finally:
+        # 结束音频播放线程
+        audio_queue.put(None)
+        if audio_player:
+            audio_player.join(timeout=1)
+        await realtime_client.close()
+        p.terminate()
+
+if __name__ == "__main__":
+    # Install required packages:
+    asyncio.run(main())

examples/qwen/quick_start/omni_realtime_client.py

@@ -0,0 +1,259 @@
+# -- coding: utf-8 --
+
+import asyncio
+import websockets
+import json
+import base64
+import os
+import time
+
+from typing import Optional, Callable, List, Dict, Any
+from enum import Enum
+
+class TurnDetectionMode(Enum):
+    SERVER_VAD = "server_vad"
+    MANUAL = "manual"
+
+class OmniRealtimeClient:
+    """
+    A demo client for interacting with the Omni Realtime API.
+
+    This class provides methods to connect to the Realtime API, send text and audio data,
+    handle responses, and manage the WebSocket connection.
+
+    Attributes:
+        base_url (str):
+            The base URL for the Realtime API.
+        api_key (str):
+            The API key for authentication.
+        model (str):
+            Omni model to use for chat.
+        voice (str):
+            The voice to use for audio output.
+        turn_detection_mode (TurnDetectionMode):
+            The mode for turn detection.
+        on_text_delta (Callable[[str], None]):
+            Callback for text delta events.
+            Takes in a string and returns nothing.
+        on_audio_delta (Callable[[bytes], None]):
+            Callback for audio delta events.
+            Takes in bytes and returns nothing.
+        on_input_transcript (Callable[[str], None]):
+            Callback for input transcript events.
+            Takes in a string and returns nothing.
+        on_interrupt (Callable[[], None]):
+            Callback for user interrupt events, should be used to stop audio playback.
+        on_output_transcript (Callable[[str], None]):
+            Callback for output transcript events.
+            Takes in a string and returns nothing.
+        extra_event_handlers (Dict[str, Callable[[Dict[str, Any]], None]]):
+            Additional event handlers.
+            Is a mapping of event names to functions that process the event payload.
+    """
+    def __init__(
+        self,
+        base_url,
+        api_key: str,
+        model: str = "",
+        voice: str = "Chelsie",
+        turn_detection_mode: TurnDetectionMode = TurnDetectionMode.MANUAL,
+        on_text_delta: Optional[Callable[[str], None]] = None,
+        on_audio_delta: Optional[Callable[[bytes], None]] = None,
+        on_interrupt: Optional[Callable[[], None]] = None,
+        on_input_transcript: Optional[Callable[[str], None]] = None,
+        on_output_transcript: Optional[Callable[[str], None]] = None,
+        extra_event_handlers: Optional[Dict[str, Callable[[Dict[str, Any]], None]]] = None
+    ):
+        self.base_url = base_url
+        self.api_key = api_key
+        self.model = model
+        self.voice = voice
+        self.ws = None
+        self.on_text_delta = on_text_delta
+        self.on_audio_delta = on_audio_delta
+        self.on_interrupt = on_interrupt
+        self.on_input_transcript = on_input_transcript
+        self.on_output_transcript = on_output_transcript
+        self.turn_detection_mode = turn_detection_mode
+        self.extra_event_handlers = extra_event_handlers or {}
+
+        # Track current response state
+        self._current_response_id = None
+        self._current_item_id = None
+        self._is_responding = False
+        # Track printing state for input and output transcripts
+        self._print_input_transcript = False
+        self._output_transcript_buffer = ""
+
+    async def connect(self) -> None:
+        """Establish WebSocket connection with the Realtime API."""
+        url = f"{self.base_url}?model={self.model}"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}"
+        }
+        print(f"url: {url}, headers: {headers}")
+
+        self.ws = await websockets.connect(url, additional_headers=headers)
+
+        # Set up default session configuration
+        if self.turn_detection_mode == TurnDetectionMode.MANUAL:
+            await self.update_session({
+                "modalities": ["text", "audio"],
+                "voice": self.voice,
+                "input_audio_format": "pcm16",
+                "output_audio_format": "pcm16",
+                "input_audio_transcription": {
+                    "model": "gummy-realtime-v1"
+                },
+                "turn_detection" : None
+            })
+        elif self.turn_detection_mode == TurnDetectionMode.SERVER_VAD:
+            await self.update_session({
+                "modalities": ["text", "audio"],
+                "voice": self.voice,
+                "input_audio_format": "pcm16",
+                "output_audio_format": "pcm16",
+                "input_audio_transcription": {
+                    "model": "gummy-realtime-v1"
+                },
+                "turn_detection": {
+                    "type": "server_vad",
+                    "threshold": 0.1,
+                    "prefix_padding_ms": 500,
+                    "silence_duration_ms": 900
+                }
+            })
+        else:
+            raise ValueError(f"Invalid turn detection mode: {self.turn_detection_mode}")
+
+    async def send_event(self, event) -> None:
+        event['event_id'] = "event_" + str(int(time.time() * 1000))
+        print(f" Send event: type={event['type']}, event_id={event['event_id']}")
+        await self.ws.send(json.dumps(event))
+
+    async def update_session(self, config: Dict[str, Any]) -> None:
+        """Update session configuration."""
+        event = {
+            "type": "session.update",
+            "session": config
+        }
+        print("update session: ", event)
+        await self.send_event(event)
+
+    async def stream_audio(self, audio_chunk: bytes) -> None:
+        """Stream raw audio data to the API."""
+        # only support 16bit 16kHz mono pcm
+        audio_b64 = base64.b64encode(audio_chunk).decode()
+
+        append_event = {
+            "type": "input_audio_buffer.append",
+            "audio": audio_b64
+        }
+        await self.send_event(json.dumps(append_event))
+
+    async def create_response(self) -> None:
+        """Request a response from the API. Needed when using manual mode."""
+        event = {
+            "type": "response.create",
+            "response": {
+                "instructions": "你是Tom，一个美国的导购，负责售卖手机、电视",
+                "modalities": ["text", "audio"]
+            }
+        }
+        print("create response: ", event)
+        await self.send_event(event)
+
+    async def cancel_response(self) -> None:
+        """Cancel the current response."""
+        event = {
+            "type": "response.cancel"
+        }
+        await self.send_event(event)
+
+    async def handle_interruption(self):
+        """Handle user interruption of the current response."""
+        if not self._is_responding:
+            return
+
+        print(" Handling interruption")
+
+        # 1. Cancel the current response
+        if self._current_response_id:
+            await self.cancel_response()
+
+        self._is_responding = False
+        self._current_response_id = None
+        self._current_item_id = None
+
+    async def handle_messages(self) -> None:
+        try:
+            async for message in self.ws:
+                event = json.loads(message)
+                event_type = event.get("type")
+                
+                if event_type != "response.audio.delta":
+                    print(" event: ", event)
+                else:
+                    print(" event_type: ", event_type)
+
+                if event_type == "error":
+                    print(" Error: ", event['error'])
+                    continue
+                elif event_type == "response.created":
+                    self._current_response_id = event.get("response", {}).get("id")
+                    self._is_responding = True
+                elif event_type == "response.output_item.added":
+                    self._current_item_id = event.get("item", {}).get("id")
+                elif event_type == "response.done":
+                    self._is_responding = False
+                    self._current_response_id = None
+                    self._current_item_id = None
+                # Handle interruptions
+                elif event_type == "input_audio_buffer.speech_started":
+                    print(" Speech detected")
+                    if self._is_responding:
+                        print(" Handling interruption")
+                        await self.handle_interruption()
+
+                    if self.on_interrupt:
+                        print(" Handling on_interrupt, stop playback")
+                        self.on_interrupt()
+                elif event_type == "input_audio_buffer.speech_stopped":
+                    print(" Speech ended")
+                # Handle normal response events
+                elif event_type == "response.text.delta":
+                    if self.on_text_delta:
+                        self.on_text_delta(event["delta"])
+                elif event_type == "response.audio.delta":
+                    if self.on_audio_delta:
+                        audio_bytes = base64.b64decode(event["delta"])
+                        self.on_audio_delta(audio_bytes)
+                elif event_type == "conversation.item.input_audio_transcription.completed":
+                    transcript = event.get("transcript", "")
+                    if self.on_input_transcript:
+                        await asyncio.to_thread(self.on_input_transcript,transcript)
+                        self._print_input_transcript = True
+                elif event_type == "response.audio_transcript.delta":
+                    if self.on_output_transcript:
+                        delta = event.get("delta", "")
+                        if not self._print_input_transcript:
+                            self._output_transcript_buffer += delta
+                        else:
+                            if self._output_transcript_buffer:
+                                await asyncio.to_thread(self.on_output_transcript,self._output_transcript_buffer)
+                                self._output_transcript_buffer = ""
+                            await asyncio.to_thread(self.on_output_transcript,delta)
+                elif event_type == "response.audio_transcript.done":
+                    self._print_input_transcript = False
+                elif event_type in self.extra_event_handlers:
+                    self.extra_event_handlers[event_type](event)
+
+        except websockets.exceptions.ConnectionClosed:
+            print(" Connection closed")
+        except Exception as e:
+            print(" Error in message handling: ", str(e))
+
+    async def close(self) -> None:
+        """Close the WebSocket connection."""
+        if self.ws:
+            await self.ws.close()

examples/qwen/qwen_omni_realtime.py

@@ -0,0 +1,425 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://help.aliyun.com/zh/model-studio/realtime#1234095db03g3
+"""
+import argparse
+import asyncio
+import base64
+from enum import Enum
+import json
+import os
+import queue
+import threading
+import time
+from typing import Optional, Callable, List, Dict, Any
+import websockets
+
+import pyaudio
+
+from project_settings import environment
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--qwen_api_key",
+        default=environment.get(key="QWEN_API_KEY"),
+        type=str
+    )
+    parser.add_argument(
+        "--model_name",
+        default="qwen-omni-turbo-realtime-2025-05-08",
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+class TurnDetectionMode(Enum):
+    SERVER_VAD = "server_vad"
+    MANUAL = "manual"
+
+
+class OmniRealtimeClient:
+    """
+    A demo client for interacting with the Omni Realtime API.
+
+    This class provides methods to connect to the Realtime API, send text and audio data,
+    handle responses, and manage the WebSocket connection.
+
+    Attributes:
+        base_url (str):
+            The base URL for the Realtime API.
+        api_key (str):
+            The API key for authentication.
+        model (str):
+            Omni model to use for chat.
+        voice (str):
+            The voice to use for audio output.
+        turn_detection_mode (TurnDetectionMode):
+            The mode for turn detection.
+        on_text_delta (Callable[[str], None]):
+            Callback for text delta events.
+            Takes in a string and returns nothing.
+        on_audio_delta (Callable[[bytes], None]):
+            Callback for audio delta events.
+            Takes in bytes and returns nothing.
+        on_input_transcript (Callable[[str], None]):
+            Callback for input transcript events.
+            Takes in a string and returns nothing.
+        on_interrupt (Callable[[], None]):
+            Callback for user interrupt events, should be used to stop audio playback.
+        on_output_transcript (Callable[[str], None]):
+            Callback for output transcript events.
+            Takes in a string and returns nothing.
+        extra_event_handlers (Dict[str, Callable[[Dict[str, Any]], None]]):
+            Additional event handlers.
+            Is a mapping of event names to functions that process the event payload.
+    """
+
+    def __init__(
+            self,
+            base_url,
+            api_key: str,
+            model: str = "",
+            voice: str = "Chelsie",
+            turn_detection_mode: TurnDetectionMode = TurnDetectionMode.MANUAL,
+            on_text_delta: Optional[Callable[[str], None]] = None,
+            on_audio_delta: Optional[Callable[[bytes], None]] = None,
+            on_interrupt: Optional[Callable[[], None]] = None,
+            on_input_transcript: Optional[Callable[[str], None]] = None,
+            on_output_transcript: Optional[Callable[[str], None]] = None,
+            extra_event_handlers: Optional[Dict[str, Callable[[Dict[str, Any]], None]]] = None
+    ):
+        self.base_url = base_url
+        self.api_key = api_key
+        self.model = model
+        self.voice = voice
+        self.ws = None
+        self.on_text_delta = on_text_delta
+        self.on_audio_delta = on_audio_delta
+        self.on_interrupt = on_interrupt
+        self.on_input_transcript = on_input_transcript
+        self.on_output_transcript = on_output_transcript
+        self.turn_detection_mode = turn_detection_mode
+        self.extra_event_handlers = extra_event_handlers or {}
+
+        # Track current response state
+        self._current_response_id = None
+        self._current_item_id = None
+        self._is_responding = False
+        # Track printing state for input and output transcripts
+        self._print_input_transcript = False
+        self._output_transcript_buffer = ""
+
+    async def connect(self) -> None:
+        """Establish WebSocket connection with the Realtime API."""
+        url = f"{self.base_url}?model={self.model}"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}"
+        }
+        print(f"url: {url}, headers: {headers}")
+
+        self.ws = await websockets.connect(url, additional_headers=headers)
+
+        # Set up default session configuration
+        if self.turn_detection_mode == TurnDetectionMode.MANUAL:
+            await self.update_session({
+                "modalities": ["text", "audio"],
+                "voice": self.voice,
+                "input_audio_format": "pcm16",
+                "output_audio_format": "pcm16",
+                "input_audio_transcription": {
+                    "model": "gummy-realtime-v1"
+                },
+                "turn_detection": None
+            })
+        elif self.turn_detection_mode == TurnDetectionMode.SERVER_VAD:
+            await self.update_session({
+                "modalities": ["text", "audio"],
+                "voice": self.voice,
+                "input_audio_format": "pcm16",
+                "output_audio_format": "pcm16",
+                "input_audio_transcription": {
+                    "model": "gummy-realtime-v1"
+                },
+                "turn_detection": {
+                    "type": "server_vad",
+                    "threshold": 0.1,
+                    "prefix_padding_ms": 500,
+                    "silence_duration_ms": 900
+                }
+            })
+        else:
+            raise ValueError(f"Invalid turn detection mode: {self.turn_detection_mode}")
+
+    async def send_event(self, event) -> None:
+        event['event_id'] = "event_" + str(int(time.time() * 1000))
+        print(f" Send event: type={event['type']}, event_id={event['event_id']}")
+        await self.ws.send(json.dumps(event))
+
+    async def update_session(self, config: Dict[str, Any]) -> None:
+        """Update session configuration."""
+        event = {
+            "type": "session.update",
+            "session": config
+        }
+        print("update session: ", event)
+        await self.send_event(event)
+
+    async def stream_audio(self, audio_chunk: bytes) -> None:
+        """Stream raw audio data to the API."""
+        # only support 16bit 16kHz mono pcm
+        audio_b64 = base64.b64encode(audio_chunk).decode()
+
+        append_event = {
+            "type": "input_audio_buffer.append",
+            "audio": audio_b64
+        }
+        await self.send_event(json.dumps(append_event))
+
+    async def create_response(self) -> None:
+        """Request a response from the API. Needed when using manual mode."""
+        event = {
+            "type": "response.create",
+            "response": {
+                "instructions": "你是Tom，一个美国的导购，负责售卖手机、电视",
+                "modalities": ["text", "audio"]
+            }
+        }
+        print("create response: ", event)
+        await self.send_event(event)
+
+    async def cancel_response(self) -> None:
+        """Cancel the current response."""
+        event = {
+            "type": "response.cancel"
+        }
+        await self.send_event(event)
+
+    async def handle_interruption(self):
+        """Handle user interruption of the current response."""
+        if not self._is_responding:
+            return
+
+        print(" Handling interruption")
+
+        # 1. Cancel the current response
+        if self._current_response_id:
+            await self.cancel_response()
+
+        self._is_responding = False
+        self._current_response_id = None
+        self._current_item_id = None
+
+    async def handle_messages(self) -> None:
+        try:
+            async for message in self.ws:
+                event = json.loads(message)
+                event_type = event.get("type")
+
+                if event_type != "response.audio.delta":
+                    print(" event: ", event)
+                else:
+                    print(" event_type: ", event_type)
+
+                if event_type == "error":
+                    print(" Error: ", event['error'])
+                    continue
+                elif event_type == "response.created":
+                    self._current_response_id = event.get("response", {}).get("id")
+                    self._is_responding = True
+                elif event_type == "response.output_item.added":
+                    self._current_item_id = event.get("item", {}).get("id")
+                elif event_type == "response.done":
+                    self._is_responding = False
+                    self._current_response_id = None
+                    self._current_item_id = None
+                # Handle interruptions
+                elif event_type == "input_audio_buffer.speech_started":
+                    print(" Speech detected")
+                    if self._is_responding:
+                        print(" Handling interruption")
+                        await self.handle_interruption()
+
+                    if self.on_interrupt:
+                        print(" Handling on_interrupt, stop playback")
+                        self.on_interrupt()
+                elif event_type == "input_audio_buffer.speech_stopped":
+                    print(" Speech ended")
+                # Handle normal response events
+                elif event_type == "response.text.delta":
+                    if self.on_text_delta:
+                        self.on_text_delta(event["delta"])
+                elif event_type == "response.audio.delta":
+                    if self.on_audio_delta:
+                        audio_bytes = base64.b64decode(event["delta"])
+                        self.on_audio_delta(audio_bytes)
+                elif event_type == "conversation.item.input_audio_transcription.completed":
+                    transcript = event.get("transcript", "")
+                    if self.on_input_transcript:
+                        await asyncio.to_thread(self.on_input_transcript, transcript)
+                        self._print_input_transcript = True
+                elif event_type == "response.audio_transcript.delta":
+                    if self.on_output_transcript:
+                        delta = event.get("delta", "")
+                        if not self._print_input_transcript:
+                            self._output_transcript_buffer += delta
+                        else:
+                            if self._output_transcript_buffer:
+                                await asyncio.to_thread(self.on_output_transcript, self._output_transcript_buffer)
+                                self._output_transcript_buffer = ""
+                            await asyncio.to_thread(self.on_output_transcript, delta)
+                elif event_type == "response.audio_transcript.done":
+                    self._print_input_transcript = False
+                elif event_type in self.extra_event_handlers:
+                    self.extra_event_handlers[event_type](event)
+
+        except websockets.exceptions.ConnectionClosed:
+            print(" Connection closed")
+        except Exception as e:
+            print(" Error in message handling: ", str(e))
+
+    async def close(self) -> None:
+        """Close the WebSocket connection."""
+        if self.ws:
+            await self.ws.close()
+
+
+class OmniRealtime(object):
+    def __init__(self,
+                 qwen_api_key: str,
+                 model_name: str,
+                 sample_rate: int = 16000,
+                 chunk_size: int = 3200,
+                 channels: int = 1,
+                 ):
+        self.qwen_api_key = qwen_api_key
+        self.model_name = model_name
+        self.sample_rate = sample_rate
+        self.chunk_size = chunk_size
+        self.channels = channels
+
+        # 创建一个全局音频队列和播放线程
+        self.audio_queue = queue.Queue()
+        self.audio_player = None
+
+        self.realtime_client = OmniRealtimeClient(
+            base_url="wss://dashscope.aliyuncs.com/api-ws/v1/realtime",
+            api_key=self.qwen_api_key,
+            model=self.model_name,
+            voice="Chelsie",
+            on_text_delta=lambda text: print(f"\nAssistant: {text}", end="", flush=True),
+            on_audio_delta=self.handle_audio_data,
+            # turn_detection_mode=TurnDetectionMode.MANUAL,
+            turn_detection_mode=TurnDetectionMode.SERVER_VAD,
+        )
+
+    def start_audio_player(self):
+        """启动音频播放线程"""
+        if self.audio_player is None or not self.audio_player.is_alive():
+            audio_player = threading.Thread(target=self.audio_player_thread, daemon=True)
+            audio_player.start()
+
+    def audio_player_thread(self):
+        """后台线程用于播放音频数据"""
+        p = pyaudio.PyAudio()
+        stream = p.open(format=pyaudio.paInt16,
+                        channels=self.channels,
+                        rate=24000,
+                        output=True,
+                        frames_per_buffer=self.chunk_size)
+
+        try:
+            while True:
+                try:
+                    # 从队列获取音频数据
+                    audio_data = self.audio_queue.get(block=True, timeout=0.5)
+                    if audio_data is None:  # 结束信号
+                        break
+                    # 播放音频数据
+                    stream.write(audio_data)
+                    self.audio_queue.task_done()
+                except queue.Empty:
+                    # 如果队列为空，继续等待
+                    continue
+        finally:
+            # 清理
+            stream.stop_stream()
+            stream.close()
+
+    def handle_audio_data(self, audio_data: bytes):
+        """处理接收到的音频数据"""
+        # 打印接收到的音频数据长度（调试用）
+        print(f"\n接收到音频数据: {len(audio_data)} 字节")
+        # 将音频数据放入队列
+        self.audio_queue.put(audio_data)
+
+    async def start_microphone_streaming(self):
+        p = pyaudio.PyAudio()
+        stream = p.open(format=pyaudio.paInt16,
+                        channels=self.channels,
+                        rate=self.sample_rate,
+                        input=True,
+                        frames_per_buffer=self.chunk_size)
+
+        try:
+            print("开始录音，请讲话...")
+            while True:
+                audio_data = stream.read(self.chunk_size)
+                encoded_data = base64.b64encode(audio_data).decode("utf-8")
+
+                eventd = {
+                    "event_id": "event_" + str(int(time.time() * 1000)),
+                    "type": "input_audio_buffer.append",
+                    "audio": encoded_data
+                }
+                await self.realtime_client.send_event(eventd)
+
+                # 保持较短的等待时间以模拟实时交互
+                await asyncio.sleep(0.05)
+        finally:
+            stream.stop_stream()
+            stream.close()
+            p.terminate()
+
+    async def run(self):
+        self.start_audio_player()
+
+        await self.realtime_client.connect()
+        # await self.realtime_client.create_response()
+
+        try:
+            # 启动消息处理和麦克风录音
+            message_handler = asyncio.create_task(self.realtime_client.handle_messages())
+            streaming_task = asyncio.create_task(self.start_microphone_streaming())
+
+            while True:
+                await asyncio.Queue().get()
+        except Exception as e:
+            print(f"Error: {e}")
+        finally:
+            # 结束音频播放线程
+            self.audio_queue.put(None)
+            if self.audio_player:
+                self.audio_player.join(timeout=1)
+            await self.realtime_client.close()
+
+        return
+
+
+async def main():
+    args = get_args()
+
+    omni_realtime = OmniRealtime(
+        qwen_api_key=args.qwen_api_key,
+        model_name=args.model_name,
+    )
+
+    await omni_realtime.run()
+    return
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/tutorial/text_generation.py

@@ -0,0 +1,49 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://ai.google.dev/gemini-api/docs/text-generation?hl=zh-cn
+"""
+import argparse
+
+from google import genai
+from google.genai import types
+
+from project_settings import environment
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--gemini_api_key",
+        default=environment.get(key="GEMINI_API_KEY"),
+        type=str
+    )
+    parser.add_argument(
+        "--model",
+        default="gemini-2.0-flash",
+        # default="gemini-2.5-pro-preview-05-06",
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    client = genai.Client(api_key=args.gemini_api_key)
+
+    response = client.models.generate_content(
+        model=args.model,
+        config=types.GenerateContentConfig(
+            system_instruction="You are a cat. Your name is Neko."),
+        contents="Hello there"
+    )
+
+    print(response.text)
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/vertexai_start/gemini-2.0-test.py

@@ -0,0 +1,48 @@
+import os
+
+from google import genai
+from google.genai import types
+import base64
+
+def generate():
+  client = genai.Client(
+      vertexai=True,
+      project="potent-veld-462405-t3",
+      location="global",
+  )
+
+  model = "gemini-2.0-flash-001"
+  contents = [
+    types.Content(
+      role="user",
+      parts=[
+        types.Part.from_text(text="""今天深圳的天气怎么样？""")
+      ]
+    )
+  ]
+
+  tools = [
+    types.Tool(google_search=types.GoogleSearch()),
+  ]
+
+  generate_content_config = types.GenerateContentConfig(
+    temperature = 1,
+    top_p = 0.95,
+    max_output_tokens = 8192,
+    response_modalities = ["TEXT"],
+    tools=tools,
+  )
+
+  for chunk in client.models.generate_content_stream(
+    model = model,
+    contents = contents,
+    config = generate_content_config,
+    ):
+    print(chunk.text, end="")
+
+
+# os.environ["http_proxy"] = "http://127.0.0.1:7890"
+# os.environ["https_proxy"] = "http://127.0.0.1:7890"
+# os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "/Users/huangjiajun/Project/baidao-test-666808-4b2251497ed0.json"
+os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = r"E:\Users\tianx\intelli-zen\OpenGeminiAPI\dotenv\potent-veld-462405-t3-8091a29b2894.json"
+generate()

examples/vertexai_start/gemini-2.5-test.py

@@ -0,0 +1,44 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import os
+
+from google import genai
+from google.genai import types
+
+os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = r"E:\Users\tianx\intelli-zen\OpenGeminiAPI\dotenv\potent-veld-462405-t3-8091a29b2894.json"
+
+
+client = genai.Client(
+    vertexai=True,
+    project="potent-veld-462405-t3",
+    location="global",
+)
+
+# model = "gemini-2.0-flash-001"
+model = "gemini-2.5-flash"
+contents = [
+    types.Content(
+        role="user",
+        parts=[
+            types.Part.from_text(text="""今天深圳的天气怎么样？""")
+        ]
+    )
+]
+
+generate_content_config = types.GenerateContentConfig(
+    temperature=1,
+    top_p=0.95,
+    max_output_tokens=8192,
+    response_modalities=["TEXT"],
+)
+response: types.GenerateContentResponse = client.models.generate_content(
+    model=model,
+    contents=contents,
+    config=generate_content_config,
+)
+text = response.candidates[0].content.parts[0].text
+print(text)
+
+
+if __name__ == "__main__":
+    pass

install.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+
+# bash install.sh --stage 1 --stop_stage 1 --system_version windows
+
+
+system_version="centos";
+verbose=true;
+stage=-1
+stop_stage=0
+
+
+# parse options
+while true; do
+  [ -z "${1:-}" ] && break;  # break if there are no arguments
+  case "$1" in
+    --*) name=$(echo "$1" | sed s/^--// | sed s/-/_/g);
+      eval '[ -z "${'"$name"'+xxx}" ]' && echo "$0: invalid option $1" 1>&2 && exit 1;
+      old_value="(eval echo \\$$name)";
+      if [ "${old_value}" == "true" ] || [ "${old_value}" == "false" ]; then
+        was_bool=true;
+      else
+        was_bool=false;
+      fi
+
+      # Set the variable to the right value-- the escaped quotes make it work if
+      # the option had spaces, like --cmd "queue.pl -sync y"
+      eval "${name}=\"$2\"";
+
+      # Check that Boolean-valued arguments are really Boolean.
+      if $was_bool && [[ "$2" != "true" && "$2" != "false" ]]; then
+        echo "$0: expected \"true\" or \"false\": $1 $2" 1>&2
+        exit 1;
+      fi
+      shift 2;
+      ;;
+
+    *) break;
+  esac
+done
+
+work_dir="$(pwd)"
+data_dir="${work_dir}/data/impulse_responses"
+
+mkdir -p "${data_dir}"
+
+if [ ${stage} -le 1 ] && [ ${stop_stage} -ge 1 ]; then
+  $verbose && echo "stage 1: download simulated room impulse responses"
+  cd "${data_dir}" || exit 1;
+
+  # https://www.openslr.org/26/
+  # wget https://www.openslr.org/resources/26/sim_rir_8k.zip
+  # unzip sim_rir_8k.zip
+
+  wget https://www.openslr.org/resources/26/sim_rir_16k.zip
+  unzip sim_rir_16k.zip
+
+  # https://www.openslr.org/28/
+  # wget https://www.openslr.org/resources/28/rirs_noises.zip
+  # unzip rirs_noises.zip
+
+fi
+

log.py

@@ -0,0 +1,229 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import logging
+from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
+import os
+
+
+def setup_size_rotating(log_directory: str):
+    fmt = "%(asctime)s - %(name)s - %(levelname)s  %(filename)s:%(lineno)d >  %(message)s"
+
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(logging.INFO)
+    stream_handler.setFormatter(logging.Formatter(fmt))
+
+    # main
+    main_logger = logging.getLogger("main")
+    main_logger.addHandler(stream_handler)
+    main_info_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "main.log"),
+        maxBytes=100*1024*1024,  # 100MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    main_info_file_handler.setLevel(logging.INFO)
+    main_info_file_handler.setFormatter(logging.Formatter(fmt))
+    main_logger.addHandler(main_info_file_handler)
+
+    # http
+    http_logger = logging.getLogger("http")
+    http_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "http.log"),
+        maxBytes=100*1024*1024,  # 100MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    http_file_handler.setLevel(logging.DEBUG)
+    http_file_handler.setFormatter(logging.Formatter(fmt))
+    http_logger.addHandler(http_file_handler)
+
+    # api
+    api_logger = logging.getLogger("api")
+    api_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "api.log"),
+        maxBytes=10*1024*1024,  # 10MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    api_file_handler.setLevel(logging.DEBUG)
+    api_file_handler.setFormatter(logging.Formatter(fmt))
+    api_logger.addHandler(api_file_handler)
+
+    # toolbox
+    toolbox_logger = logging.getLogger("toolbox")
+    toolbox_logger.addHandler(stream_handler)
+    toolbox_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "toolbox.log"),
+        maxBytes=10*1024*1024,  # 10MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    toolbox_file_handler.setLevel(logging.DEBUG)
+    toolbox_file_handler.setFormatter(logging.Formatter(fmt))
+    toolbox_logger.addHandler(toolbox_file_handler)
+
+    # alarm
+    alarm_logger = logging.getLogger("alarm")
+    alarm_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "alarm.log"),
+        maxBytes=1*1024*1024,  # 1MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    alarm_file_handler.setLevel(logging.DEBUG)
+    alarm_file_handler.setFormatter(logging.Formatter(fmt))
+    alarm_logger.addHandler(alarm_file_handler)
+
+    debug_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "debug.log"),
+        maxBytes=1*1024*1024,  # 1MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    debug_file_handler.setLevel(logging.DEBUG)
+    debug_file_handler.setFormatter(logging.Formatter(fmt))
+
+    info_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "info.log"),
+        maxBytes=1*1024*1024,  # 1MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    info_file_handler.setLevel(logging.INFO)
+    info_file_handler.setFormatter(logging.Formatter(fmt))
+
+    error_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "error.log"),
+        maxBytes=1*1024*1024,  # 1MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    error_file_handler.setLevel(logging.ERROR)
+    error_file_handler.setFormatter(logging.Formatter(fmt))
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        datefmt="%a, %d %b %Y %H:%M:%S",
+        handlers=[
+            debug_file_handler,
+            info_file_handler,
+            error_file_handler,
+        ]
+    )
+
+
+def setup_time_rotating(log_directory: str):
+    fmt = "%(asctime)s - %(name)s - %(levelname)s  %(filename)s:%(lineno)d >  %(message)s"
+
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(logging.INFO)
+    stream_handler.setFormatter(logging.Formatter(fmt))
+
+    # main
+    main_logger = logging.getLogger("main")
+    main_logger.addHandler(stream_handler)
+    main_info_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "main.log"),
+        encoding="utf-8",
+        when="midnight",
+        interval=1,
+        backupCount=7
+    )
+    main_info_file_handler.setLevel(logging.INFO)
+    main_info_file_handler.setFormatter(logging.Formatter(fmt))
+    main_logger.addHandler(main_info_file_handler)
+
+    # http
+    http_logger = logging.getLogger("http")
+    http_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "http.log"),
+        encoding='utf-8',
+        when="midnight",
+        interval=1,
+        backupCount=7
+    )
+    http_file_handler.setLevel(logging.DEBUG)
+    http_file_handler.setFormatter(logging.Formatter(fmt))
+    http_logger.addHandler(http_file_handler)
+
+    # api
+    api_logger = logging.getLogger("api")
+    api_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "api.log"),
+        encoding='utf-8',
+        when="midnight",
+        interval=1,
+        backupCount=7
+    )
+    api_file_handler.setLevel(logging.DEBUG)
+    api_file_handler.setFormatter(logging.Formatter(fmt))
+    api_logger.addHandler(api_file_handler)
+
+    # toolbox
+    toolbox_logger = logging.getLogger("toolbox")
+    toolbox_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "toolbox.log"),
+        maxBytes=10*1024*1024,  # 10MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    toolbox_file_handler.setLevel(logging.DEBUG)
+    toolbox_file_handler.setFormatter(logging.Formatter(fmt))
+    toolbox_logger.addHandler(toolbox_file_handler)
+
+    # alarm
+    alarm_logger = logging.getLogger("alarm")
+    alarm_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "alarm.log"),
+        encoding="utf-8",
+        when="midnight",
+        interval=1,
+        backupCount=7
+    )
+    alarm_file_handler.setLevel(logging.DEBUG)
+    alarm_file_handler.setFormatter(logging.Formatter(fmt))
+    alarm_logger.addHandler(alarm_file_handler)
+
+    debug_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "debug.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    debug_file_handler.setLevel(logging.DEBUG)
+    debug_file_handler.setFormatter(logging.Formatter(fmt))
+
+    info_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "info.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    info_file_handler.setLevel(logging.INFO)
+    info_file_handler.setFormatter(logging.Formatter(fmt))
+
+    error_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "error.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    error_file_handler.setLevel(logging.ERROR)
+    error_file_handler.setFormatter(logging.Formatter(fmt))
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        datefmt="%a, %d %b %Y %H:%M:%S",
+        handlers=[
+            debug_file_handler,
+            info_file_handler,
+            error_file_handler,
+        ]
+    )
+
+
+if __name__ == "__main__":
+    pass

main.py

@@ -0,0 +1,70 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import asyncio
+import json
+import logging
+from pathlib import Path
+import platform
+import tempfile
+from typing import Tuple, List
+import uuid
+
+import gradio as gr
+import numpy as np
+from scipy.io import wavfile
+
+from project_settings import environment, project_path, log_directory
+from toolbox.os.command import Command
+import log
+
+log.setup_size_rotating(log_directory=log_directory)
+
+logger = logging.getLogger("main")
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--examples_dir",
+        default=(project_path / "data/examples").as_posix(),
+        type=str,
+    )
+    args = parser.parse_args()
+    return args
+
+
+def shell(cmd: str):
+    return Command.popen(cmd)
+
+
+def main():
+    args = get_args()
+
+    # ui
+    with gr.Blocks() as blocks:
+        with gr.Tabs():
+            with gr.TabItem("shell"):
+                shell_text = gr.Textbox(label="cmd")
+                shell_button = gr.Button("run")
+                shell_output = gr.Textbox(label="output")
+
+                shell_button.click(
+                    shell,
+                    inputs=[shell_text,],
+                    outputs=[shell_output],
+                )
+
+    # http://127.0.0.1:7861/
+    # http://10.75.27.247:7861/
+    blocks.queue().launch(
+        share=False if platform.system() == "Windows" else False,
+        server_name="127.0.0.1" if platform.system() == "Windows" else "0.0.0.0",
+        # server_name="0.0.0.0",
+        server_port=environment.get("port", 7860, dtype=int),
+    )
+    return
+
+
+if __name__ == "__main__":
+    main()

project_settings.py

@@ -0,0 +1,21 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import os
+from pathlib import Path
+
+from toolbox.os.environment import EnvironmentManager
+
+project_path = os.path.abspath(os.path.dirname(__file__))
+project_path = Path(project_path)
+
+log_directory = project_path / "logs"
+log_directory.mkdir(parents=True, exist_ok=True)
+
+environment = EnvironmentManager(
+    path=os.path.join(project_path, "dotenv"),
+    env=os.environ.get("environment", "dev"),
+)
+
+
+if __name__ == '__main__':
+    pass

requirements.txt

@@ -0,0 +1,11 @@
+gradio
+librosa
+soundfile
+scipy
+python-dotenv
+pandas
+openpyxl
+google-genai
+pyaudio==0.2.14
+google-generativeai
+openai

toolbox/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == "__main__":
+    pass

toolbox/json/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/json/misc.py

@@ -0,0 +1,63 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from typing import Callable
+
+
+def traverse(js, callback: Callable, *args, **kwargs):
+    if isinstance(js, list):
+        result = list()
+        for l in js:
+            l = traverse(l, callback, *args, **kwargs)
+            result.append(l)
+        return result
+    elif isinstance(js, tuple):
+        result = list()
+        for l in js:
+            l = traverse(l, callback, *args, **kwargs)
+            result.append(l)
+        return tuple(result)
+    elif isinstance(js, dict):
+        result = dict()
+        for k, v in js.items():
+            k = traverse(k, callback, *args, **kwargs)
+            v = traverse(v, callback, *args, **kwargs)
+            result[k] = v
+        return result
+    elif isinstance(js, int):
+        return callback(js, *args, **kwargs)
+    elif isinstance(js, str):
+        return callback(js, *args, **kwargs)
+    else:
+        return js
+
+
+def demo1():
+    d = {
+        "env": "ppe",
+        "mysql_connect": {
+            "host": "$mysql_connect_host",
+            "port": 3306,
+            "user": "callbot",
+            "password": "NxcloudAI2021!",
+            "database": "callbot_ppe",
+            "charset": "utf8"
+        },
+        "es_connect": {
+            "hosts": ["10.20.251.8"],
+            "http_auth": ["elastic", "ElasticAI2021!"],
+            "port": 9200
+        }
+    }
+
+    def callback(s):
+        if isinstance(s, str) and s.startswith('$'):
+            return s[1:]
+        return s
+
+    result = traverse(d, callback=callback)
+    print(result)
+    return
+
+
+if __name__ == '__main__':
+    demo1()

toolbox/os/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/os/command.py

@@ -0,0 +1,59 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import os
+
+
+class Command(object):
+    custom_command = [
+        "cd"
+    ]
+
+    @staticmethod
+    def _get_cmd(command):
+        command = str(command).strip()
+        if command == "":
+            return None
+        cmd_and_args = command.split(sep=" ")
+        cmd = cmd_and_args[0]
+        args = " ".join(cmd_and_args[1:])
+        return cmd, args
+
+    @classmethod
+    def popen(cls, command):
+        cmd, args = cls._get_cmd(command)
+        if cmd in cls.custom_command:
+            method = getattr(cls, cmd)
+            return method(args)
+        else:
+            resp = os.popen(command)
+            result = resp.read()
+            resp.close()
+            return result
+
+    @classmethod
+    def cd(cls, args):
+        if args.startswith("/"):
+            os.chdir(args)
+        else:
+            pwd = os.getcwd()
+            path = os.path.join(pwd, args)
+            os.chdir(path)
+
+    @classmethod
+    def system(cls, command):
+        return os.system(command)
+
+    def __init__(self):
+        pass
+
+
+def ps_ef_grep(keyword: str):
+    cmd = "ps -ef | grep {}".format(keyword)
+    rows = Command.popen(cmd)
+    rows = str(rows).split("\n")
+    rows = [row for row in rows if row.__contains__(keyword) and not row.__contains__("grep")]
+    return rows
+
+
+if __name__ == "__main__":
+    pass

toolbox/os/environment.py

@@ -0,0 +1,114 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import json
+import os
+
+from dotenv import load_dotenv
+from dotenv.main import DotEnv
+
+from toolbox.json.misc import traverse
+
+
+class EnvironmentManager(object):
+    def __init__(self, path, env, override=False):
+        filename = os.path.join(path, '{}.env'.format(env))
+        self.filename = filename
+
+        load_dotenv(
+            dotenv_path=filename,
+            override=override
+        )
+
+        self._environ = dict()
+
+    def open_dotenv(self, filename: str = None):
+        filename = filename or self.filename
+        dotenv = DotEnv(
+            dotenv_path=filename,
+            stream=None,
+            verbose=False,
+            interpolate=False,
+            override=False,
+            encoding="utf-8",
+        )
+        result = dotenv.dict()
+        return result
+
+    def get(self, key, default=None, dtype=str):
+        result = os.environ.get(key)
+        if result is None:
+            if default is None:
+                result = None
+            else:
+                result = default
+        else:
+            result = dtype(result)
+        self._environ[key] = result
+        return result
+
+
+_DEFAULT_DTYPE_MAP = {
+    'int': int,
+    'float': float,
+    'str': str,
+    'json.loads': json.loads
+}
+
+
+class JsonConfig(object):
+    """
+    将 json 中, 形如 `$float:threshold` 的值, 处理为:
+    从环境变量中查到 threshold, 再将其转换为 float 类型.
+    """
+    def __init__(self, dtype_map: dict = None, environment: EnvironmentManager = None):
+        self.dtype_map = dtype_map or _DEFAULT_DTYPE_MAP
+        self.environment = environment or os.environ
+
+    def sanitize_by_filename(self, filename: str):
+        with open(filename, 'r', encoding='utf-8') as f:
+            js = json.load(f)
+
+        return self.sanitize_by_json(js)
+
+    def sanitize_by_json(self, js):
+        js = traverse(
+            js,
+            callback=self.sanitize,
+            environment=self.environment
+        )
+        return js
+
+    def sanitize(self, string, environment):
+        """支持 $ 符开始的, 环境变量配置"""
+        if isinstance(string, str) and string.startswith('$'):
+            dtype, key = string[1:].split(':')
+            dtype = self.dtype_map[dtype]
+
+            value = environment.get(key)
+            if value is None:
+                raise AssertionError('environment not exist. key: {}'.format(key))
+
+            value = dtype(value)
+            result = value
+        else:
+            result = string
+        return result
+
+
+def demo1():
+    import json
+
+    from project_settings import project_path
+
+    environment = EnvironmentManager(
+        path=os.path.join(project_path, 'server/callbot_server/dotenv'),
+        env='dev',
+    )
+    init_scenes = environment.get(key='init_scenes', dtype=json.loads)
+    print(init_scenes)
+    print(environment._environ)
+    return
+
+
+if __name__ == '__main__':
+    demo1()

toolbox/os/other.py

@@ -0,0 +1,9 @@
+import os
+import inspect
+
+
+def pwd():
+    """你在哪个文件调用此函数, 它就会返回那个文件所在的 dir 目标"""
+    frame = inspect.stack()[1]
+    module = inspect.getmodule(frame[0])
+    return os.path.dirname(os.path.abspath(module.__file__))