piwave 2.0.7__py3-none-any.whl → 2.0.9__py3-none-any.whl

piwave/piwave.py

@@ -6,11 +6,11 @@ import subprocess
 import signal
 import threading
 import time
-import asyncio
+
 import tempfile
 import shutil
 import sys
-from typing import List, Optional, Callable
+from typing import Optional, Callable
 from pathlib import Path
 from urllib.parse import urlparse
 import atexit
@@ -118,9 +118,9 @@ class PiWave:
                  ps: str = "PiWave", 
                  rt: str = "PiWave: The best python module for managing your pi radio", 
                  pi: str = "FFFF", 
-                 loop: bool = False, 
                  debug: bool = False,
                  silent: bool = False,
+                 loop: bool = False,
                  on_track_change: Optional[Callable] = None,
                  on_error: Optional[Callable] = None):
         """Initialize PiWave FM transmitter.
@@ -133,12 +133,12 @@ class PiWave:
         :type rt: str
         :param pi: Program Identification code (4 hex digits)
         :type pi: str
-        :param loop: Whether to loop the playlist when it ends
-        :type loop: bool
         :param debug: Enable debug logging
         :type debug: bool
         :param silent: Removes every output log
         :type silent: bool
+        :param loop: Loop the current track continuously (default: False)
+        :type loop: bool
         :param on_track_change: Callback function called when track changes
         :type on_track_change: Optional[Callable]
         :param on_error: Callback function called when an error occurs
@@ -159,9 +159,7 @@ class PiWave:
         self.on_track_change = on_track_change
         self.on_error = on_error
         
-        self.playlist: List[str] = []
-        self.converted_files: dict[str, str] = {}
-        self.current_index = 0
+        self.current_file: Optional[str] = None
         self.is_playing = False
         self.is_stopped = False
         
@@ -170,7 +168,6 @@ class PiWave:
         self.stop_event = threading.Event()
         
         self.temp_dir = tempfile.mkdtemp(prefix="piwave_")
-        self.stream_process: Optional[subprocess.Popen] = None
 
         Log.config(silent=silent)
         
@@ -185,7 +182,7 @@ class PiWave:
 
     def _log_debug(self, message: str):
         if self.debug:
-            Log.print(f"[DEBUG] {message}", 'blue')
+            Log.print(f"[DEBUG] {message}", 'bright_cyan')
 
 
     def _validate_environment(self):
@@ -200,10 +197,10 @@ class PiWave:
 
     def _is_raspberry_pi(self) -> bool:
         try:
-            with open("/sys/firmware/devicetree/base/model", "r") as f:
-                model = f.read().strip()
-                return "Raspberry Pi" in model
-        except FileNotFoundError:
+            with open('/proc/cpuinfo', 'r') as f:
+                cpuinfo = f.read()
+            return 'raspberry' in cpuinfo.lower()
+        except:
             return False
 
     def _is_root(self) -> bool:
@@ -261,52 +258,17 @@ class PiWave:
         except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError):
             return False
 
-    def _is_url(self, path: str) -> bool:
-        parsed = urlparse(path)
-        return parsed.scheme in ('http', 'https', 'ftp')
-
     def _is_wav_file(self, filepath: str) -> bool:
         return filepath.lower().endswith('.wav')
 
-    async def _download_stream_chunk(self, url: str, output_file: str, duration: int = 30) -> bool:
-        #Download a chunk of stream for specified duration
-        try:
-            cmd = [
-                'ffmpeg', '-i', url, '-t', str(duration), 
-                '-acodec', 'pcm_s16le', '-ar', '44100', '-ac', '2',
-                '-y', output_file
-            ]
-            
-            process = await asyncio.create_subprocess_exec(
-                *cmd,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
-            )
-            
-            stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=duration + 10)
-            return process.returncode == 0
-            
-        except asyncio.TimeoutError:
-            Log.error(f"Timeout downloading stream chunk from {url}")
-            return False
-        except Exception as e:
-            Log.error(f"Error downloading stream: {e}")
-            return False
 
     def _convert_to_wav(self, filepath: str) -> Optional[str]:
-        if filepath in self.converted_files:
-            return self.converted_files[filepath]
-        
-        if self._is_wav_file(filepath) and not self._is_url(filepath):
-            self.converted_files[filepath] = filepath
+        if self._is_wav_file(filepath):
             return filepath
         
         Log.file_message(f"Converting {filepath} to WAV")
         
-        if self._is_url(filepath):
-            output_file = os.path.join(self.temp_dir, f"stream_{int(time.time())}.wav")
-        else:
-            output_file = f"{os.path.splitext(filepath)[0]}_converted.wav"
+        output_file = f"{os.path.splitext(filepath)[0]}_converted.wav"
         
         cmd = [
             'ffmpeg', '-i', filepath, '-acodec', 'pcm_s16le', 
@@ -314,7 +276,7 @@ class PiWave:
         ]
         
         try:
-            result = subprocess.run(
+            subprocess.run(
                 cmd,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
@@ -324,7 +286,6 @@ class PiWave:
             
             self._log_debug(f"FFmpeg conversion successful for {filepath}")
             
-            self.converted_files[filepath] = output_file
             return output_file
             
         except subprocess.TimeoutExpired:
@@ -374,7 +335,8 @@ class PiWave:
         ]
 
         try:
-            Log.broadcast_message(f"Playing {wav_file} (Duration: {duration:.1f}s) at {self.frequency}MHz")
+            loop_status = "looping" if self.loop else f"Duration: {duration:.1f}s"
+            Log.broadcast_message(f"Playing {wav_file} ({loop_status}) at {self.frequency}MHz")
             self.current_process = subprocess.Popen(
                 cmd,
                 stdout=subprocess.PIPE,
@@ -383,21 +345,32 @@ class PiWave:
             )
 
             if self.on_track_change:
-                self.on_track_change(wav_file, self.current_index)
-
-            # wait for either
-            # The duration to elapse (then kill the process), or
-            # stop_event to be set (user requested stop)
-            start_time = time.time()
-            while True:
-                if self.stop_event.wait(timeout=0.1):
-                    self._stop_current_process()
-                    return False
-
-                elapsed = time.time() - start_time
-                if elapsed >= duration:
-                    self._stop_current_process()
-                    break
+                self.on_track_change(wav_file)
+
+            if self.loop:
+                # if looping is enabled, let pi_fm_rds handle the looping
+                # and just wait for stop event
+                while not self.stop_event.is_set():
+                    if self.stop_event.wait(timeout=0.1):
+                        self._stop_current_process()
+                        return False
+                    
+                    # check if process exists cuz why not
+                    if self.current_process.poll() is not None:
+                        Log.error("Process ended unexpectedly while looping")
+                        return False
+            else:
+                # if not looping wait for stopevent or end of file
+                start_time = time.time()
+                while True:
+                    if self.stop_event.wait(timeout=0.1):
+                        self._stop_current_process()
+                        return False
+
+                    elapsed = time.time() - start_time
+                    if elapsed >= duration:
+                        self._stop_current_process()
+                        break
 
             return True
 
@@ -428,28 +401,25 @@ class PiWave:
     def _playback_worker(self):
         self._log_debug("Playback worker started")
 
-        while not self.stop_event.is_set() and not self.is_stopped:
-            if self.current_index >= len(self.playlist):
-                if self.loop:
-                    self.current_index = 0
-                    continue
-                else:
-                    break
-
-            if self.current_index < len(self.playlist):
-                wav_file = self.playlist[self.current_index]
+        if not self.current_file:
+            Log.error("No file specified for playback")
+            self.is_playing = False
+            return
 
-                if not os.path.exists(wav_file):
-                    Log.error(f"File not found: {wav_file}")
-                    self.current_index += 1
-                    continue
+        wav_file = self._convert_to_wav(self.current_file)
+        if not wav_file:
+            Log.error(f"Failed to convert {self.current_file}")
+            self.is_playing = False
+            return
 
-                if not self._play_wav(wav_file):
-                    if not self.stop_event.is_set():
-                        Log.error(f"Playback failed for {wav_file}")
-                    break
+        if not os.path.exists(wav_file):
+            Log.error(f"File not found: {wav_file}")
+            self.is_playing = False
+            return
 
-                self.current_index += 1
+        if not self._play_wav(wav_file):
+            if not self.stop_event.is_set():
+                Log.error(f"Playback failed for {wav_file}")
 
         self.is_playing = False
         self._log_debug("Playback worker finished")
@@ -460,70 +430,28 @@ class PiWave:
         self.stop()
         os._exit(0)
 
-    def add_files(self, files: List[str]) -> bool:
-        """Add audio files to the playlist.
-
-        :param files: List of file paths or URLs to add to the playlist
-        :type files: List[str]
-        :return: True if at least one file was successfully added, False otherwise
-        :rtype: bool
-        
-        .. note::
-           Files are automatically converted to WAV format if needed.
-           URLs are supported for streaming audio.
-        
-        Example:
-            >>> pw.add_files(['song1.mp3', 'song2.wav', 'http://stream.url'])
-        """
-
-        converted_files = []
-        
-        for file_path in files:
-            if self._is_url(file_path):
-                converted_files.append(file_path)
-            else:
-                wav_file = self._convert_to_wav(file_path)
-                if wav_file:
-                    converted_files.append(wav_file)
-                else:
-                    Log.warning(f"Failed to convert {file_path}")
-        
-        if converted_files:
-            self.playlist.extend(converted_files)
-            Log.success(f"Added {len(converted_files)} files to playlist")
-            return True
-        
-        return False
+    def play(self, file_path: str) -> bool:
+        """Start playing the specified audio file.
 
-    def play(self, files: Optional[List[str]] = None) -> bool:
-        """Start playing the playlist or specified files.
-
-        :param files: Optional list of files to play. If provided, replaces current playlist
-        :type files: Optional[List[str]]
+        :param file_path: Path to local audio file
+        :type file_path: str
         :return: True if playback started successfully, False otherwise
         :rtype: bool
         
         .. note::
-           If no files are specified, plays the current playlist.
-           Automatically stops any current playback before starting.
+           Files are automatically converted to WAV format if needed.
+           Only local files are supported. If loop is enabled, the file will
+           repeat continuously until stop() is called.
         
         Example:
-            >>> pw.play(['song1.mp3', 'song2.wav'])  # Play specific files
-            >>> pw.play()  # Play current playlist
+            >>> pw.play('song.mp3')
+            >>> pw.play('audio.wav')
         """
-        if files:
-            self.playlist.clear()
-            self.current_index = 0
-            if not self.add_files(files):
-                return False
-        
-        if not self.playlist:
-            Log.warning("No files in playlist")
-            return False
         
         if self.is_playing:
             self.stop()
         
+        self.current_file = file_path
         self.stop_event.clear()
         self.is_stopped = False
         self.is_playing = True
@@ -561,15 +489,6 @@ class PiWave:
             finally:
                 self.current_process = None
 
-        if self.stream_process:
-            try:
-                os.killpg(os.getpgid(self.stream_process.pid), signal.SIGTERM)
-                self.stream_process.wait(timeout=5)
-            except Exception:
-                pass
-            finally:
-                self.stream_process = None
-
         if self.playback_thread and self.playback_thread.is_alive():
             self.playback_thread.join(timeout=5)
 
@@ -579,7 +498,7 @@ class PiWave:
     def pause(self):
         """Pause the current playback.
 
-        Stops the current track but maintains the playlist position.
+        Stops the current track but maintains the file reference.
         Use :meth:`resume` to continue playback.
         
         Example:
@@ -590,40 +509,96 @@ class PiWave:
             Log.info("Playback paused")
 
     def resume(self):
-        """Resume playback from the current position.
+        """Resume playback from the current file.
 
-        Continues playback from where it was paused or stopped.
+        Continues playback of the current file.
         
         Example:
             >>> pw.resume()
         """
-        if not self.is_playing and self.playlist:
-            self.play()
+        if not self.is_playing and self.current_file:
+            self.play(self.current_file)
+
+    def update(self, 
+               frequency: Optional[float] = None,
+               ps: Optional[str] = None,
+               rt: Optional[str] = None,
+               pi: Optional[str] = None,
+               debug: Optional[bool] = None,
+               silent: Optional[bool] = None,
+               loop: Optional[bool] = None,
+               on_track_change: Optional[Callable] = None,
+               on_error: Optional[Callable] = None):
+        """Update PiWave settings.
 
-    def next_track(self):
-        """Skip to the next track in the playlist.
-
-        If currently playing, stops the current track and advances to the next one.
+        :param frequency: FM frequency to broadcast on (80.0-108.0 MHz)
+        :type frequency: Optional[float]
+        :param ps: Program Service name (max 8 characters)
+        :type ps: Optional[str]
+        :param rt: Radio Text message (max 64 characters)
+        :type rt: Optional[str]
+        :param pi: Program Identification code (4 hex digits)
+        :type pi: Optional[str]
+        :param debug: Enable debug logging
+        :type debug: Optional[bool]
+        :param silent: Remove every output log
+        :type silent: Optional[bool]
+        :param loop: Loop the current track continuously
+        :type loop: Optional[bool]
+        :param on_track_change: Callback function called when track changes
+        :type on_track_change: Optional[Callable]
+        :param on_error: Callback function called when an error occurs
+        :type on_error: Optional[Callable]
         
-        Example:
-            >>> pw.next_track()
-        """
-        if self.is_playing:
-            self._stop_current_process()
-            self.current_index += 1
-
-    def previous_track(self):
-        """Go back to the previous track in the playlist.
-
-        If currently playing, stops the current track and goes to the previous one.
-        Cannot go before the first track.
+        .. note::
+           Only non-None parameters will be updated. Changes take effect immediately, except for broadcast related changes, where you will have to start a new broadcast to apply them.
         
         Example:
-            >>> pw.previous_track()
+            >>> pw.update(frequency=101.5, ps="NewName")
+            >>> pw.update(rt="Updated radio text", debug=True, loop=True)
         """
-        if self.is_playing:
-            self._stop_current_process()
-            self.current_index = max(0, self.current_index - 1)
+        updated_settings = []
+        
+        if frequency is not None:
+            self.frequency = frequency
+            updated_settings.append(f"frequency: {frequency}MHz")
+        
+        if ps is not None:
+            self.ps = str(ps)[:8]
+            updated_settings.append(f"PS: {self.ps}")
+        
+        if rt is not None:
+            self.rt = str(rt)[:64]
+            updated_settings.append(f"RT: {self.rt}")
+        
+        if pi is not None:
+            self.pi = str(pi).upper()[:4]
+            updated_settings.append(f"PI: {self.pi}")
+        
+        if debug is not None:
+            self.debug = debug
+            updated_settings.append(f"debug: {debug}")
+        
+        if silent is not None:
+            Log.config(silent=silent)
+            updated_settings.append(f"silent: {silent}")
+        
+        if loop is not None:
+            self.loop = loop
+            updated_settings.append(f"loop: {loop}")
+        
+        if on_track_change is not None:
+            self.on_track_change = on_track_change
+            updated_settings.append("on_track_change callback updated")
+        
+        if on_error is not None:
+            self.on_error = on_error
+            updated_settings.append("on_error callback updated")
+        
+        if updated_settings:
+            Log.success(f"Updated settings: {', '.join(updated_settings)}")
+        else:
+            Log.info("No settings updated")
 
     def set_frequency(self, frequency: float):
         """Change the FM broadcast frequency.
@@ -632,7 +607,7 @@ class PiWave:
         :type frequency: float
         
         .. note::
-           The frequency change will take effect on the next track or broadcast.
+           The frequency change will take effect on the next broadcast.
         
         Example:
             >>> pw.set_frequency(101.5)
@@ -640,6 +615,23 @@ class PiWave:
         self.frequency = frequency
         Log.broadcast_message(f"Frequency changed to {frequency}MHz. Will update on next file's broadcast.")
 
+    def set_loop(self, loop: bool):
+        """Enable or disable looping for the current track.
+
+        :param loop: True to enable looping, False to disable
+        :type loop: bool
+        
+        .. note::
+           The loop setting will take effect on the next broadcast.
+        
+        Example:
+            >>> pw.set_loop(True)   # Enable looping
+            >>> pw.set_loop(False)  # Disable looping
+        """
+        self.loop = loop
+        loop_status = "enabled" if loop else "disabled"
+        Log.broadcast_message(f"Looping {loop_status}. Will update on next file's broadcast.")
+
     def get_status(self) -> dict:
         """Get current status information.
 
@@ -649,22 +641,27 @@ class PiWave:
         The returned dictionary contains:
         
         - **is_playing** (bool): Whether playback is active
-        - **current_index** (int): Current position in playlist
-        - **playlist_length** (int): Total number of items in playlist
         - **frequency** (float): Current broadcast frequency
         - **current_file** (str|None): Path of currently playing file
+        - **ps** (str): Program Service name
+        - **rt** (str): Radio Text message
+        - **pi** (str): Program Identification code
+        - **loop** (bool): Whether looping is enabled
         
         Example:
             >>> status = pw.get_status()
             >>> print(f"Playing: {status['is_playing']}")
-            >>> print(f"Track {status['current_index'] + 1} of {status['playlist_length']}")
+            >>> print(f"Current file: {status['current_file']}")
+            >>> print(f"Looping: {status['loop']}")
         """
         return {
             'is_playing': self.is_playing,
-            'current_index': self.current_index,
-            'playlist_length': len(self.playlist),
             'frequency': self.frequency,
-            'current_file': self.playlist[self.current_index] if self.current_index < len(self.playlist) else None
+            'current_file': self.current_file,
+            'ps': self.ps,
+            'rt': self.rt,
+            'pi': self.pi,
+            'loop': self.loop
         }
 
     def cleanup(self):
@@ -686,11 +683,11 @@ class PiWave:
     def __del__(self):
         self.cleanup()
 
-    def send(self, files: List[str]):
+    def send(self, file_path: str):
         """Alias for the play method.
 
-        :param files: List of file paths or URLs to play
-        :type files: List[str]
+        :param file_path: Path to local audio file
+        :type file_path: str
         :return: True if playback started successfully, False otherwise
         :rtype: bool
         
@@ -698,22 +695,9 @@ class PiWave:
            This is an alias for :meth:`play` for backward compatibility.
         
         Example:
-            >>> pw.send(['song1.mp3', 'song2.wav'])
-        """
-        return self.play(files)
-
-    def restart(self):
-        """Restart playback from the beginning of the playlist.
-
-        Resets the current position to the first track and starts playback.
-        Only works if there are files in the playlist.
-        
-        Example:
-            >>> pw.restart()
+            >>> pw.send('song.mp3')
         """
-        if self.playlist:
-            self.current_index = 0
-            self.play()
+        return self.play(file_path)
 
 if __name__ == "__main__":
     Log.header("PiWave Radio Module")

piwave-2.0.9.dist-info/METADATA

@@ -0,0 +1,419 @@
+Metadata-Version: 2.4
+Name: piwave
+Version: 2.0.9
+Summary: A python module to broadcast radio waves with your Raspberry Pi.
+Home-page: https://github.com/douxxtech/piwave
+Author: Douxx
+Author-email: douxx@douxx.tech
+License: GPL-3.0-or-later
+Project-URL: Bug Reports, https://github.com/douxxtech/piwave/issues
+Project-URL: Source, https://github.com/douxxtech/piwave
+Keywords: raspberry pi,radio,fm,rds,streaming,audio,broadcast
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.0; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Requires-Dist: flake8>=4.0; extra == "dev"
+Dynamic: license-file
+
+<div align=center>
+<img alt="PiWave image" src="https://piwave.xyz/static/img/logo.png"/>
+<h1>PiWave</h1>
+</div>
+
+**PiWave** is a Python module designed to manage and control your Raspberry Pi radio using the `pi_fm_rds` utility. It allows you to easily convert audio files to WAV format and broadcast them at a specified frequency with RDS (Radio Data System) support.
+
+## Features
+
+- Supports most audio file formats (MP3, FLAC, M4A, etc.)
+- Configurable broadcast frequency, PS (Program Service), RT (Radio Text), and PI (Program Identifier)
+- Real-time settings updates without restart
+- Detailed logging with debug mode
+- Error handling and event callbacks
+- Non-blocking playback with threading
+- Simple streaming-focused design
+
+## Hardware Installation
+
+To use PiWave for broadcasting, you need to set up the hardware correctly. This involves connecting an antenna or cable to the Raspberry Pi's GPIO pin.
+
+1. **Connect the Cable or Antenna**:
+   - Attach a cable or an antenna to GPIO 4 (Pin 7) on the Raspberry Pi.
+   - Ensure the connection is secure to avoid any broadcasting issues.
+
+2. **GPIO Pinout**:
+   - GPIO 4 (Pin 7) is used for the broadcasting signal.
+   - Ensure that the cable or antenna is properly connected to this pin for optimal performance.
+
+## Installation
+
+> [!WARNING]
+> **Warning**: Using PiWave involves broadcasting signals which may be subject to local regulations and laws. It is your responsibility to ensure that your use of PiWave complies with all applicable legal requirements and regulations in your area. Unauthorized use of broadcasting equipment may result in legal consequences, including fines or penalties.
+>
+> **Liability**: The author of PiWave is not responsible for any damage, loss, or legal issues that may arise from the use of this software. By using PiWave, you agree to accept all risks and liabilities associated with its operation and broadcasting capabilities.
+>
+> Please exercise caution and ensure you have the proper permissions and knowledge of the regulations before using PiWave for broadcasting purposes.
+
+### Auto Installer
+
+For a quick and easy installation, you can use the auto installer script. Open a terminal and run:
+
+```bash
+curl -sL https://setup.piwave.xyz/ | sudo bash
+```
+
+This command will download and execute the installation script, setting up PiWave and its dependencies automatically.
+
+> [!NOTE]
+> To uninstall, use the following command:
+> ```bash
+> curl -sL https://setup.piwave.xyz/uninstall | sudo bash
+> ```
+
+### Manual Installation
+
+To install PiWave manually, follow these steps:
+
+1. **Clone the repository and install**:
+
+   ```bash
+   pip install git+https://github.com/douxxtech/piwave.git
+   ```
+
+2. **Dependencies**:
+
+   PiWave requires the `ffmpeg` and `ffprobe` utilities for file conversion and duration extraction. Install them using:
+
+   ```bash
+   sudo apt-get install ffmpeg
+   ```
+
+3. **PiFmRds**:
+
+   PiWave uses [PiFmRds](https://github.com/ChristopheJacquet/PiFmRds) to work. Make sure you have installed it before running PiWave.
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from piwave import PiWave
+
+# Create PiWave instance
+pw = PiWave(
+    frequency=90.0,
+    ps="MyRadio",
+    rt="Playing great music",
+    pi="ABCD",
+    debug=True
+)
+
+# Play a single audio file
+pw.play("song.mp3")
+
+# Stop playback
+pw.stop()
+```
+
+### Real-time Settings Updates
+
+```python
+from piwave import PiWave
+
+pw = PiWave()
+
+# Update multiple settings at once
+pw.update(
+    frequency=101.5,
+    ps="NewName",
+    rt="Updated radio text",
+    debug=True
+)
+
+# Update individual settings
+pw.update(frequency=102.1)
+pw.update(ps="Radio2024")
+```
+
+### Control Playback
+
+```python
+from piwave import PiWave
+
+pw = PiWave(frequency=95.0)
+
+# Play, pause, resume
+pw.play("music.mp3")
+pw.pause()
+pw.resume()
+
+# Check status
+status = pw.get_status()
+print(f"Playing: {status['is_playing']}")
+print(f"Current file: {status['current_file']}")
+```
+
+## Examples
+
+### Text-to-Speech Radio
+
+```python
+from gtts import gTTS
+from piwave import PiWave
+from pydub import AudioSegment
+import os
+import sys
+import time
+
+wav_file = sys.argv[1] if len(sys.argv) > 1 else 'tts.wav'
+
+def tts(text, wav_file):
+    mp3_file = "tts.mp3"
+    tts = gTTS(text=text, lang="en", slow=False)
+    tts.save(mp3_file)
+    sound = AudioSegment.from_mp3(mp3_file)
+    sound.export(wav_file, format="wav")
+    os.remove(mp3_file)
+
+def main():
+    pw = None
+    
+    print("=" * 50)
+    print("Text Broadcast by https://douxx.tech")
+    print("""You need PiWave and a raspberry pi with root
+access to run this tool !""")
+    
+    try:
+        while True:
+            print("=" * 50)
+            text = input("Text to broadcast: ").strip()
+            if not text:
+                print("No text entered, skipping...\n")
+                continue
+
+            try:
+                freq = float(input("Frequency to broadcast (MHz): "))
+            except ValueError:
+                print("Invalid frequency, please enter a number.\n")
+                continue
+
+            tts(text, wav_file)
+            pw = PiWave(silent=True, frequency=freq)
+
+            print("=" * 50)
+            print("Ready to play!")
+            print(f"Frequency : {freq} MHz")
+            print(f"Text      : {text}")
+            print(f"WAV file  : {os.path.abspath(wav_file)}")
+            print("=" * 50)
+
+            pw.play(wav_file)
+            print("Playing! Press Ctrl+C to stop or wait for completion...\n")
+            
+            # Wait for playback to complete
+            while pw.get_status()['is_playing']:
+                time.sleep(0.5)
+            
+            print("Playback completed!\n")
+
+    except KeyboardInterrupt:
+        print("\nStopped by user.")
+    finally:
+        # Cleanup PiWave
+        if pw:
+            pw.stop()
+            pw.cleanup()
+        
+        # Remove temp file
+        if os.path.exists(wav_file):
+            os.remove(wav_file)
+        
+        print("Cleanup done. Exiting...")
+
+if __name__ == "__main__":
+    main()
+```
+
+### Music Player with Callbacks
+
+```python
+from piwave import PiWave
+import os
+import time
+
+def on_track_change(filename):
+    print(f"🎵 Now playing: {os.path.basename(filename)}")
+
+def on_error(error):
+    print(f"❌ Error occurred: {error}")
+
+def main():
+    # Create player with callbacks
+    pw = PiWave(
+        frequency=101.5,
+        ps="MyMusic",
+        rt="Your favorite tunes",
+        on_track_change=on_track_change,
+        on_error=on_error
+    )
+    
+    try:
+        # Play different formats
+        audio_files = ["song1.mp3", "song2.flac", "song3.m4a"]
+
+        for audio_file in audio_files:
+            if os.path.exists(audio_file):
+                print(f"Playing {audio_file}...")
+                pw.play(audio_file)
+                
+                # Wait for playback to complete
+                while pw.get_status()['is_playing']:
+                    time.sleep(0.5)
+                
+                print("Track completed. Press Enter for next song or Ctrl+C to quit...")
+                input()
+            else:
+                print(f"File {audio_file} not found, skipping...")
+
+        print("All tracks completed!")
+
+    except KeyboardInterrupt:
+        print("\nPlayback interrupted by user.")
+    finally:
+        # Cleanup
+        pw.stop()
+        pw.cleanup()
+        print("Cleanup completed.")
+
+if __name__ == "__main__":
+    main()
+```
+
+### Simple FM Transmitter
+
+```python
+from piwave import PiWave
+import os
+import time
+
+def simple_broadcast():
+    pw = None
+    
+    try:
+        # Initialize with custom settings
+        pw = PiWave(
+            frequency=88.5,
+            ps="Pi-FM",
+            rt="Broadcasting from Raspberry Pi",
+            pi="RAPI"
+        )
+        
+        audio_file = input("Enter audio file path: ")
+        
+        if not os.path.exists(audio_file):
+            print("File not found!")
+            return
+        
+        print(f"Broadcasting {audio_file} on 88.5 MHz")
+        print("Press Ctrl+C to stop...")
+        
+        pw.play(audio_file)
+        
+        # Keep program running and show status
+        while pw.get_status()['is_playing']:
+            time.sleep(1)
+        
+        print("\nPlayback completed!")
+            
+    except KeyboardInterrupt:
+        print("\nStopping broadcast...")
+    except Exception as e:
+        print(f"Error: {e}")
+    finally:
+        if pw:
+            pw.stop()
+            pw.cleanup()
+        print("Broadcast stopped and cleaned up.")
+
+if __name__ == "__main__":
+    simple_broadcast()
+```
+
+## API Reference
+
+### PiWave Class
+
+#### Initialization
+
+```python
+PiWave(
+    frequency=90.0,        # Broadcast frequency (80.0-108.0 MHz)
+    ps="PiWave",          # Program Service name (max 8 chars)
+    rt="PiWave: ...",     # Radio Text (max 64 chars)
+    pi="FFFF",            # Program Identifier (4 hex digits)
+    debug=False,          # Enable debug logging
+    silent=False,         # Disable all logging
+    on_track_change=None, # Callback for track changes
+    on_error=None         # Callback for errors
+)
+```
+
+#### Methods
+
+- **`play(file_path)`** - Play an audio file
+- **`stop()`** - Stop playback
+- **`pause()`** - Pause current playback
+- **`resume()`** - Resume playback
+- **`update(**kwargs)`** - Update any settings in real-time
+- **`set_frequency(freq)`** - Change broadcast frequency
+- **`get_status()`** - Get current player status
+- **`cleanup()`** - Clean up resources
+
+#### Properties
+
+Access current settings through `get_status()`:
+- `is_playing` - Whether audio is currently playing
+- `frequency` - Current broadcast frequency
+- `current_file` - Currently loaded file
+- `ps` - Program Service name
+- `rt` - Radio Text
+- `pi` - Program Identifier
+
+## Error Handling
+
+- **Raspberry Pi Check**: Verifies the program is running on a Raspberry Pi
+- **Root User Check**: Requires root privileges for GPIO access
+- **Executable Check**: Automatically finds `pi_fm_rds` or prompts for path
+- **File Validation**: Checks file existence and conversion capability
+- **Process Management**: Handles cleanup of broadcasting processes
+
+## Requirements
+
+- Raspberry Pi (any model with GPIO)
+- Root access (`sudo`)
+- Python 3.6+
+- FFmpeg for audio conversion
+- PiFmRds for FM transmission
+
+## License
+
+PiWave is licensed under the GNU General Public License (GPL) v3.0. See the [LICENSE](LICENSE) file for more details.
+
+## Contributing
+
+Contributions are welcome! Please submit a pull request or open an issue on [GitHub](https://github.com/douxxtech/piwave/issues) for any bugs or feature requests.
+
+---
+
+Thank you for using PiWave!
+
+![](https://madeby.douxx.tech)

piwave-2.0.9.dist-info/RECORD

@@ -0,0 +1,7 @@
+piwave/__init__.py,sha256=tAmruZvneieh6fgkf7chKzOX9Q6fEB-5Jt9FJ7Fl5xQ,74
+piwave/piwave.py,sha256=OSSQWrsm37eiyq4GBFkddZnY4qxTfqOmhm05ClIB7w4,24207
+piwave-2.0.9.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+piwave-2.0.9.dist-info/METADATA,sha256=BkYwSKDSJ0eWXxSWZvB3v_YU2HAZJXc3WIgabvyU5yM,11697
+piwave-2.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+piwave-2.0.9.dist-info/top_level.txt,sha256=xUbZ7Rk6OymSdDxmb9bfO8N-avJ9VYxP41GnXfwKYi8,7
+piwave-2.0.9.dist-info/RECORD,,

piwave-2.0.7.dist-info/METADATA

@@ -1,207 +0,0 @@
-Metadata-Version: 2.4
-Name: piwave
-Version: 2.0.7
-Summary: A python module to broadcast radio waves with your Raspberry Pi.
-Home-page: https://github.com/douxxtech/piwave
-Author: Douxx
-Author-email: douxx@douxx.tech
-License: GPL-3.0-or-later
-Project-URL: Bug Reports, https://github.com/douxxtech/piwave/issues
-Project-URL: Source, https://github.com/douxxtech/piwave
-Keywords: raspberry pi,radio,fm,rds,streaming,audio,broadcast
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Operating System :: POSIX :: Linux
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Provides-Extra: dev
-Requires-Dist: pytest>=6.0; extra == "dev"
-Requires-Dist: pytest-cov>=2.0; extra == "dev"
-Requires-Dist: black>=22.0; extra == "dev"
-Requires-Dist: flake8>=4.0; extra == "dev"
-Dynamic: license-file
-
-<div align=center>
-<img alt="PiWave image" src="https://piwave.xyz/static/img/logo.png"/>
-<h1>PiWave</h1>
-</div>
-
-**PiWave** is a Python module designed to manage and control your Raspberry Pi radio using the `pi_fm_rds` utility. It allows you to easily convert audio files to WAV format and broadcast them at a specified frequency with RDS (Radio Data System) support.
-
-## Features
-
-- Converts audio files to WAV format.
-- Broadcasts WAV files using the `pi_fm_rds` utility.
-- Configurable broadcast frequency, PS (Program Service), RT (Radio Text), and PI (Program Identifier).
-- Supports looping of playback.
-- Detailed logging for debug mode.
-- Supports streaming from URLs.
-- Better error handling and event callbacks.
-- Non-blocking playback with threading.
-
-## Hardware Installation
-
-To use PiWave for broadcasting, you need to set up the hardware correctly. This involves connecting an antenna or cable to the Raspberry Pi's GPIO pin.
-
-1. **Connect the Cable or Antenna**:
-   - Attach a cable or an antenna to GPIO 4 (Pin 7) on the Raspberry Pi.
-   - Ensure the connection is secure to avoid any broadcasting issues.
-
-2. **GPIO Pinout**:
-   - GPIO 4 (Pin 7) is used for the broadcasting signal.
-   - Ensure that the cable or antenna is properly connected to this pin for optimal performance.
-
-## Installation
-
-> [!WARNING]
-> **Warning**: Using PiWave involves broadcasting signals which may be subject to local regulations and laws. It is your responsibility to ensure that your use of PiWave complies with all applicable legal requirements and regulations in your area. Unauthorized use of broadcasting equipment may result in legal consequences, including fines or penalties.
->
-> **Liability**: The author of PiWave is not responsible for any damage, loss, or legal issues that may arise from the use of this software. By using PiWave, you agree to accept all risks and liabilities associated with its operation and broadcasting capabilities.
->
-> Please exercise caution and ensure you have the proper permissions and knowledge of the regulations before using PiWave for broadcasting purposes.
-
-### Auto Installer
-
-For a quick and easy installation, you can use the auto installer script. Open a terminal and run:
-
-```bash
-curl -sL https://setup.piwave.xyz/ | sudo bash
-```
-
-This command will download and execute the installation script, setting up PiWave and its dependencies automatically.
-
-> [!NOTE]
-> To uninstall, use the following command:
-> ```bash
-> curl -sL https://setup.piwave.xyz/uninstall | sudo bash
-> ```
-
-### Manual Installation
-
-To install PiWave manually, follow these steps:
-
-1. **Clone the repository and install**:
-
-   ```bash
-   pip install git+https://github.com/douxxtech/piwave.git --break-system-packages
-   ```
-
-2. **Dependencies**:
-
-   PiWave requires the `ffmpeg` and `ffprobe` utilities for file conversion and duration extraction. Install them using:
-
-   ```bash
-   sudo apt-get install ffmpeg
-   ```
-
-3. **PiFmRds**:
-
-   PiWave uses [PiFmRds](https://github.com/ChristopheJacquet/PiFmRds) to work. Make sure you have installed it before running PiWave.
-
-## Usage
-
-### Basic Usage
-
-1. **Importing the module**:
-
-   ```python
-   from piwave import PiWave
-   ```
-
-2. **Creating an instance**:
-
-   ```python
-   piwave = PiWave(
-       frequency=90.0,
-       ps="MyRadio",
-       rt="Playing great music",
-       pi="ABCD",
-       loop=True,
-       debug=True,
-       silent=False,
-       on_track_change=lambda file, index: print(f"Now playing: {file}"),
-       on_error=lambda error: print(f"Error occurred: {error}")
-   )
-   ```
-
-3. **Adding files to the playlist**:
-
-   ```python
-   files = ["path/to/your/audiofile.mp3", "http://example.com/stream.mp3"]
-   piwave.add_files(files)
-   ```
-
-4. **Starting playback**:
-
-   ```python
-   piwave.play() # or files = ["path/to/your/audiofile.mp3", "http://example.com/stream.mp3"]; piwave.play(files)
-   ```
-
-5. **Stopping playback**:
-
-   ```python
-   piwave.stop()
-   ```
-
-6. **Pausing and resuming playback**:
-
-   ```python
-   piwave.pause()
-   piwave.resume()
-   ```
-
-7. **Skipping tracks**:
-
-   ```python
-   piwave.next_track()
-   piwave.previous_track()
-   ```
-
-8. **Changing frequency**:
-
-   ```python
-   piwave.set_frequency(95.0)
-   ```
-
-9. **Getting status**:
-
-   ```python
-   status = piwave.get_status()
-   print(status)
-   ```
-
-### Configuration
-
-- `frequency`: The broadcast frequency in MHz (default: 90.0).
-- `ps`: Program Service name (up to 8 characters, default: "PiWave").
-- `rt`: Radio Text (up to 64 characters, default: "PiWave: The best python module for managing your pi radio").
-- `pi`: Program Identifier (up to 4 characters, default: "FFFF").
-- `loop`: Whether to loop playback of files (default: False).
-- `debug`: Enable detailed debug logging (default: False).
-- `silent`: Disables every log output (default: False).
-- `on_track_change`: Callback function when the track changes (default: None).
-- `on_error`: Callback function when an error occurs (default: None).
-
-## Error Handling
-
-- **Raspberry Pi Check**: The program verifies if it is running on a Raspberry Pi. It exits with an error message if not.
-- **Root User Check**: The program requires root privileges to run. It exits with an error message if not run as root.
-- **Executable Check**: The program automatically finds the `pi_fm_rds` executable or prompts the user to manually provide its path if it cannot be found.
-
-## License
-
-PiWave is licensed under the GNU General Public License (GPL) v3.0. See the [LICENSE](LICENSE) file for more details.
-
-## Contributing
-
-Contributions are welcome! Please submit a pull request or open an issue on [GitHub](https://github.com/douxxtech/piwave/issues) for any bugs or feature requests.
-
----
-
-Thank you for using PiWave!
-
-Made with <3 by Douxx

piwave-2.0.7.dist-info/RECORD

@@ -1,7 +0,0 @@
-piwave/__init__.py,sha256=tAmruZvneieh6fgkf7chKzOX9Q6fEB-5Jt9FJ7Fl5xQ,74
-piwave/piwave.py,sha256=GkhNuw_mZnEZbUf6AC4mx4QwYpeFsSDpj1RqXUTf3Ms,24613
-piwave-2.0.7.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-piwave-2.0.7.dist-info/METADATA,sha256=7I5mVMuiAcAzklTaum2d7CqL_V4Z-urMPc6Vcgv4Cno,6845
-piwave-2.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-piwave-2.0.7.dist-info/top_level.txt,sha256=xUbZ7Rk6OymSdDxmb9bfO8N-avJ9VYxP41GnXfwKYi8,7
-piwave-2.0.7.dist-info/RECORD,,