messageflight 0.2.4__py3-none-any.whl

message_flight/tts.py

@@ -0,0 +1,298 @@
+"""Text-to-speech notification reader.
+
+Provides ``TTSReader`` abstract base class and two concrete implementations:
+- ``SAPIReader``  – Windows SAPI via pywin32 (falls back to no-op if unavailable)
+- ``MiniMaxReader`` – MiniMax online TTS engine via Qt async network + pygame audio
+"""
+from __future__ import annotations
+
+import binascii
+import json
+import logging
+import os
+import sys
+import tempfile
+import uuid
+
+from PyQt6.QtCore import QByteArray, QObject, QTimer, QUrl, pyqtSignal
+from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkReply, QNetworkRequest
+
+logger = logging.getLogger(__name__)
+
+
+class TTSReader:
+    """Abstract TTS reader that formats a message through a template and
+    delegates speaking to :meth:`_speak_impl`.
+    """
+
+    def __init__(self, enabled: bool = True, title_template: str = "{message}"):
+        self._enabled = enabled
+        self._title_template = title_template
+
+    def speak(self, message: str) -> None:
+        """If enabled, format *message* with :attr:`_title_template` and speak it."""
+        if not self._enabled:
+            logger.debug("TTSReader.speak: skipped (disabled)")
+            return
+        try:
+            text = self._title_template.replace("{message}", message)
+        except Exception as e:
+            logger.error("TTS format error: %s", e)
+            return
+        try:
+            logger.debug("TTSReader.speak: speaking text=%r", text)
+            self._speak_impl(text)
+        except Exception as e:
+            logger.error("TTS speak error: %s", e)
+
+    def _speak_impl(self, text: str) -> None:
+        """Concrete subclasses must override this method."""
+        raise NotImplementedError
+
+
+class SAPIReader(TTSReader):
+    """Windows SAPI TTS via ``win32com.client``.
+
+    If ``pywin32`` is not installed or the platform is not Windows,
+    initialization silently fails and :meth:`speak` becomes a no-op.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        if self._enabled:
+            self._init_sapi()
+
+    def _init_sapi(self) -> None:
+        if sys.platform != "win32":
+            logger.warning("SAPIReader: not on Windows, disabling")
+            self._enabled = False
+            return
+        try:
+            import win32com.client
+
+            self._speaker = win32com.client.Dispatch("SAPI.SpVoice")
+            logger.info("SAPIReader: SAPI initialized successfully")
+        except Exception as e:
+            logger.warning("SAPIReader: failed to initialize SAPI: %s", e)
+            self._enabled = False
+
+    # SVSFlagsAsync = 1 — speak asynchronously so we don't block the UI
+    _SVS_FLAGS_ASYNC = 1
+
+    def _speak_impl(self, text: str) -> None:
+        logger.debug("SAPIReader._speak_impl: speaking asynchronously")
+        self._speaker.Speak(text, self._SVS_FLAGS_ASYNC)
+
+
+class MiniMaxReader(TTSReader, QObject):
+    """MiniMax TTS via QNetworkAccessManager + pygame.mixer.
+
+    Asynchronously calls the MiniMax API and plays the returned MP3.
+    On any error, emits ``error_occurred`` so TTSManager can fall back
+    to SAPIReader.
+    """
+
+    playback_finished = pyqtSignal()
+    # error_occurred(error_message: str, original_text: str)
+    # original_text is passed so TTSManager can fall back with the correct message
+    error_occurred = pyqtSignal(str, str)
+
+    _ENDPOINT = "https://api.minimaxi.com/v1/t2a_v2"
+    _DEFAULT_VOICE = "male-qn-qingse"
+    _TIMEOUT_MS = 10000
+
+    def __init__(
+        self,
+        api_key: str = "",
+        voice_id: str = _DEFAULT_VOICE,
+        speed: float = 1.0,
+        vol: float = 1.0,
+        enabled: bool = True,
+        title_template: str = "{message}",
+    ):
+        TTSReader.__init__(self, enabled=enabled, title_template=title_template)
+        QObject.__init__(self)
+        self._api_key = api_key
+        self._voice_id = voice_id
+        self._speed = speed
+        self._vol = vol
+        self._network = QNetworkAccessManager()
+        self._active_audio_files: set[str] = set()  # Track temp files for cleanup
+        self._last_text = ""  # Last text sent to MiniMax, for error fallback
+        self._reply_text_map: dict[int, str] = {}  # id(reply) -> original text
+
+        self._network.finished.connect(self._on_reply_finished)
+        from PyQt6.QtWidgets import QApplication
+        app = QApplication.instance()
+        if app is not None:
+            app.aboutToQuit.connect(self.cleanup)
+        logger.info("MiniMaxReader: initialized with voice_id=%s", voice_id)
+
+    def _speak_impl(self, text: str) -> None:
+        self._last_text = text
+        if not self._api_key:
+            logger.error("MiniMaxReader._speak_impl: api_key is empty")
+            self.error_occurred.emit("MiniMax API key is empty", text)
+            return
+
+        logger.info("MiniMaxReader._speak_impl: sending TTS request for text=%r", text[:50])
+
+        request = QNetworkRequest(QUrl(self._ENDPOINT))
+        request.setTransferTimeout(self._TIMEOUT_MS)
+        request.setHeader(QNetworkRequest.KnownHeaders.ContentTypeHeader, "application/json")
+        request.setRawHeader(b"Authorization", f"Bearer {self._api_key}".encode())
+
+        payload = {
+            "model": "speech-2.8-hd",
+            "text": text,
+            "stream": False,
+            "voice_setting": {
+                "voice_id": self._voice_id,
+                "speed": self._speed,
+                "vol": self._vol,
+                "pitch": 0,
+            },
+            "audio_setting": {
+                "sample_rate": 32000,
+                "bitrate": 128000,
+                "format": "mp3",
+                "channel": 1,
+            },
+        }
+        body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+        logger.debug("MiniMaxReader._speak_impl: request body=%s", body.decode("utf-8")[:200])
+        reply = self._network.post(request, body)
+        self._reply_text_map[id(reply)] = text
+
+    def _on_reply_finished(self, reply: QNetworkReply) -> None:
+        status_code = reply.attribute(QNetworkRequest.Attribute.HttpStatusCodeAttribute)
+        logger.info("MiniMaxReader._on_reply_finished: HTTP status=%s", status_code)
+
+        original_text = self._reply_text_map.pop(id(reply), self._last_text)
+
+        if reply.error() != QNetworkReply.NetworkError.NoError:
+            err_msg = f"MiniMax network error: {reply.errorString()}"
+            logger.error("MiniMaxReader._on_reply_finished: %s", err_msg)
+            self.error_occurred.emit(err_msg, original_text)
+            reply.deleteLater()
+            return
+
+        data = reply.readAll()
+        if data.isEmpty():
+            logger.error("MiniMaxReader._on_reply_finished: empty response")
+            self.error_occurred.emit("MiniMax returned empty response", original_text)
+            reply.deleteLater()
+            return
+
+        try:
+            response_text = data.data().decode("utf-8")
+            logger.debug("MiniMaxReader._on_reply_finished: response=%s", response_text[:500])
+            response_json = json.loads(response_text)
+        except (UnicodeDecodeError, json.JSONDecodeError) as e:
+            logger.error("MiniMaxReader._on_reply_finished: failed to parse response: %s", e)
+            self.error_occurred.emit(f"MiniMax response parse error: {e}", original_text)
+            reply.deleteLater()
+            return
+
+        # Check base_resp for API errors
+        base_resp = response_json.get("base_resp", {})
+        status_code_api = base_resp.get("status_code", 0)
+        if status_code_api != 0:
+            status_msg = base_resp.get("status_msg", "unknown error")
+            err_msg = f"MiniMax API error {status_code_api}: {status_msg}"
+            logger.error("MiniMaxReader._on_reply_finished: %s", err_msg)
+            self.error_occurred.emit(err_msg, original_text)
+            reply.deleteLater()
+            return
+
+        # Extract hex-encoded audio
+        audio_hex = response_json.get("data", {}).get("audio", "")
+        if not audio_hex:
+            logger.error("MiniMaxReader._on_reply_finished: no audio in response")
+            self.error_occurred.emit("MiniMax returned no audio data", self._last_text)
+            reply.deleteLater()
+            return
+
+        try:
+            audio_bytes = binascii.unhexlify(audio_hex)
+            logger.info("MiniMaxReader._on_reply_finished: decoded %d bytes of audio", len(audio_bytes))
+        except binascii.Error as e:
+            logger.error("MiniMaxReader._on_reply_finished: failed to decode audio hex: %s", e)
+            self.error_occurred.emit(f"MiniMax audio decode error: {e}", self._last_text)
+            reply.deleteLater()
+            return
+
+        self._buffer = QByteArray(audio_bytes)
+        # Use uuid to avoid filename collisions between concurrent requests
+        audio_path = os.path.join(tempfile.gettempdir(), f"messageflight_{uuid.uuid4().hex}.mp3")
+        with open(audio_path, "wb") as f:
+            f.write(self._buffer.data())
+
+        self._active_audio_files.add(audio_path)
+        logger.info("MiniMaxReader._on_reply_finished: saved audio to %s (%d bytes)", audio_path, len(audio_bytes))
+
+        # Use pygame.mixer to play audio (reliable cross-platform MP3 playback)
+        self._play_audio_with_pygame(audio_path)
+        reply.deleteLater()
+
+    def _play_audio_with_pygame(self, audio_path: str) -> None:
+        """Play audio file using pygame.mixer."""
+        try:
+            import pygame
+
+            # Initialize pygame mixer if not already initialized
+            if not pygame.mixer.get_init():
+                pygame.mixer.init(frequency=32000)
+                logger.info("MiniMaxReader: pygame.mixer initialized")
+
+            # Load and play the audio
+            sound = pygame.mixer.Sound(audio_path)
+            sound.set_volume(self._vol)
+            sound.play()
+            logger.info("MiniMaxReader: playing audio from %s", audio_path)
+
+            # Track this file for cleanup
+            timer = QTimer(self)
+            timer.setSingleShot(True)
+            # Capture audio_path by value to avoid closure issues
+            timer.timeout.connect(lambda _path=audio_path, _timer=timer: self._cleanup_after_playback(_path, _timer))
+            timer.start(100)  # Check every 100ms
+
+        except Exception as e:
+            logger.error("MiniMaxReader: failed to play audio with pygame: %s", e)
+            self._remove_audio_file(audio_path)
+            self.error_occurred.emit(f"Audio playback error: {e}", self._last_text)
+
+    def _cleanup_after_playback(self, audio_path: str, timer: QTimer) -> None:
+        """Check if pygame audio playback has finished and clean up the file."""
+        try:
+            import pygame
+            if not pygame.mixer.get_busy():
+                logger.debug("MiniMaxReader: playback finished for %s", audio_path)
+                self.playback_finished.emit()
+                timer.stop()
+                timer.deleteLater()
+                self._remove_audio_file(audio_path)
+            else:
+                # Still playing, check again
+                timer.start(100)
+        except Exception:
+            timer.stop()
+            timer.deleteLater()
+            self._remove_audio_file(audio_path)
+
+    def _remove_audio_file(self, audio_path: str) -> None:
+        """Remove a temporary audio file and update tracking."""
+        self._active_audio_files.discard(audio_path)
+        if os.path.exists(audio_path):
+            try:
+                os.remove(audio_path)
+                logger.debug("MiniMaxReader: removed temp file %s", audio_path)
+            except OSError as e:
+                logger.warning("MiniMaxReader: failed to remove temp file %s: %s", audio_path, e)
+
+    def cleanup(self) -> None:
+        """Remove all active temp audio files. Called on application exit."""
+        for path in list(self._active_audio_files):
+            self._remove_audio_file(path)
+        self._active_audio_files.clear()

message_flight/tts_manager.py

@@ -0,0 +1,98 @@
+"""TTS provider manager with automatic fallback."""
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from PyQt6.QtCore import QObject, pyqtSignal
+
+from message_flight.config import AppConfig
+from message_flight.tts import MiniMaxReader, SAPIReader, TTSReader
+
+logger = logging.getLogger(__name__)
+
+
+class TTSManager(QObject):
+    """Manages TTS providers and handles automatic fallback.
+
+    Usage:
+        mgr = TTSManager(config)
+        mgr.speak("notification text")
+
+    On MiniMax error, automatically falls back to SAPIReader.
+    """
+
+    provider_changed = pyqtSignal(str)
+    fallback_triggered = pyqtSignal(str)
+
+    def __init__(self, config: AppConfig, parent: Optional[QObject] = None):
+        super().__init__(parent)
+        self._config = config
+        self._current_provider_name = config.tts_provider
+        logger.info("TTSManager: initialized with provider=%s", self._current_provider_name)
+        self._providers: dict[str, TTSReader] = {}
+        self._last_message = ""
+        self._init_providers()
+
+    def _init_providers(self) -> None:
+        """Initialize all known providers."""
+        self._providers["sapi"] = SAPIReader(
+            enabled=True,
+            title_template="您有新消息了。{message}",
+        )
+        key_preview = self._config.minimax_subscription_key[:8] + "..." if self._config.minimax_subscription_key else "(empty)"
+        logger.info("TTSManager._init_providers: creating MiniMaxReader with key=%s", key_preview)
+        self._providers["minimax"] = MiniMaxReader(
+            api_key=self._config.minimax_subscription_key,
+            enabled=True,
+            title_template="您有新消息了。{message}",
+        )
+        # Connect MiniMax error signal to fallback handler
+        minimax = self._providers.get("minimax")
+        if isinstance(minimax, MiniMaxReader):
+            minimax.error_occurred.connect(self._on_minimax_error)
+
+    def speak(self, message: str) -> None:
+        """Speak a message using the current provider."""
+        logger.info("TTSManager.speak: provider=%s message=%r", self._current_provider_name, message[:50])
+        self._last_message = message
+        provider = self._providers.get(self._current_provider_name)
+        if provider is None:
+            logger.warning("TTSManager.speak: unknown provider %r, falling back to sapi", self._current_provider_name)
+            provider = self._providers.get("sapi")
+        if provider is not None:
+            provider.speak(message)
+
+    def update_config(self, config: AppConfig) -> None:
+        """Hot-update configuration (e.g. after settings dialog)."""
+        logger.info("TTSManager.update_config: provider=%s -> %s", self._current_provider_name, config.tts_provider)
+        self._config = config
+        old_provider = self._current_provider_name
+        self._current_provider_name = config.tts_provider
+
+        # Update MiniMaxReader API key if changed
+        minimax = self._providers.get("minimax")
+        if isinstance(minimax, MiniMaxReader):
+            old_key = minimax._api_key[:8] + "..." if minimax._api_key else "(empty)"
+            new_key = config.minimax_subscription_key[:8] + "..." if config.minimax_subscription_key else "(empty)"
+            logger.info("TTSManager.update_config: updating MiniMax key %s -> %s", old_key, new_key)
+            minimax._api_key = config.minimax_subscription_key
+
+        if old_provider != self._current_provider_name:
+            self.provider_changed.emit(self._current_provider_name)
+
+    def _on_minimax_error(self, error_msg: str, original_text: str) -> None:
+        """Handle MiniMax error by falling back to SAPI.
+
+        Args:
+            error_msg: Human-readable error description.
+            original_text: The text that was supposed to be spoken;
+                passed explicitly to avoid race conditions with
+                rapid successive speak() calls.
+        """
+        logger.error("TTSManager: MiniMax failed (%s), falling back to SAPI", error_msg)
+        self.fallback_triggered.emit(error_msg)
+        sapi = self._providers.get("sapi")
+        if sapi is not None and original_text:
+            logger.info("TTSManager: falling back to SAPI for message=%r", original_text[:50])
+            sapi.speak(original_text)

messageflight-0.2.4.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: messageflight
+Version: 0.2.4
+Summary: Let Windows notifications fly across your screen like a little plane.
+Project-URL: Homepage, https://github.com/wx528/MessageFlight
+Project-URL: Issues, https://github.com/wx528/MessageFlight/issues
+Author: MessageFlight Contributors
+License: MIT License
+        
+        Copyright (c) 2026 MessageFlight Contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Requires-Python: >=3.8
+Requires-Dist: pygame>=2.5.0
+Requires-Dist: pyqt6>=6.5.0
+Requires-Dist: pywin32>=227; sys_platform == 'win32'
+Requires-Dist: winsdk>=1.0.0b10
+Provides-Extra: dev
+Requires-Dist: mypy<1.15,>=1.8; extra == 'dev'
+Requires-Dist: pytest-qt>=4.0; extra == 'dev'
+Requires-Dist: pytest<9,>=7.0; extra == 'dev'
+Requires-Dist: types-pywin32>=311; (python_version >= '3.9') and extra == 'dev'
+Description-Content-Type: text/markdown
+
+# MessageFlight
+
+[中文](README.zh.md) | English | [日本語](README.ja.md) | [한국어](README.ko.md) | [Bahasa Indonesia](README.id.md) | [ไทย](README.th.md) | [Tiếng Việt](README.vi.md) | [Bahasa Melayu](README.ms.md)
+
+<p align="center">
+  <img src="https://img.shields.io/badge/Python-3.8%2B-3776AB?style=flat&logo=python&logoColor=white" alt="Python">
+  <img src="https://img.shields.io/badge/GUI-PyQt6-41CD52?style=flat" alt="PyQt6">
+  <img src="https://img.shields.io/badge/Platform-Windows%2010%2F11-0078D6?style=flat&logo=windows&logoColor=white" alt="Windows">
+  <a href="https://pypi.org/project/messageflight/"><img src="https://img.shields.io/pypi/v/messageflight?style=flat&logo=pypi&logoColor=white" alt="PyPI"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow?style=flat" alt="License"></a>
+  <a href="https://github.com/wx528/MessageFlight/actions/workflows/ci.yml"><img src="https://github.com/wx528/MessageFlight/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <br>
+  <img src="https://img.shields.io/badge/Languages-zh%20%7C%20en%20%7C%20ja%20%7C%20ko%20%7C%20id%20%7C%20th%20%7C%20vi%20%7C%20ms-8A2BE2?style=flat" alt="Languages">
+</p>
+
+Let Windows notifications fly across your screen like a little plane.
+
+## Screenshots
+
+| | | |
+|:---:|:---:|:---:|
+| ![Plane flying above a game window](screenshots/screen_top_on_game01.png) | ![Plane flying above a game window](screenshots/screen_top_on_game02.png) | ![Plane flying across the desktop](screenshots/screen_top_on_screen.png) |
+| ![Plane in cyber preset](screenshots/screen_other_color.png) | | |
+
+## Features
+
+- Animated plane overlay for real Windows notifications
+- System tray controls for pause, demo notification, do-not-disturb, settings, autostart, and quit
+- Lightweight UI languages: Chinese, English, Japanese, Korean, Indonesian, Thai, Vietnamese, and Malay
+- Custom colors, flight paths, and vehicle presets
+- Optional TTS support through SAPI or MiniMax
+
+## Quick Start
+
+Requires Windows 10/11 and Python 3.8+.
+
+```bash
+git clone https://github.com/wx528/MessageFlight.git
+cd MessageFlight
+python -m venv .venv
+.venv\Scripts\activate
+pip install .
+python message_flight.py
+```
+
+Using `uv`:
+
+```bash
+uv sync
+uv run python message_flight.py
+```
+
+[MIT License](LICENSE)

messageflight-0.2.4.dist-info/RECORD

@@ -0,0 +1,24 @@
+message_flight/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+message_flight/autostart.py,sha256=ugzxII8aih_kXl85d4fHvoZd6p0F1TNU4_sG3tCmzWw,1150
+message_flight/config.py,sha256=8pA-EEJpnV3wnbIt-G-XO8hTby1rwx7g8LrAJktcAAk,17287
+message_flight/demo_notifications.py,sha256=c_XqbRTZ37Ojej7obppyA-cB_RNYmLSndo9uEQhZxZs,350
+message_flight/flight_widget.py,sha256=SSHfs_8KFi-Lf-GKZz_AqEjTBiHDbQ3vFPs0Co9N-1w,19306
+message_flight/i18n.py,sha256=vxk8thbAPLXVyhZKFQvvdRteAL9dbkEVWwfXKpY6qws,18681
+message_flight/notification_queue.py,sha256=hqoJaAxmLNNJnK61HawblhSu0_PaOcKwT1ON83KiD3A,2315
+message_flight/notification_worker.py,sha256=xPEBVRiRBb9tx1ivfQbfJNtOFOzj3JxAuVbACOy40HI,3687
+message_flight/plane_banner.py,sha256=YrdwOi5Ymjl3VPO4CxG1a7ySOLpTQ5h6aqm5p1q7F9w,14369
+message_flight/preset_editor.py,sha256=az2JNA-LdeuXPBLE5B-MBeb2XVLqn52L53HKcIRQ-Cw,13239
+message_flight/settings_dialog.py,sha256=WyttfOB9CnP8saV-AfRtBOT0cugy8mFZMHaTG79MBh0,10600
+message_flight/tray_app.py,sha256=y89A5Wm0IqtlPyGpR-U62PJh3mUnDeXvDDkqX05_MsQ,11116
+message_flight/tts.py,sha256=A5vU8A5e-bqXQbn90Lrm5jYH84ufGyhMFgoeYuXqt_Y,12248
+message_flight/tts_manager.py,sha256=UkUJ1xLHJeQbgMPRAz16UaJAAPmxULBuD7nVV-ZzwP4,4307
+message_flight/plane_presets/__init__.py,sha256=zQxkbsNgPTWICirpcYnqXz1Ad3D-FmyyktqWOhcaVE0,602
+message_flight/plane_presets/airplane.py,sha256=jhfoctq3GCW9FZzKkaQI6fCmd92Une1xbVaOr7ndOXA,4287
+message_flight/plane_presets/base.py,sha256=Lw6HeHIvwPitaG9mvQDQtzqkviTtSngPUA8hIIt5NHM,668
+message_flight/plane_presets/bird.py,sha256=gVvAjuwUk6BpV3unr9zjevV4-GfvPUm7SuHi-4fmniA,3287
+message_flight/plane_presets/rocket.py,sha256=HJ3PGbDjYZEUgquypx5jn9KngAsu2v8oUoMWwhpMXaI,3509
+message_flight/plane_presets/ufo.py,sha256=cDXYpy-QnNV2vw58j85LEFfd5_UAHWtgPQwfnbJyXPk,2676
+messageflight-0.2.4.dist-info/METADATA,sha256=sEpeAHBo7IrPFzP4Z7ayyHmdYotfzCvP9Cg4AnYn31Q,4324
+messageflight-0.2.4.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+messageflight-0.2.4.dist-info/licenses/LICENSE,sha256=B_KZ3UmKfNSncgBrsubFqqHRhWwFIPt2gunQzzoCLg0,1104
+messageflight-0.2.4.dist-info/RECORD,,

messageflight-0.2.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

messageflight-0.2.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MessageFlight Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.