xiaozhi-sdk 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

xiaozhi_sdk/__init__.py

@@ -1,13 +1,14 @@
 import asyncio
 import json
 import os
+import re
 import uuid
 from collections import deque
-from typing import Any, Callable, Dict
+from typing import Any, Callable, Dict, Optional
 
 import websockets
 
-from xiaozhi_sdk.config import INPUT_SERVER_AUDIO_SAMPLE_RATE, WSS_URL
+from xiaozhi_sdk.config import INPUT_SERVER_AUDIO_SAMPLE_RATE
 from xiaozhi_sdk.iot import OtaDevice
 from xiaozhi_sdk.mcp import McpTool
 from xiaozhi_sdk.utils import get_wav_info, read_audio_file, setup_opus
@@ -19,26 +20,40 @@ from xiaozhi_sdk.opus import AudioOpus
 class XiaoZhiWebsocket(McpTool):
 
     def __init__(
-        self, message_handler_callback=None, url=None, ota_url=None, audio_sample_rate=16000, audio_channels=1
+        self,
+        message_handler_callback: Optional[Callable] = None,
+        url: Optional[str] = None,
+        ota_url: Optional[str] = None,
+        audio_sample_rate: int = 16000,
+        audio_channels: int = 1,
     ):
         super().__init__()
-        self.url = url or WSS_URL
+        self.url = url
         self.ota_url = ota_url
-        self.audio_sample_rate = audio_sample_rate
         self.audio_channels = audio_channels
         self.audio_opus = AudioOpus(audio_sample_rate, audio_channels)
+
+        # 客户端标识
         self.client_id = str(uuid.uuid4())
-        self.mac_addr = None
+        self.mac_addr: Optional[str] = None
+
+        # 回调函数
         self.message_handler_callback = message_handler_callback
 
+        # 连接状态
         self.hello_received = asyncio.Event()
         self.session_id = ""
-        self.audio_queue = deque()
         self.websocket = None
-        self.message_handler_task = None
-        self.ota = None
+        self.message_handler_task: Optional[asyncio.Task] = None
+
+        # 输出音频
+        self.output_audio_queue: deque[bytes] = deque()
 
-    async def send_hello(self, aec: bool):
+        # OTA设备
+        self.ota: Optional[OtaDevice] = None
+
+    async def _send_hello(self, aec: bool) -> None:
+        """发送hello消息"""
         hello_message = {
             "type": "hello",
             "version": 1,
@@ -54,61 +69,109 @@ class XiaoZhiWebsocket(McpTool):
         await self.websocket.send(json.dumps(hello_message))
         await asyncio.wait_for(self.hello_received.wait(), timeout=10.0)
 
-    async def start_listen(self):
+    async def _start_listen(self) -> None:
+        """开始监听"""
+
         listen_message = {"session_id": self.session_id, "type": "listen", "state": "start", "mode": "realtime"}
         await self.websocket.send(json.dumps(listen_message))
 
-    async def set_mcp_tool_callback(self, tool_func: Dict[str, Callable[..., Any]]):
-        self.tool_func = tool_func
-
-    async def activate_iot_device(self, ota_info):
-        if ota_info.get("activation"):
-            await self.send_demo_audio()
-            challenge = ota_info["activation"]["challenge"]
-            await asyncio.sleep(3)
-            for _ in range(10):
-                if await self.ota.check_activate(challenge):
-                    break
-                await asyncio.sleep(3)
+    async def _activate_iot_device(self, ota_info: Dict[str, Any]) -> None:
+        """激活IoT设备"""
+        if not ota_info.get("activation"):
+            return
 
-    async def init_connection(self, mac_addr: str, aec: bool = False):
-        self.mac_addr = mac_addr
-        self.ota = OtaDevice(self.mac_addr, self.client_id, self.ota_url)
-        ota_info = await self.ota.activate_device()
+        if not self.ota:
+            return
 
-        headers = {
-            "Authorization": "Bearer test-token",
-            "Protocol-Version": "1",
-            "Device-Id": mac_addr,
-            "Client-Id": self.client_id,
-        }
+        await self._send_demo_audio()
+        challenge = ota_info["activation"]["challenge"]
+        await asyncio.sleep(3)
 
-        self.websocket = await websockets.connect(uri=self.url, additional_headers=headers)
-        self.message_handler_task = asyncio.create_task(self.message_handler())
-        await self.send_hello(aec)
-        await self.start_listen()
-        asyncio.create_task(self.activate_iot_device(ota_info))
+        for _ in range(10):
+            if await self.ota.check_activate(challenge):
+                break
+            await asyncio.sleep(3)
 
-    async def send_demo_audio(self):
+    async def _send_demo_audio(self) -> None:
+        """发送演示音频"""
         current_dir = os.path.dirname(os.path.abspath(__file__))
-        wav_path = os.path.join(current_dir, "../file/greet.wav")
-        framerate, nchannels = get_wav_info(wav_path)
-        audio_opus = AudioOpus(framerate, nchannels)
+        wav_path = os.path.join(current_dir, "../file/audio/greet.wav")
+        framerate, channels = get_wav_info(wav_path)
+        audio_opus = AudioOpus(framerate, channels)
 
         for pcm_data in read_audio_file(wav_path):
             opus_data = await audio_opus.pcm_to_opus(pcm_data)
             await self.websocket.send(opus_data)
         await self.send_silence_audio()
 
-    async def send_silence_audio(self, duration_seconds: float = 1.2):
-        # 发送 静音数据
+    async def send_silence_audio(self, duration_seconds: float = 1.2) -> None:
+        """发送静音音频"""
         frames_count = int(duration_seconds * 1000 / 60)
         pcm_frame = b"\x00\x00" * int(INPUT_SERVER_AUDIO_SAMPLE_RATE / 1000 * 60)
 
         for _ in range(frames_count):
             await self.send_audio(pcm_frame)
 
-    async def send_audio(self, pcm: bytes):
+    async def _handle_websocket_message(self, message: Any) -> None:
+        """处理接受到的WebSocket消息"""
+        if isinstance(message, bytes):
+            pcm_array = await self.audio_opus.opus_to_pcm(message)
+            self.output_audio_queue.extend(pcm_array)
+        else:
+            data = json.loads(message)
+            message_type = data["type"]
+
+            if message_type == "hello":
+                self.hello_received.set()
+                self.session_id = data["session_id"]
+            elif message_type == "mcp":
+                await self.mcp(data)
+            elif self.message_handler_callback:
+                await self.message_handler_callback(data)
+
+    async def _message_handler(self) -> None:
+        """消息处理器"""
+        try:
+            async for message in self.websocket:
+                await self._handle_websocket_message(message)
+        except websockets.ConnectionClosed:
+            if self.message_handler_callback:
+                await self.message_handler_callback(
+                    {"type": "websocket", "state": "close", "source": "sdk.message_handler"}
+                )
+
+    async def set_mcp_tool_callback(self, tool_func: Dict[str, Callable[..., Any]]) -> None:
+        """设置MCP工具回调函数"""
+        self.tool_func = tool_func
+
+    async def init_connection(self, mac_addr: str, aec: bool = False) -> None:
+        """初始化连接"""
+        # 校验MAC地址格式 XX:XX:XX:XX:XX:XX
+        mac_pattern = r"^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$"
+        if not re.match(mac_pattern, mac_addr):
+            raise ValueError(f"无效的MAC地址格式: {mac_addr}。正确格式应为 XX:XX:XX:XX:XX:XX")
+
+        self.mac_addr = mac_addr.lower()
+        self.ota = OtaDevice(self.mac_addr, self.client_id, self.ota_url)
+        ota_info = await self.ota.activate_device()
+
+        headers = {
+            "Authorization": "Bearer {}".format(ota_info["websocket"]["token"]),
+            "Protocol-Version": "1",
+            "Device-Id": self.mac_addr,
+            "Client-Id": self.client_id,
+        }
+        self.url = self.url or ota_info["websocket"]["url"]
+        self.websocket = await websockets.connect(uri=self.url, additional_headers=headers)
+        self.message_handler_task = asyncio.create_task(self._message_handler())
+
+        await self._send_hello(aec)
+        await self._start_listen()
+        asyncio.create_task(self._activate_iot_device(ota_info))
+        await asyncio.sleep(0.5)
+
+    async def send_audio(self, pcm: bytes) -> None:
+        """发送音频数据"""
         if not self.websocket:
             return
 
@@ -119,34 +182,13 @@ class XiaoZhiWebsocket(McpTool):
         elif state in [websockets.protocol.State.CLOSED, websockets.protocol.State.CLOSING]:
             if self.message_handler_callback:
                 await self.message_handler_callback({"type": "websocket", "state": "close", "source": "sdk.send_audio"})
+                self.websocket = None
             await asyncio.sleep(0.5)
         else:
             await asyncio.sleep(0.1)
 
-    async def message_handler(self):
-        try:
-            async for message in self.websocket:
-                if isinstance(message, bytes):
-                    pcm_array = await self.audio_opus.opus_to_pcm(message)
-                    self.audio_queue.extend(pcm_array)
-                else:
-                    data = json.loads(message)
-                    message_type = data["type"]
-
-                    if message_type == "hello":
-                        self.hello_received.set()
-                        self.session_id = data["session_id"]
-                    elif message_type == "mcp":
-                        await self.mcp(data)
-                    elif self.message_handler_callback:
-                        await self.message_handler_callback(data)
-        except websockets.ConnectionClosed:
-            if self.message_handler_callback:
-                await self.message_handler_callback(
-                    {"type": "websocket", "state": "close", "source": "sdk.message_handler"}
-                )
-
-    async def close(self):
+    async def close(self) -> None:
+        """关闭连接"""
         if self.message_handler_task and not self.message_handler_task.done():
             self.message_handler_task.cancel()
             try:

xiaozhi_sdk/__main__.py

@@ -1,8 +1,9 @@
 import argparse
 import asyncio
-import re
+import logging
 import time
 from collections import deque
+from typing import Optional
 
 import numpy as np
 import sounddevice as sd
@@ -10,84 +11,90 @@ import sounddevice as sd
 from xiaozhi_sdk import XiaoZhiWebsocket
 from xiaozhi_sdk.config import INPUT_SERVER_AUDIO_SAMPLE_RATE
 
-input_audio: deque[bytes] = deque()
+# 配置logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+)
+logger = logging.getLogger("xiaozhi_sdk")
 
-is_play_audio = False
+# 全局状态
+input_audio_buffer: deque[bytes] = deque()
+is_playing_audio = False
 
 
-async def message_handler_callback(message):
-    print("message received:", message)
+async def handle_message(message):
+    """处理接收到的消息"""
+    logger.info("message received: %s", message)
 
 
-async def assistant_audio_play(audio_queue):
-    global is_play_audio
-    # 创建一个持续播放的流
+async def play_assistant_audio(audio_queue: deque[bytes]):
+    """播放音频流"""
+    global is_playing_audio
+
     stream = sd.OutputStream(samplerate=INPUT_SERVER_AUDIO_SAMPLE_RATE, channels=1, dtype=np.int16)
     stream.start()
-    last_time = None
+    last_audio_time = None
 
     while True:
-
         if not audio_queue:
             await asyncio.sleep(0.01)
-            if last_time and time.time() - last_time > 1:
-                is_play_audio = False
+            if last_audio_time and time.time() - last_audio_time > 1:
+                is_playing_audio = False
             continue
 
-        is_play_audio = True
+        is_playing_audio = True
         pcm_data = audio_queue.popleft()
         stream.write(pcm_data)
-        last_time = time.time()
+        last_audio_time = time.time()
+
 
+class XiaoZhiClient:
+    """小智客户端类"""
 
-class Client:
-    def __init__(self, mac_address, url=None, ota_url=None):
+    def __init__(self, mac_address: str, url: Optional[str] = None, ota_url: Optional[str] = None):
         self.mac_address = mac_address
-        self.xiaozhi = None
+        self.xiaozhi: Optional[XiaoZhiWebsocket] = None
         self.url = url
         self.ota_url = ota_url
 
     async def start(self):
-        self.xiaozhi = XiaoZhiWebsocket(message_handler_callback, url=self.url, ota_url=self.ota_url)
+        """启动客户端连接"""
+        self.xiaozhi = XiaoZhiWebsocket(handle_message, url=self.url, ota_url=self.ota_url)
         await self.xiaozhi.init_connection(self.mac_address, aec=False)
-        asyncio.create_task(assistant_audio_play(self.xiaozhi.audio_queue))
+        asyncio.create_task(play_assistant_audio(self.xiaozhi.output_audio_queue))
 
-    def callback_func(self, indata, frames, time, status):
-        pcm = (indata.flatten() * 32767).astype(np.int16).tobytes()
-        input_audio.append(pcm)
+    def audio_callback(self, indata, frames, time, status):
+        """音频输入回调函数"""
+        pcm_data = (indata.flatten() * 32767).astype(np.int16).tobytes()
+        input_audio_buffer.append(pcm_data)
 
-    async def process_audio(self):
+    async def process_audio_input(self):
+        """处理音频输入"""
         while True:
-            if not input_audio:
+            if not input_audio_buffer:
                 await asyncio.sleep(0.02)
                 continue
-            pcm = input_audio.popleft()
-            if not is_play_audio:
-                await self.xiaozhi.send_audio(pcm)
 
-
-def mac_address(string):
-    """验证是否为有效的MAC地址"""
-    if re.fullmatch(r"([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}", string):
-        return string
-    else:
-        raise argparse.ArgumentTypeError(f"无效的MAC地址格式: '{string}'")
+            pcm_data = input_audio_buffer.popleft()
+            if not is_playing_audio:
+                await self.xiaozhi.send_audio(pcm_data)
 
 
 async def main():
-    parser = argparse.ArgumentParser(description="这是一个小智SDK。")
-    parser.add_argument("device", type=mac_address, help="你的小智设备的MAC地址 (格式: XX:XX:XX:XX:XX:XX)")
-    parser.add_argument("--url", help="小智服务 websocket 地址")
-    parser.add_argument("--ota_url", help="小智 OTA 地址")
+    """主函数"""
+    parser = argparse.ArgumentParser(description="小智SDK客户端")
+    parser.add_argument("device", help="小智设备的MAC地址 (格式: XX:XX:XX:XX:XX:XX)")
+    parser.add_argument("--url", help="小智服务websocket地址")
+    parser.add_argument("--ota_url", help="小智OTA地址")
 
     args = parser.parse_args()
-    client = Client(args.device, args.url, args.ota_url)
+    logger.info("Recording... Press Ctrl+C to stop.")
+
+    client = XiaoZhiClient(args.device, args.url, args.ota_url)
     await client.start()
-    await asyncio.sleep(2)
 
-    with sd.InputStream(callback=client.callback_func, channels=1, samplerate=16000, blocksize=960):
-        print("Recording... Press Ctrl+C to stop.")
-        await client.process_audio()  # 持续处理音频
+    with sd.InputStream(callback=client.audio_callback, channels=1, samplerate=16000, blocksize=960):
+        await client.process_audio_input()
 
 
 if __name__ == "__main__":

xiaozhi_sdk/config.py

@@ -1,5 +1,3 @@
 INPUT_SERVER_AUDIO_SAMPLE_RATE = 16000
 
-WSS_URL = "wss://api.tenclass.net/xiaozhi/v1/"
 OTA_URL = "https://api.tenclass.net/xiaozhi/ota/"
-VL_URL = "http://api.xiaozhi.me/mcp/vision/explain"

xiaozhi_sdk/iot.py

@@ -1,52 +1,76 @@
+import hashlib
+import hmac
 import json
+from typing import Any, Dict, Optional
 
 import aiohttp
 
 from xiaozhi_sdk.config import OTA_URL
 
-USER_AGENT = "XiaoXhi-SDK/1.0"
+# 常量定义
+DEFAULT_APPLICATION_VERSION = "1.0.0"
+BOARD_TYPE = "xiaozhi-sdk-box"
+USER_AGENT = "xiaozhi-sdk/{}".format(DEFAULT_APPLICATION_VERSION)
+BOARD_NAME = "xiaozhi-sdk-{}".format(DEFAULT_APPLICATION_VERSION)
 
 
-class OtaDevice(object):
+class OtaDevice:
+    """
+    OTA设备管理类
 
-    def __init__(self, mac_addr: str, client_id: str, ota_url: str, serial_number: str = ""):
+    用于处理设备的激活和挑战验证操作。
+
+    Attributes:
+        ota_url (str): OTA服务器URL
+        mac_addr (str): 设备MAC地址
+        client_id (str): 客户端ID
+        serial_number (str): 设备序列号
+    """
+
+    def __init__(self, mac_addr: str, client_id: str, ota_url: Optional[str] = None, serial_number: str = "") -> None:
         self.ota_url = ota_url or OTA_URL
         self.mac_addr = mac_addr
         self.client_id = client_id
         self.serial_number = serial_number
 
-    async def activate_device(self):
-        header = {
+    def _get_base_headers(self) -> Dict[str, str]:
+        return {
             "user-agent": USER_AGENT,
             "Device-Id": self.mac_addr,
             "Client-Id": self.client_id,
             "Content-Type": "application/json",
-            "serial-number": self.serial_number,
         }
+
+    async def activate_device(self) -> Dict[str, Any]:
+        headers = self._get_base_headers()
+        headers["serial-number"] = self.serial_number
+
         payload = {
-            "application": {"version": "1.0.0"},
+            "application": {"version": DEFAULT_APPLICATION_VERSION},
             "board": {
-                "type": "xiaozhi-sdk-box",
-                "name": "xiaozhi-sdk-main",
+                "type": BOARD_TYPE,
+                "name": BOARD_NAME,
             },
         }
+
         async with aiohttp.ClientSession() as session:
-            async with session.post(self.ota_url, headers=header, data=json.dumps(payload)) as response:
-                data = await response.json()
-                return data
+            async with session.post(self.ota_url, headers=headers, data=json.dumps(payload)) as response:
+                response.raise_for_status()
+                return await response.json()
+
+    async def check_activate(self, challenge: str, license_key: str = "") -> bool:
+        url = f"{self.ota_url}/activate"
+        headers = self._get_base_headers()
+
+        hmac_instance = hmac.new(license_key.encode(), challenge.encode(), hashlib.sha256)
+        hmac_result = hmac_instance.hexdigest()
 
-    async def check_activate(self, challenge: str):
-        url = self.ota_url + "/activate"
-        header = {
-            "user-agent": USER_AGENT,
-            "Device-Id": self.mac_addr,
-            "Client-Id": self.client_id,
-            "Content-Type": "application/json",
-        }
         payload = {
             "serial_number": self.serial_number,
             "challenge": challenge,
+            "hmac": hmac_result
         }
+
         async with aiohttp.ClientSession() as session:
-            async with session.post(url, headers=header, data=json.dumps(payload)) as response:
+            async with session.post(url, headers=headers, data=json.dumps(payload)) as response:
                 return response.status == 200

xiaozhi_sdk/mcp.py

@@ -1,16 +1,19 @@
 import json
+import logging
 
 import requests
 
-from xiaozhi_sdk.config import VL_URL
 from xiaozhi_sdk.data import mcp_initialize_payload, mcp_tool_conf, mcp_tools_payload
 
+logger = logging.getLogger("xiaozhi_sdk")
+
 
 class McpTool(object):
 
     def __init__(self):
         self.session_id = ""
-        self.vl_token = ""
+        self.explain_url = ""
+        self.explain_token = ""
         self.websocket = None
         self.tool_func = {}
 
@@ -30,48 +33,68 @@ class McpTool(object):
         )
 
     async def analyze_image(self, img_byte: bytes, question: str = "这张图片里有什么？"):
-        headers = {"Authorization": f"Bearer {self.vl_token}"}
+        headers = {"Authorization": f"Bearer {self.explain_token}"}
         files = {"file": ("camera.jpg", img_byte, "image/jpeg")}
         payload = {"question": question}
-
-        response = requests.post(VL_URL, files=files, data=payload, headers=headers)
-        return response.json()
+        try:
+            response = requests.post(self.explain_url, files=files, data=payload, headers=headers, timeout=5)
+            res_json = response.json()
+        except Exception as e:
+            return "网络异常", True
+        if res_json.get("error"):
+            return res_json, True
+        return res_json, False
 
     async def mcp_tool_call(self, mcp_json: dict):
         tool_name = mcp_json["params"]["name"]
         tool_func = self.tool_func[tool_name]
+        try:
+            tool_res, is_error = tool_func(mcp_json["params"]["arguments"])
+        except Exception as e:
+            logger.error("tool_func error: %s", e)
+            return
 
         if tool_name == "take_photo":
-            res = await self.analyze_image(tool_func(None), mcp_json["params"]["arguments"]["question"])
-        else:
-            res = tool_func(mcp_json["params"]["arguments"])
+            tool_res, is_error = await self.analyze_image(tool_res, mcp_json["params"]["arguments"]["question"])
 
-        content = json.dumps(res, ensure_ascii=False)
-        return self._build_response(mcp_json["id"], content)
+        content = json.dumps(tool_res, ensure_ascii=False)
+        return self._build_response(mcp_json["id"], content, is_error)
 
     async def mcp(self, data: dict):
         payload = data["payload"]
         method = payload["method"]
 
         if method == "initialize":
-            self.vl_token = payload["params"]["capabilities"]["vision"]["token"]
+            self.explain_url = payload["params"]["capabilities"]["vision"]["url"]
+            self.explain_token = payload["params"]["capabilities"]["vision"]["token"]
+
             mcp_initialize_payload["id"] = payload["id"]
             await self.websocket.send(self.get_mcp_json(mcp_initialize_payload))
 
+        elif method == "notifications/initialized":
+            # print("\nMCP 工具初始化")
+            pass
+
+        elif method == "notifications/cancelled":
+            logger.error("MCP 工具加载失败")
+
         elif method == "tools/list":
             mcp_tools_payload["id"] = payload["id"]
+            tool_list = []
             for name, func in self.tool_func.items():
                 if func:
+                    tool_list.append(name)
                     mcp_tool_conf[name]["name"] = name
                     mcp_tools_payload["result"]["tools"].append(mcp_tool_conf[name])
-
             await self.websocket.send(self.get_mcp_json(mcp_tools_payload))
+            if tool_list:
+                logger.info("MCP 加载成功，当前可用工具列表为：%s", tool_list)
 
         elif method == "tools/call":
-            print("tools/call", payload)
             tool_name = payload["params"]["name"]
             if not self.tool_func.get(tool_name):
                 raise Exception("Tool not found")
-
             mcp_res = await self.mcp_tool_call(payload)
             await self.websocket.send(mcp_res)
+        else:
+            logger.warning("unknown method %s: %s", method, payload)

xiaozhi_sdk/utils.py

@@ -1,6 +1,7 @@
 import ctypes.util
-import wave
+import os
 import platform
+import wave
 
 
 def get_wav_info(file_path):
@@ -27,26 +28,28 @@ def read_audio_file(file_path):
 
 
 def setup_opus():
+
     def fake_find_library(name):
+        current_dir = os.path.dirname(os.path.abspath(__file__))
         if name == "opus":
             system = platform.system().lower()
             machine = platform.machine().lower()
-            
+
             # 检测架构
-            if machine in ['x86_64', 'amd64', 'x64']:
-                arch = 'x64'
-            elif machine in ['arm64', 'aarch64']:
-                arch = 'arm64'
+            if machine in ["x86_64", "amd64", "x64"]:
+                arch = "x64"
+            elif machine in ["arm64", "aarch64"]:
+                arch = "arm64"
             else:
                 # 默认使用x64作为回退
-                arch = 'x64'
-            
+                arch = "x64"
+
             if system == "darwin":  # macOS
-                return f"./libs/macos/{arch}/libopus.dylib"
+                return f"{current_dir}/../file/opus/macos-{arch}-libopus.dylib"
             elif system == "windows":  # Windows
-                return f"./libs/windows/{arch}/opus.dll"
+                return f"{current_dir}/../file/opus/windows-{arch}-opus.dll"
             elif system == "linux":  # Linux
-                return f"./libs/linux/{arch}/libopus.so"
+                return f"{current_dir}/../file/opus/linux-{arch}-libopus.so"
             else:
                 # 默认情况，尝试系统查找
                 return ctypes.util.find_library(name)

{xiaozhi_sdk-0.0.1.dist-info → xiaozhi_sdk-0.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xiaozhi-sdk
-Version: 0.0.1
+Version: 0.0.2
 Summary: 一个用于连接和控制小智智能设备的Python SDK，支持实时音频通信、MCP工具集成和设备管理功能。
 Home-page: https://github.com/dairoot/xiaozhi-sdk
 Author: dairoot
@@ -79,7 +79,7 @@ options:
 #### 连接设备（需要提供 MAC 地址）
 
 ```bash
-python -m xiaozhi_sdk 00:11:22:33:44:55
+python -m xiaozhi_sdk 00:22:44:66:88:00
 ```
 
 ### 2. 编程使用

xiaozhi_sdk-0.0.2.dist-info/RECORD

@@ -0,0 +1,22 @@
+file/audio/greet.wav,sha256=F60kKKFVQZyYh67_-9AJHMviuquSWHHqwGQewUSOAFg,32720
+file/audio/say_hello.wav,sha256=RGo2MDUF7npGmjFPT4III0ibf7dIZ1c47jijrF0Yjaw,34146
+file/audio/take_photo.wav,sha256=_DNWg31Q8NIxN3eUS4wBC7mn4MZCWLCNPuKfKPv1ojQ,51412
+file/image/leijun.jpg,sha256=plhBvnB4O21RjLwH-HjNq0jH4Msy5ppA_IDWe5ieNg4,70814
+file/opus/linux-arm64-libopus.so,sha256=D2H5VDUomaYuLetejCvLwCgf-iAVP0isg1yGwfsuvEE,493032
+file/opus/linux-x64-libopus.so,sha256=FmXJqkxLpDzNFOHYkmOzmsp1hP0eIS5b6x_XfOs-IQA,623008
+file/opus/macos-arm64-libopus.dylib,sha256=H7wXwkrGwb-hesMMZGFxWb0Ri1Y4m5GWiKsd8CfOhE8,357584
+file/opus/macos-x64-libopus.dylib,sha256=MqyL_OjwSACF4Xs_-KrGbcScy4IEprr5Rlkk3ddZye8,550856
+file/opus/windows-x86_64-opus.dll,sha256=kLfhioMvbJhOgNMAldpWk3DCZqC5Xd70LRbHnACvAnw,463360
+xiaozhi_sdk/__init__.py,sha256=w_qhmG3_KPZM3753ovJibgeRRzMlwymwvMj0xMsWK5g,7251
+xiaozhi_sdk/__main__.py,sha256=aidncdraH8Zyvhmp2f_upMLnUL9LG1XwFf6NBd7Wnzo,3175
+xiaozhi_sdk/config.py,sha256=mpjWWklTI2bw4zY3ZWCYvqvpfZSoF5iM7ubAP9y_8cM,90
+xiaozhi_sdk/data.py,sha256=ST9ks_B23iUToacccDqa49LjdWRkvxtrxbplhVKlpqw,2527
+xiaozhi_sdk/iot.py,sha256=4KW6NNA3W5gjZYXgaujkpVPONGZ3nzMB3HOmZHS3waU,2432
+xiaozhi_sdk/mcp.py,sha256=Q1f9FJu7kEcLK_RHTSInV824kgRKp_uwEp_-rsRYUGE,3734
+xiaozhi_sdk/opus.py,sha256=4O-kz-PcUVmpa27Vju6jv-sbwywuAXFvVL23R1-vv5o,2104
+xiaozhi_sdk/utils.py,sha256=5qHAiI5Nrzeka3TofMPhAVmMovEJJa6QSrKcDM0OF4g,1703
+xiaozhi_sdk-0.0.2.dist-info/licenses/LICENSE,sha256=Vwgps1iODKl43cAtME_0dawTjAzNW-O2BWiN5BHggww,1085
+xiaozhi_sdk-0.0.2.dist-info/METADATA,sha256=lETEmKz2mqb87k17NCWdnRHfih5xmsGAZH9A7EAiOtM,2390
+xiaozhi_sdk-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xiaozhi_sdk-0.0.2.dist-info/top_level.txt,sha256=nBpue4hU5Ykm5CtYPsAdxSa_yqbtZsIT_gF_EkBaJPM,12
+xiaozhi_sdk-0.0.2.dist-info/RECORD,,

xiaozhi_sdk-0.0.1.dist-info/RECORD

@@ -1,22 +0,0 @@
-file/greet.wav,sha256=F60kKKFVQZyYh67_-9AJHMviuquSWHHqwGQewUSOAFg,32720
-file/leijun.jpg,sha256=plhBvnB4O21RjLwH-HjNq0jH4Msy5ppA_IDWe5ieNg4,70814
-file/say_hello.wav,sha256=RGo2MDUF7npGmjFPT4III0ibf7dIZ1c47jijrF0Yjaw,34146
-file/take_photo.wav,sha256=_DNWg31Q8NIxN3eUS4wBC7mn4MZCWLCNPuKfKPv1ojQ,51412
-libs/linux/arm64/libopus.so,sha256=D2H5VDUomaYuLetejCvLwCgf-iAVP0isg1yGwfsuvEE,493032
-libs/linux/x64/libopus.so,sha256=FmXJqkxLpDzNFOHYkmOzmsp1hP0eIS5b6x_XfOs-IQA,623008
-libs/macos/arm64/libopus.dylib,sha256=H7wXwkrGwb-hesMMZGFxWb0Ri1Y4m5GWiKsd8CfOhE8,357584
-libs/macos/x64/libopus.dylib,sha256=MqyL_OjwSACF4Xs_-KrGbcScy4IEprr5Rlkk3ddZye8,550856
-libs/win/x86_64/opus.dll,sha256=kLfhioMvbJhOgNMAldpWk3DCZqC5Xd70LRbHnACvAnw,463360
-xiaozhi_sdk/__init__.py,sha256=OxmYqKsXg0vcHrr5HzbsG3jJOGjhqeGMxfONkAkTD1I,6023
-xiaozhi_sdk/__main__.py,sha256=LyEt1-9Nk4MGMLSOyjgxiRau_-WyMxC-syE5PWMYAcA,2889
-xiaozhi_sdk/config.py,sha256=q4e_xmYzUB4_E5h-YftsyAhfeBSapwYD-ogx9ps1fIQ,189
-xiaozhi_sdk/data.py,sha256=ST9ks_B23iUToacccDqa49LjdWRkvxtrxbplhVKlpqw,2527
-xiaozhi_sdk/iot.py,sha256=hw2UJAMdY41AARSh7l3XTkHzV1NUiQC3YQBWTR3YSqk,1697
-xiaozhi_sdk/mcp.py,sha256=jvXICyZ4BAdpyCIBzw9q40JjQrzi562NQdU9-vwWQJw,2786
-xiaozhi_sdk/opus.py,sha256=4O-kz-PcUVmpa27Vju6jv-sbwywuAXFvVL23R1-vv5o,2104
-xiaozhi_sdk/utils.py,sha256=3o2wHRCG3dHcnn9_jbRzl1patgU1I2JTJJaTNb9EUys,1591
-xiaozhi_sdk-0.0.1.dist-info/licenses/LICENSE,sha256=Vwgps1iODKl43cAtME_0dawTjAzNW-O2BWiN5BHggww,1085
-xiaozhi_sdk-0.0.1.dist-info/METADATA,sha256=8g3Q-kcBWqymax4PYY0ypgVTcf_9Vl03JYlzkeWtWgs,2390
-xiaozhi_sdk-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xiaozhi_sdk-0.0.1.dist-info/top_level.txt,sha256=nBpue4hU5Ykm5CtYPsAdxSa_yqbtZsIT_gF_EkBaJPM,12
-xiaozhi_sdk-0.0.1.dist-info/RECORD,,