xiaogpt 3.3__py3-none-any.whl → 3.5__py3-none-any.whl

xiaogpt/cli.py

@@ -111,9 +111,10 @@ def main():
     )
     parser.add_argument(
         "--verbose",
+        "-v",
         dest="verbose",
-        action="store_true",
-        default=None,
+        action="count",
+        default=0,
         help="show info",
     )
     parser.add_argument(

xiaogpt/config.py

@@ -77,7 +77,7 @@ class Config:
     api_base: str | None = None
     deployment_id: str | None = None
     use_command: bool = False
-    verbose: bool = False
+    verbose: int = 0
     start_conversation: str = "开始持续对话"
     end_conversation: str = "结束持续对话"
     stream: bool = False

xiaogpt/tts/__init__.py

@@ -1,5 +1,6 @@
 from xiaogpt.tts.base import TTS
+from xiaogpt.tts.file import TetosFileTTS
+from xiaogpt.tts.live import TetosLiveTTS
 from xiaogpt.tts.mi import MiTTS
-from xiaogpt.tts.tetos import TetosTTS
 
-__all__ = ["TTS", "TetosTTS", "MiTTS"]
+__all__ = ["TTS", "TetosFileTTS", "MiTTS", "TetosLiveTTS"]

xiaogpt/tts/base.py

@@ -2,20 +2,10 @@ from __future__ import annotations
 
 import abc
 import asyncio
-import functools
 import json
 import logging
-import os
-import random
-import socket
-import tempfile
-import threading
-from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
-from pathlib import Path
 from typing import TYPE_CHECKING, AsyncIterator
 
-from xiaogpt.utils import get_hostname
-
 if TYPE_CHECKING:
     from typing import TypeVar
 
@@ -46,7 +36,7 @@ class TTS(abc.ABC):
                 break
             await asyncio.sleep(1)
 
-    async def get_if_xiaoai_is_playing(self):
+    async def get_if_xiaoai_is_playing(self) -> bool:
         playing_info = await self.mina_service.player_get_status(self.device_id)
         # WTF xiaomi api
         is_playing = (
@@ -59,82 +49,3 @@ class TTS(abc.ABC):
     async def synthesize(self, lang: str, text_stream: AsyncIterator[str]) -> None:
         """Synthesize speech from a stream of text."""
         raise NotImplementedError
-
-
-class HTTPRequestHandler(SimpleHTTPRequestHandler):
-    def log_message(self, format, *args):
-        logger.debug(f"{self.address_string()} - {format}", *args)
-
-    def log_error(self, format, *args):
-        logger.error(f"{self.address_string()} - {format}", *args)
-
-    def copyfile(self, source, outputfile):
-        try:
-            super().copyfile(source, outputfile)
-        except (socket.error, ConnectionResetError, BrokenPipeError):
-            # ignore this or TODO find out why the error later
-            pass
-
-
-class AudioFileTTS(TTS):
-    """A TTS model that generates audio files locally and plays them via URL."""
-
-    def __init__(
-        self, mina_service: MiNAService, device_id: str, config: Config
-    ) -> None:
-        super().__init__(mina_service, device_id, config)
-        self.dirname = tempfile.TemporaryDirectory(prefix="xiaogpt-tts-")
-        self._start_http_server()
-
-    @abc.abstractmethod
-    async def make_audio_file(self, lang: str, text: str) -> tuple[Path, float]:
-        """Synthesize speech from text and save it to a file.
-        Return the file path and the duration of the audio in seconds.
-        The file path must be relative to the self.dirname.
-        """
-        raise NotImplementedError
-
-    async def synthesize(self, lang: str, text_stream: AsyncIterator[str]) -> None:
-        queue: asyncio.Queue[tuple[str, float]] = asyncio.Queue()
-        finished = asyncio.Event()
-
-        async def worker():
-            async for text in text_stream:
-                path, duration = await self.make_audio_file(lang, text)
-                url = f"http://{self.hostname}:{self.port}/{path.name}"
-                await queue.put((url, duration))
-            finished.set()
-
-        task = asyncio.create_task(worker())
-
-        while True:
-            try:
-                url, duration = queue.get_nowait()
-            except asyncio.QueueEmpty:
-                if finished.is_set():
-                    break
-                else:
-                    await asyncio.sleep(0.1)
-                    continue
-            logger.debug("Playing URL %s (%s seconds)", url, duration)
-            await asyncio.gather(
-                self.mina_service.play_by_url(self.device_id, url, _type=1),
-                self.wait_for_duration(duration),
-            )
-        await task
-
-    def _start_http_server(self):
-        # set the port range
-        port_range = range(8050, 8090)
-        # get a random port from the range
-        self.port = int(os.getenv("XIAOGPT_PORT", random.choice(port_range)))
-        # create the server
-        handler = functools.partial(HTTPRequestHandler, directory=self.dirname.name)
-        httpd = ThreadingHTTPServer(("", self.port), handler)
-        # start the server in a new thread
-        server_thread = threading.Thread(target=httpd.serve_forever)
-        server_thread.daemon = True
-        server_thread.start()
-
-        self.hostname = get_hostname()
-        logger.info(f"Serving on {self.hostname}:{self.port}")

xiaogpt/tts/file.py

@@ -0,0 +1,103 @@
+import asyncio
+import functools
+import os
+import random
+import socket
+import tempfile
+import threading
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import AsyncIterator
+
+from miservice import MiNAService
+
+from xiaogpt.config import Config
+from xiaogpt.tts.base import TTS, logger
+from xiaogpt.utils import get_hostname
+
+
+class HTTPRequestHandler(SimpleHTTPRequestHandler):
+    def log_message(self, format, *args):
+        logger.debug(f"{self.address_string()} - {format}", *args)
+
+    def log_error(self, format, *args):
+        logger.error(f"{self.address_string()} - {format}", *args)
+
+    def copyfile(self, source, outputfile):
+        try:
+            super().copyfile(source, outputfile)
+        except (socket.error, ConnectionResetError, BrokenPipeError):
+            # ignore this or TODO find out why the error later
+            pass
+
+
+class TetosFileTTS(TTS):
+    """A TTS model that generates audio files locally and plays them via URL."""
+
+    def __init__(
+        self, mina_service: MiNAService, device_id: str, config: Config
+    ) -> None:
+        from tetos import get_speaker
+
+        super().__init__(mina_service, device_id, config)
+        self.dirname = tempfile.TemporaryDirectory(prefix="xiaogpt-tts-")
+        self._start_http_server()
+
+        assert config.tts and config.tts != "mi"
+        speaker_cls = get_speaker(config.tts)
+        try:
+            self.speaker = speaker_cls(**config.tts_options)
+        except TypeError as e:
+            raise ValueError(f"{e}. Please add them via `tts_options` config") from e
+
+    async def make_audio_file(self, lang: str, text: str) -> tuple[Path, float]:
+        output_file = tempfile.NamedTemporaryFile(
+            suffix=".mp3", mode="wb", delete=False, dir=self.dirname.name
+        )
+        duration = await self.speaker.synthesize(text, output_file.name, lang=lang)
+        return Path(output_file.name), duration
+
+    async def synthesize(self, lang: str, text_stream: AsyncIterator[str]) -> None:
+        queue: asyncio.Queue[tuple[str, float]] = asyncio.Queue()
+        finished = asyncio.Event()
+
+        async def worker():
+            async for text in text_stream:
+                path, duration = await self.make_audio_file(lang, text)
+                url = f"http://{self.hostname}:{self.port}/{path.name}"
+                await queue.put((url, duration))
+            finished.set()
+
+        task = asyncio.create_task(worker())
+
+        while True:
+            try:
+                url, duration = queue.get_nowait()
+            except asyncio.QueueEmpty:
+                if finished.is_set():
+                    break
+                else:
+                    await asyncio.sleep(0.1)
+                    continue
+            logger.debug("Playing URL %s (%s seconds)", url, duration)
+            await asyncio.gather(
+                self.mina_service.play_by_url(self.device_id, url, _type=1),
+                self.wait_for_duration(duration),
+            )
+        await task
+
+    def _start_http_server(self):
+        # set the port range
+        port_range = range(8050, 8090)
+        # get a random port from the range
+        self.port = int(os.getenv("XIAOGPT_PORT", random.choice(port_range)))
+        # create the server
+        handler = functools.partial(HTTPRequestHandler, directory=self.dirname.name)
+        httpd = ThreadingHTTPServer(("", self.port), handler)
+        # start the server in a new thread
+        server_thread = threading.Thread(target=httpd.serve_forever)
+        server_thread.daemon = True
+        server_thread.start()
+
+        self.hostname = get_hostname()
+        logger.info(f"Serving on {self.hostname}:{self.port}")

xiaogpt/tts/live.py

@@ -0,0 +1,103 @@
+import asyncio
+import os
+import queue
+import random
+import threading
+import uuid
+from functools import lru_cache
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import AsyncIterator
+
+from miservice import MiNAService
+
+from xiaogpt.config import Config
+from xiaogpt.tts.base import TTS, logger
+from xiaogpt.utils import get_hostname
+
+
+@lru_cache(maxsize=64)
+def get_queue(key: str) -> queue.Queue[bytes]:
+    return queue.Queue()
+
+
+class HTTPRequestHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        self.send_response(200)
+        self.send_header("Content-type", "audio/mpeg")
+        self.end_headers()
+        key = self.path.split("/")[-1]
+        queue = get_queue(key)
+        chunks: list[bytes] = []
+        while True:
+            chunk = queue.get()
+            chunks.append(chunk)
+            if chunk == b"":
+                break
+            self.wfile.write(chunk)
+        for chunk in chunks:
+            queue.put_nowait(chunk)
+
+    def log_message(self, format, *args):
+        logger.debug(f"{self.address_string()} - {format}", *args)
+
+    def log_error(self, format, *args):
+        logger.error(f"{self.address_string()} - {format}", *args)
+
+
+class TetosLiveTTS(TTS):
+    """A TTS model that generates audio in real-time."""
+
+    def __init__(
+        self, mina_service: MiNAService, device_id: str, config: Config
+    ) -> None:
+        from tetos import get_speaker
+
+        super().__init__(mina_service, device_id, config)
+        self._start_http_server()
+
+        assert config.tts and config.tts != "mi"
+        speaker_cls = get_speaker(config.tts)
+        try:
+            self.speaker = speaker_cls(**config.tts_options)
+        except TypeError as e:
+            raise ValueError(f"{e}. Please add them via `tts_options` config") from e
+        if not hasattr(self.speaker, "live"):
+            raise ValueError(f"{config.tts} Speaker does not support live synthesis")
+
+    async def synthesize(self, lang: str, text_stream: AsyncIterator[str]) -> None:
+        key = str(uuid.uuid4())
+        queue = get_queue(key)
+
+        async def worker():
+            async for chunk in self.speaker.live(text_stream, lang):
+                queue.put(chunk)
+            queue.put(b"")
+
+        task = asyncio.create_task(worker())
+        await self.mina_service.play_by_url(
+            self.device_id, f"http://{self.hostname}:{self.port}/{key}", _type=1
+        )
+
+        while True:
+            if await self.get_if_xiaoai_is_playing():
+                logger.debug("Xiaoai is playing, waiting")
+                await asyncio.sleep(1)
+            else:
+                break
+        await task
+
+    def _start_http_server(self):
+        # set the port range
+        port_range = range(8050, 8090)
+        # get a random port from the range
+        self.port = int(os.getenv("XIAOGPT_PORT", random.choice(port_range)))
+        # create the server
+        handler = HTTPRequestHandler
+        httpd = ThreadingHTTPServer(("", self.port), handler)
+        # start the server in a new thread
+        server_thread = threading.Thread(target=httpd.serve_forever)
+        server_thread.daemon = True
+        server_thread.start()
+
+        self.hostname = get_hostname()
+        logger.info(f"Serving on {self.hostname}:{self.port}")

xiaogpt/xiaogpt.py

@@ -23,7 +23,8 @@ from xiaogpt.config import (
     WAKEUP_KEYWORD,
     Config,
 )
-from xiaogpt.tts import TTS, MiTTS, TetosTTS
+from xiaogpt.tts import TTS, MiTTS, TetosFileTTS
+from xiaogpt.tts.live import TetosLiveTTS
 from xiaogpt.utils import detect_language, parse_cookie_string
 
 EOF = object()
@@ -56,15 +57,20 @@ class MiGPT:
     async def poll_latest_ask(self):
         async with ClientSession() as session:
             session._cookie_jar = self.cookie_jar
+            log_polling = int(self.config.verbose) > 1
             while True:
-                self.log.debug(
-                    "Listening new message, timestamp: %s", self.last_timestamp
-                )
+                if log_polling:
+                    self.log.debug(
+                        "Listening new message, timestamp: %s", self.last_timestamp
+                    )
                 new_record = await self.get_latest_ask_from_xiaoai(session)
                 start = time.perf_counter()
-                self.log.debug(
-                    "Polling_event, timestamp: %s %s", self.last_timestamp, new_record
-                )
+                if log_polling:
+                    self.log.debug(
+                        "Polling_event, timestamp: %s %s",
+                        self.last_timestamp,
+                        new_record,
+                    )
                 await self.polling_event.wait()
                 if (
                     self.config.mute_xiaoai
@@ -74,7 +80,10 @@ class MiGPT:
                     await self.stop_if_xiaoai_is_playing()
                 if (d := time.perf_counter() - start) < 1:
                     # sleep to avoid too many request
-                    self.log.debug("Sleep %f, timestamp: %s", d, self.last_timestamp)
+                    if log_polling:
+                        self.log.debug(
+                            "Sleep %f, timestamp: %s", d, self.last_timestamp
+                        )
                     # if you want force mute xiaoai, comment this line below.
                     await asyncio.sleep(1 - d)
 
@@ -260,8 +269,10 @@ class MiGPT:
     def tts(self) -> TTS:
         if self.config.tts == "mi":
             return MiTTS(self.mina_service, self.device_id, self.config)
+        elif self.config.tts == "fish":
+            return TetosLiveTTS(self.mina_service, self.device_id, self.config)
         else:
-            return TetosTTS(self.mina_service, self.device_id, self.config)
+            return TetosFileTTS(self.mina_service, self.device_id, self.config)
 
     async def wait_for_tts_finish(self):
         while True:
@@ -331,6 +342,7 @@ class MiGPT:
     async def stop_if_xiaoai_is_playing(self):
         is_playing = await self.get_if_xiaoai_is_playing()
         if is_playing:
+            self.log.debug("Muting xiaoai")
             # stop it
             await self.mina_service.player_pause(self.device_id)
 

{xiaogpt-3.3.dist-info → xiaogpt-3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xiaogpt
-Version: 3.3
+Version: 3.5
 Summary: Play ChatGPT or other LLM with xiaomi AI speaker
 Author-Email: yihong0618 <zouzou0208@gmail.com>
 License: MIT
@@ -65,6 +65,7 @@ Requires-Dist: h11==0.14.0; extra == "locked"
 Requires-Dist: httpcore==1.0.5; extra == "locked"
 Requires-Dist: httplib2==0.22.0; extra == "locked"
 Requires-Dist: httpx==0.27.2; extra == "locked"
+Requires-Dist: httpx-ws==0.6.2; extra == "locked"
 Requires-Dist: httpx[socks]==0.27.2; extra == "locked"
 Requires-Dist: idna==3.7; extra == "locked"
 Requires-Dist: jiter==0.5.0; extra == "locked"
@@ -111,14 +112,14 @@ Requires-Dist: socksio==1.0.0; extra == "locked"
 Requires-Dist: soupsieve==2.5; extra == "locked"
 Requires-Dist: sqlalchemy==2.0.25; extra == "locked"
 Requires-Dist: tenacity==8.2.3; extra == "locked"
-Requires-Dist: tetos==0.3.1; extra == "locked"
+Requires-Dist: tetos==0.4.1; extra == "locked"
 Requires-Dist: tqdm==4.66.1; extra == "locked"
 Requires-Dist: typing-extensions==4.12.2; extra == "locked"
 Requires-Dist: typing-inspect==0.9.0; extra == "locked"
 Requires-Dist: uritemplate==4.1.1; extra == "locked"
 Requires-Dist: urllib3==2.1.0; extra == "locked"
 Requires-Dist: websocket-client==1.8.0; extra == "locked"
-Requires-Dist: websockets==12.0; extra == "locked"
+Requires-Dist: wsproto==1.2.0; extra == "locked"
 Requires-Dist: yarl==1.14.0; extra == "locked"
 Requires-Dist: zhipuai==2.1.5.20230904; extra == "locked"
 Description-Content-Type: text/markdown

{xiaogpt-3.3.dist-info → xiaogpt-3.5.dist-info}/RECORD

@@ -1,7 +1,7 @@
-xiaogpt-3.3.dist-info/METADATA,sha256=5nJ9Wb_Io16JM6QtUo8sC7Xfz6CoHI01VBQFwAPvOVw,31468
-xiaogpt-3.3.dist-info/WHEEL,sha256=pM0IBB6ZwH3nkEPhtcp50KvKNX-07jYtnb1g1m6Z4Co,90
-xiaogpt-3.3.dist-info/entry_points.txt,sha256=q4WRS7kS4kQ5kZX57Fq40VrhCi74NZcyRPRX4JP2veo,61
-xiaogpt-3.3.dist-info/licenses/LICENSE,sha256=XdClh516MvlnOf9749JZHCxSB7y6_fyXcWmLDz6IkZY,1063
+xiaogpt-3.5.dist-info/METADATA,sha256=fqymHqLmsFnNBE2G332D8ZbdmEFJ0gI3q08OXn6M3j0,31516
+xiaogpt-3.5.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+xiaogpt-3.5.dist-info/entry_points.txt,sha256=q4WRS7kS4kQ5kZX57Fq40VrhCi74NZcyRPRX4JP2veo,61
+xiaogpt-3.5.dist-info/licenses/LICENSE,sha256=XdClh516MvlnOf9749JZHCxSB7y6_fyXcWmLDz6IkZY,1063
 xiaogpt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xiaogpt/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
 xiaogpt/bot/__init__.py,sha256=BDGvj1JuWVw47qfREWGKnSXeiFg6DVJJAz2rHVryqmc,1160
@@ -15,16 +15,17 @@ xiaogpt/bot/llama_bot.py,sha256=HRR_ycuC6DY5MQTKauXEayQ0o_JKk9t-ea3mblscm8E,708
 xiaogpt/bot/moonshot_bot.py,sha256=PrVRBskZx-U0lH_3RVe89QJa7WKHYqhpft0089pYQz0,822
 xiaogpt/bot/qwen_bot.py,sha256=rFCOz5uiUsuhePjPozdCecNv5HGiUTNEhHYNw3Exexs,3590
 xiaogpt/bot/yi_bot.py,sha256=D7JEIh8KPVMvlOLaEVr9ahvyMaJLGToHP_gWU3RoYPc,784
-xiaogpt/cli.py,sha256=HXKkW5yg2q8qCruzjMjNTgcjsvs-qoZWPg6mNC_XSB8,5926
-xiaogpt/config.py,sha256=mwlJ26_Yv6BriPuWgZaaxotPCr6rO4MahlJXquawJt0,7048
+xiaogpt/cli.py,sha256=iUPQwiZqIpzu1HoinneijBEfVKV7F_f_YMgqPPZM5lA,5932
+xiaogpt/config.py,sha256=GpK3RXJI_B5YBKMxErAh9wUH1FWqVbQppZM4f7B-EoI,7043
 xiaogpt/langchain/callbacks.py,sha256=yR9AXQt9OHVYBWC47Q1I_BUT4Xg9iM44vnW2vv0BLpE,2616
 xiaogpt/langchain/chain.py,sha256=z0cqRlL0ElWnf31ByxZBN7AKOT-svXQDt5_NDft_nYc,1495
 xiaogpt/langchain/examples/email/mail_box.py,sha256=xauqrjE4-G4XPQnokUPE-MZgAaHQ_VrUDLlbfYTdCoo,6372
 xiaogpt/langchain/examples/email/mail_summary_tools.py,sha256=6cWvBJUaA7iaywcHdbUoww8WiCtaNw3TmwyxyF4DY7E,1561
-xiaogpt/tts/__init__.py,sha256=xasHDrmgECirf1MSyrfURSaMBqtdZBi3cQNeDvPo_cQ,145
-xiaogpt/tts/base.py,sha256=k0ZUcLJZWU5U_fXu_w-cLFgZpE2KkV89ARbVDXLqTck,4665
+xiaogpt/tts/__init__.py,sha256=75_W5ZhON87RSutiLhJB29Ub-634iI2IlTEZd0alao8,210
+xiaogpt/tts/base.py,sha256=8vP8fIksSZttmrMaUT4vtiDbkfijkr9lbhyod1_5tc4,1440
+xiaogpt/tts/file.py,sha256=pWzozktMAgJraPiANWQC5dB4EQcL9QCwJWbX_M4hqWE,3721
+xiaogpt/tts/live.py,sha256=7-NpuOU7E6GNht1PHjAA8_miXdFVDk8C7aL-sY1xqPE,3299
 xiaogpt/tts/mi.py,sha256=1MzCB27DBohPQ_4Xz4W_FV9p-chJFDavOHB89NviLcM,1095
-xiaogpt/tts/tetos.py,sha256=fkuOSYGqAfJyyPEXbsiOS--CewGf1JUiahoN33nzOAA,1058
 xiaogpt/utils.py,sha256=YYmRDNtccxqB9gyN_xhKZwgL1_PNYEp7So_-jt2tiVg,2668
-xiaogpt/xiaogpt.py,sha256=ZSVsMzwSW0uxwW2VN4phXV1A-suyrwhE0jAMGtaUB5I,16196
-xiaogpt-3.3.dist-info/RECORD,,
+xiaogpt/xiaogpt.py,sha256=zHZFijx-tH6vi3roB1uluZUhqLUnhmYNUR367GXVixg,16696
+xiaogpt-3.5.dist-info/RECORD,,

{xiaogpt-3.3.dist-info → xiaogpt-3.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.4.2)
+Generator: pdm-backend (2.4.3)
 Root-Is-Purelib: true
 Tag: py3-none-any

xiaogpt/tts/tetos.py

@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-import tempfile
-from pathlib import Path
-
-from miservice import MiNAService
-
-from xiaogpt.config import Config
-from xiaogpt.tts.base import AudioFileTTS
-
-
-class TetosTTS(AudioFileTTS):
-    def __init__(
-        self, mina_service: MiNAService, device_id: str, config: Config
-    ) -> None:
-        from tetos import get_speaker
-
-        super().__init__(mina_service, device_id, config)
-        assert config.tts and config.tts != "mi"
-        speaker_cls = get_speaker(config.tts)
-        try:
-            self.speaker = speaker_cls(**config.tts_options)
-        except TypeError as e:
-            raise ValueError(f"{e}. Please add them via `tts_options` config") from e
-
-    async def make_audio_file(self, lang: str, text: str) -> tuple[Path, float]:
-        output_file = tempfile.NamedTemporaryFile(
-            suffix=".mp3", mode="wb", delete=False, dir=self.dirname.name
-        )
-        duration = await self.speaker.synthesize(text, output_file.name, lang=lang)
-        return Path(output_file.name), duration