piwave 2.1.3__py3-none-any.whl → 2.1.4__py3-none-any.whl

piwave/__main__.py

@@ -72,6 +72,7 @@ def main():
 
         args = parser.parse_args(sys.argv[2:])
 
+        pw = None
         try:
             pw = PiWave(
                 frequency=args.frequency,
@@ -92,9 +93,17 @@ def main():
             except KeyboardInterrupt:
                 pw.stop()
                 Log.info("Broadcast stopped")
+                raise
+
         except PiWaveError as e:
             Log.error(f"PiWaveError: {e}")
             sys.exit(1)
+        except Exception:
+            pass
+        finally:
+            if pw is not None:
+                pw.cleanup()
+
 
     else:
         Log.error(f"Unknown command: {cmd}")

piwave/backends/base.py

@@ -43,6 +43,11 @@ class Backend(ABC):
     @abstractmethod
     def supports_live_streaming(self):
         pass
+
+    @property
+    @abstractmethod
+    def supports_loop(self):
+        pass
     
     @property 
     def cache_file(self):
@@ -208,7 +213,7 @@ class Backend(ABC):
             return False
     
     @abstractmethod
-    def build_command(self, wav_file: str):
+    def build_command(self, wav_file: str, loop: bool):
         pass
 
     @abstractmethod
@@ -219,12 +224,12 @@ class Backend(ABC):
         min_freq, max_freq = self.frequency_range
         return min_freq <= self.frequency <= max_freq
     
-    def play_file(self, wav_file: str) -> subprocess.Popen:
+    def play_file(self, wav_file: str, loop: bool) -> subprocess.Popen:
         if not self.validate_settings():
             min_freq, max_freq = self.frequency_range
             raise BackendError(f"{self.name} supports {min_freq}-{max_freq}MHz, got {self.frequency}MHz")
             
-        cmd = self.build_command(wav_file)
+        cmd = self.build_command(wav_file, loop)
         self.current_process = subprocess.Popen(
             cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             preexec_fn=os.setsid

piwave/backends/fm_transmitter.py

@@ -23,13 +23,17 @@ class FmTransmitterBackend(Backend):
     def supports_live_streaming(self):
         return True
     
+    @property
+    def supports_loop(self):
+        return False
+    
     def _get_executable_name(self):
         return "fm_transmitter"
     
     def _get_search_paths(self):
         return ["/opt/PiWave/fm_transmitter", "/opt", "/usr/local/bin", "/usr/bin", "/bin", "/home"]
     
-    def build_command(self, wav_file: str):
+    def build_command(self, wav_file: str, loop: bool):
         return [
             'sudo', self.required_executable,
             '-f', str(self.frequency),

piwave/backends/pi_fm_rds.py

@@ -13,7 +13,7 @@ class PiFmRdsBackend(Backend):
     
     @property
     def frequency_range(self):
-        return (80.0, 108.0)  # standard fm band with a bit less bcs it still kinda works
+        return (76.0, 108.0)  # taken from pi_fm_rds.c
     
     @property
     def supports_rds(self):
@@ -23,13 +23,17 @@ class PiFmRdsBackend(Backend):
     def supports_live_streaming(self):
         return False
     
+    @property
+    def supports_loop(self):
+        return False
+    
     def _get_executable_name(self):
         return "pi_fm_rds"
     
     def _get_search_paths(self):
         return ["/opt/PiWave/PiFmRds", "/opt", "/usr/local/bin", "/usr/bin", "/bin", "/home"]
     
-    def build_command(self, wav_file: str) -> list:
+    def build_command(self, wav_file: str, loop: bool) -> list:
         cmd = [
             'sudo', self.required_executable,
             '-freq', str(self.frequency),

piwave/logger.py

@@ -1,99 +1,46 @@
 # PiWave is available at https://piwave.xyz
 # Licensed under GPLv3.0, main GitHub repository at https://github.com/douxxtech/piwave/
-# piwave/Logger.py : Main logging manager
+# piwave/Logger.py : Main logging manage
 
-import sys
-
-class Log:
-    COLORS = { # absolutely not taken from stackoverflow trust
-        'reset': '\033[0m',
-        'bold': '\033[1m',
-        'underline': '\033[4m',
-        'red': '\033[31m',
-        'green': '\033[32m',
-        'yellow': '\033[33m',
-        'blue': '\033[34m',
-        'magenta': '\033[35m',
-        'cyan': '\033[36m',
-        'white': '\033[37m',
-        'bright_red': '\033[91m',
-        'bright_green': '\033[92m',
-        'bright_yellow': '\033[93m',
-        'bright_blue': '\033[94m',
-        'bright_magenta': '\033[95m',
-        'bright_cyan': '\033[96m',
-        'bright_white': '\033[97m',
-    }
+from dlogger import DLogger
 
+class Logger(DLogger):
+    
     ICONS = {
         'success': 'OK',
         'error': 'ERR',
         'warning': 'WARN',
         'info': 'INFO',
-        'client': 'CLIENT',
-        'server': 'SERVER',
         'file': 'FILE',
-        'broadcast': 'BCAST',
-        'version': 'VER',
-        'update': 'UPD',
+        'broadcast': 'BCAST'
     }
-
+    
+    STYLES = {
+        'success': 'bright_green',
+        'error': 'bright_red',
+        'warning': 'bright_yellow',
+        'info': 'bright_cyan',
+        'file': 'yellow',
+        'broadcast': 'bright_magenta'
+    }
+    
     SILENT = False
-
-    @classmethod
-    def config(cls, silent: bool = False):
-        cls.SILENT = silent
-
-    @classmethod
-    def print(cls, message: str, style: str = '', icon: str = '', end: str = '\n'):
-
-        if cls.SILENT: return
-
-        color = cls.COLORS.get(style, '')
-        icon_char = cls.ICONS.get(icon, '')
-        if icon_char:
-            if color:
-                print(f"{color}[{icon_char}]\033[0m {message}", end=end)
-            else:
-                print(f"[{icon_char}] {message}", end=end)
-        else:
-            if color:
-                print(f"{color}{message}\033[0m", end=end)
-            else:
-                print(f"{message}", end=end)
-        sys.stdout.flush()
-
-    @classmethod
-    def header(cls, text: str):
-        cls.print(text, 'bright_blue', end='\n\n')
-        sys.stdout.flush()
-
-    @classmethod
-    def section(cls, text: str):
-        cls.print(f" {text} ", 'bright_blue', end='')
-        cls.print("─" * (len(text) + 2), 'blue', end='\n\n')
-        sys.stdout.flush()
-
-    @classmethod
-    def success(cls, message: str):
-        cls.print(message, 'bright_green', 'success')
-
-    @classmethod
-    def error(cls, message: str):
-        cls.print(message, 'bright_red', 'error')
-
-    @classmethod
-    def warning(cls, message: str):
-        cls.print(message, 'bright_yellow', 'warning')
-
-    @classmethod
-    def info(cls, message: str):
-        cls.print(message, 'bright_cyan', 'info')
-
-    @classmethod
-    def file_message(cls, message: str):
-        cls.print(message, 'yellow', 'file')
-
-    @classmethod
-    def broadcast_message(cls, message: str):
-        cls.print(message, 'bright_magenta', 'broadcast')
+    
+    def __init__(self):
+        # Initialize with prebuilt icons & styles and silent support.
+        
+        super().__init__(
+            icons=self.ICONS,
+            styles=self.STYLES
+        )
+    
+    @classmethod
+    def config(self, silent: bool = False):
+        self.SILENT = silent
+    
+    def print(self, message: str, style: str = '', icon: str = '', end: str = '\n'):
+        if self.SILENT:
+            return
+        super().print(message, style, icon, end)
+
+Log = Logger()

piwave/piwave.py

@@ -13,10 +13,8 @@ import shutil
 import queue
 from typing import Optional, Callable
 from pathlib import Path
-from urllib.parse import urlparse
-import atexit
 
-from .backends import discover_backends, backends, get_best_backend, search_backends, list_backends
+from .backends import discover_backends, backends, get_best_backend
 from .logger import Log
 
 class PiWaveError(Exception):
@@ -214,7 +212,7 @@ class PiWave:
         if self._is_wav_file(filepath):
             return filepath
         
-        Log.file_message(f"Converting {filepath} to WAV")
+        Log.file(f"Converting {filepath} to WAV")
         
         output_file = f"{os.path.splitext(filepath)[0]}_converted.wav"
         
@@ -267,35 +265,37 @@ class PiWave:
     def _play_file(self, wav_file: str) -> bool:
         if self.stop_event.is_set():
             return False
-
+        
         duration = self._get_file_duration(wav_file)
+
         if duration <= 0:
             Log.error(f"Could not determine duration for {wav_file}")
             return False
-
+        
         try:
             # update settings
             self.backend.frequency = self.frequency
             self.backend.ps = self.ps
             self.backend.rt = self.rt
             self.backend.pi = self.pi
-            
+
             # validate frequency
             min_freq, max_freq = self.backend.frequency_range
             if not (min_freq <= self.frequency <= max_freq):
                 raise PiWaveError(f"Current backend '{self.backend.name}' doesn't support {self.frequency}MHz (supports {min_freq}-{max_freq}MHz). Use update() to change backend or frequency.")
-            
-            
+
             loop_status = "looping" if self.loop else f"Duration: {duration:.1f}s"
             rds_info = f" (PS: {self.ps})" if self.backend.supports_rds and self.ps else ""
-            Log.broadcast_message(f"Playing {wav_file} ({loop_status}) at {self.frequency}MHz{rds_info}")
-            
-            self.current_process = self.backend.play_file(wav_file)
+            Log.broadcast(f"Playing {wav_file} ({loop_status}) at {self.frequency}MHz{rds_info}")
+
+            self.current_process = self.backend.play_file(wav_file, self.loop)
 
             if self.on_track_change:
                 self.on_track_change(wav_file)
 
-            if self.loop:
+            if self.loop and not self.backend.supports_loop:
+
+                # Only manually loop if the backend does not support it
                 while not self.stop_event.is_set():
                     if self.stop_event.wait(timeout=0.1):
                         self._stop_current_process()
@@ -304,26 +304,24 @@ class PiWave:
                     if self.current_process.poll() is not None:
                         Log.error("Process ended unexpectedly while looping")
                         return False
+                    
             else:
-                start_time = time.time()
-                while True:
+                # fi backend supports looping or we are not looping, just wait for the process to finish
+                while not self.stop_event.is_set():
                     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()
+                    if not self.loop and self.current_process.poll() is not None:
                         break
-
             return True
-
+        
         except Exception as e:
             Log.error(f"Error playing {wav_file}: {e}")
             if self.on_error:
                 self.on_error(e)
             self._stop_current_process()
             return False
+
         
     def _playback_worker_wrapper(self):
         # wrapper for non-blocking playback
@@ -397,7 +395,7 @@ class PiWave:
         consumer_thread.daemon = True
         consumer_thread.start()
         
-        Log.broadcast_message(f"Live streaming at {self.frequency}MHz ({sample_rate}Hz, {channels}ch)")
+        Log.broadcast(f"Live streaming at {self.frequency}MHz ({sample_rate}Hz, {channels}ch)")
         return True
     
     def _live_producer_worker(self, audio_source, chunk_size: int):
@@ -741,7 +739,7 @@ class PiWave:
             >>> pw.set_frequency(101.5)
         """
         self.frequency = frequency
-        Log.broadcast_message(f"Frequency changed to {frequency}MHz. Will update on next file's broadcast.")
+        Log.broadcast(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.
@@ -758,7 +756,7 @@ class PiWave:
         """
         self.loop = loop
         loop_status = "enabled" if loop else "disabled"
-        Log.broadcast_message(f"Looping {loop_status}. Will update on next file's broadcast.")
+        Log.broadcast(f"Looping {loop_status}. Will update on next file's broadcast.")
 
     def get_status(self) -> dict:
         """Get current status information.

{piwave-2.1.3.dist-info → piwave-2.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: piwave
-Version: 2.1.3
+Version: 2.1.4
 Summary: A python module to broadcast radio waves with your Raspberry Pi.
 Home-page: https://github.com/douxxtech/piwave
 Author: Douxx
@@ -18,6 +18,7 @@ Classifier: Operating System :: POSIX :: Linux
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: dlogger==1.0.1
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: pytest-cov>=2.0; extra == "dev"
@@ -614,6 +615,10 @@ class CustomBackend(Backend):
     @property
     def supports_rds(self):
         return True  # RDS capability
+
+    @property
+    def supports_loop(self):
+        return True  # loop support capability
     
     def _get_executable_name(self):
         return "my_transmitter"
@@ -621,10 +626,13 @@ class CustomBackend(Backend):
     def _get_search_paths(self):
         return ["/opt", "/usr/local/bin", "/usr/bin"]
     
-    def build_command(self, wav_file: str):
+    def build_command(self, wav_file: str, loop: bool):
         cmd = ['sudo', self.required_executable, '-f', str(self.frequency)]
         if self.supports_rds and self.ps:
             cmd.extend(['-ps', self.ps])
+
+        if self.supports_rds and loop:
+            cmd.extend(['-loop'])
         cmd.append(wav_file)
         return cmd
 ```

piwave-2.1.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+piwave/__init__.py,sha256=jz2r-qclltKTxJjlGnqhAwIlUgjvRTR31f4hjTHP5NA,230
+piwave/__main__.py,sha256=-Z3RI7TiicE5UwWc4dZaHX82-MpwVXWkfMZXOC457_Q,4089
+piwave/logger.py,sha256=ipWzdNcEYob0xjXP8bbTq9enA3nryU-GKzAOKayRqlg,1149
+piwave/piwave.py,sha256=LdBwjdP_MWC-FSacQYOUUHZUGEVk4wR8K5YmdkgJnzo,32434
+piwave/backends/__init__.py,sha256=DUbdyYf2V2XcDB05vmFWEkuJ292YTNiNJjzh1raJ5Cg,3756
+piwave/backends/base.py,sha256=ttpaxkE-x9l_rQROs3rkrz5qg8kpsIqbmMWyK90Xaf4,7775
+piwave/backends/fm_transmitter.py,sha256=JzO5AswPzuoLOkTPLQrFy8r3trQvxXZrDPIGsrPDtmI,1419
+piwave/backends/pi_fm_rds.py,sha256=GGcOeazzPBV0TF12EESaI_PldZyG_Jowh64cGMuF7R4,1475
+piwave-2.1.4.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+piwave-2.1.4.dist-info/METADATA,sha256=6Pi4mVKXh-mflSfrpNuF4FAHArI-pEKg7-QBw7arJq0,20819
+piwave-2.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+piwave-2.1.4.dist-info/top_level.txt,sha256=xUbZ7Rk6OymSdDxmb9bfO8N-avJ9VYxP41GnXfwKYi8,7
+piwave-2.1.4.dist-info/RECORD,,

piwave-2.1.3.dist-info/RECORD

@@ -1,13 +0,0 @@
-piwave/__init__.py,sha256=jz2r-qclltKTxJjlGnqhAwIlUgjvRTR31f4hjTHP5NA,230
-piwave/__main__.py,sha256=ygl6F8VmOZjsnnUbAbzLoA7_1qv18ruG6TW4EocSaQE,3927
-piwave/logger.py,sha256=lPG3cz3ByqC1p1UKpwlv3R9KgiAb0zzyu6c3bhTpST0,2766
-piwave/piwave.py,sha256=f3v0n3RBr7sxQ7D1jXunAmplxe0D-6_mdaDLJmGwVpM,32423
-piwave/backends/__init__.py,sha256=DUbdyYf2V2XcDB05vmFWEkuJ292YTNiNJjzh1raJ5Cg,3756
-piwave/backends/base.py,sha256=amjdR3pwx-0XN2ngpwfYNt74j5kWrW1cI0zMOTMU-q8,7668
-piwave/backends/fm_transmitter.py,sha256=6CuYpkCgb40PEpemMlbTkQ6Gq8qFe3C1TSSLLnwXXX4,1338
-piwave/backends/pi_fm_rds.py,sha256=l1y9JUKjw-d9lh9X7HLQNEwbNVO-whYlzaYnqEfRviI,1429
-piwave-2.1.3.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-piwave-2.1.3.dist-info/METADATA,sha256=opQ0LdqJda66i1iaOGccjdw0gdZT9b7CKwDC1Ym_xWM,20612
-piwave-2.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-piwave-2.1.3.dist-info/top_level.txt,sha256=xUbZ7Rk6OymSdDxmb9bfO8N-avJ9VYxP41GnXfwKYi8,7
-piwave-2.1.3.dist-info/RECORD,,