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

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,98 @@
+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)
+        while True:
+            chunk = queue.get()
+            if chunk == b"":
+                break
+            self.wfile.write(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():
+                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()
@@ -260,8 +261,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:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xiaogpt
-Version: 3.3
+Version: 3.4
 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.4.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.4.dist-info/METADATA,sha256=JZdIj1t1yuHoWkRqXOzO0Uo6rS1Q3pJ52TlLJQ0VpPg,31516
+xiaogpt-3.4.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+xiaogpt-3.4.dist-info/entry_points.txt,sha256=q4WRS7kS4kQ5kZX57Fq40VrhCi74NZcyRPRX4JP2veo,61
+xiaogpt-3.4.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
@@ -21,10 +21,11 @@ xiaogpt/langchain/callbacks.py,sha256=yR9AXQt9OHVYBWC47Q1I_BUT4Xg9iM44vnW2vv0BLp
 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=tmyW26TRTau1Ci_7aHiNyzv-UfzoaiWgnlxz4gA62yw,3109
 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=Og982fJSlzbMhcjP_Hj5dj1dKS-31y4gXA8sZRwZOPI,16366
+xiaogpt-3.4.dist-info/RECORD,,

{xiaogpt-3.3.dist-info → xiaogpt-3.4.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