piwave 2.0.8__py3-none-any.whl → 2.1.0__py3-none-any.whl

piwave/piwave.py

@@ -1,5 +1,6 @@
-# piwave/pw.py
-# pi_fm_rds is required !!! Check https://github.com/ChristopheJacquet/PiFmRds
+# PiWave is available at https://piwave.xyz
+# Licensed under GPLv3.0, main GitHub repository at https://github.com/douxxtech/piwave/
+# piwave/piwave.py : main entry
 
 import os
 import subprocess
@@ -15,99 +16,8 @@ from pathlib import Path
 from urllib.parse import urlparse
 import atexit
 
-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',
-    }
-
-    ICONS = {
-        'success': 'OK',
-        'error': 'ERR',
-        'warning': 'WARN',
-        'info': 'INFO',
-        'client': 'CLIENT',
-        'server': 'SERVER',
-        'file': 'FILE',
-        'broadcast': 'BCAST',
-        'version': 'VER',
-        'update': 'UPD',
-    }
-
-    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')
+from .backends import discover_backends, backends, get_best_backend, search_backends, list_backends
+from .logger import Log
 
 class PiWaveError(Exception):
     pass
@@ -120,6 +30,8 @@ class PiWave:
                  pi: str = "FFFF", 
                  debug: bool = False,
                  silent: bool = False,
+                 loop: bool = False,
+                 backend: str = "auto",
                  on_track_change: Optional[Callable] = None,
                  on_error: Optional[Callable] = None):
         """Initialize PiWave FM transmitter.
@@ -136,6 +48,10 @@ class PiWave:
         :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 backend: Chose a specific backend to handle the broadcast (default: auto)
+        :type backend: str
         :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
@@ -152,29 +68,56 @@ class PiWave:
         self.ps = str(ps)[:8]
         self.rt = str(rt)[:64]
         self.pi = str(pi).upper()[:4]
+        self.loop = loop
         self.on_track_change = on_track_change
         self.on_error = on_error
         
         self.current_file: Optional[str] = None
         self.is_playing = False
         self.is_stopped = False
-        
         self.current_process: Optional[subprocess.Popen] = None
         self.playback_thread: Optional[threading.Thread] = None
         self.stop_event = threading.Event()
-        
         self.temp_dir = tempfile.mkdtemp(prefix="piwave_")
-
-        Log.config(silent=silent)
-        
-        self.pi_fm_rds_path = self._find_pi_fm_rds_path()
         
+        Log.config(silent=silent)
+
         self._validate_environment()
-        
         atexit.register(self.cleanup)
+        
+        discover_backends()
 
+        if backend == "auto":
+            backend_name = get_best_backend("file_broadcast", self.frequency)
+            if not backend_name:
+                available = list(backends.keys())
+                raise PiWaveError(f"No suitable backend found for {self.frequency}MHz. Available backends: {available}")
+        else:
+            if backend not in backends:
+                available = list(backends.keys())
+                raise PiWaveError(f"Backend '{backend}' not available. Available: {available}. Use 'python3 -m piwave search' to refresh.")
+            
+            # Validate that the chosen backend supports the frequency
+            backend_instance = backends[backend]()
+            min_freq, max_freq = backend_instance.frequency_range
+            if not (min_freq <= self.frequency <= max_freq):
+                raise PiWaveError(f"Backend '{backend}' doesn't support {self.frequency}MHz (supports {min_freq}-{max_freq}MHz)")
+            
+            backend_name = backend
+
+        self.backend_name = backend_name
+        self.backend = backends[backend_name](
+            frequency=self.frequency,
+            ps=self.ps,
+            rt=self.rt,
+            pi=self.pi
+        )
+
+        min_freq, max_freq = self.backend.frequency_range
+        rds_support = "with RDS" if self.backend.supports_rds else "no RDS"
+        Log.info(f"Using {self.backend.name} backend ({min_freq}-{max_freq}MHz, {rds_support})")
         
-        Log.info(f"PiWave initialized - Frequency: {frequency}MHz, PS: {ps}")
+        Log.info(f"PiWave initialized - Frequency: {frequency}MHz, PS: {ps}, Loop: {loop}")
 
     def _log_debug(self, message: str):
         if self.debug:
@@ -321,40 +264,48 @@ class PiWave:
             Log.error(f"Could not determine duration for {wav_file}")
             return False
 
-        cmd = [
-            'sudo', self.pi_fm_rds_path,
-            '-freq', str(self.frequency),
-            '-ps', self.ps,
-            '-rt', self.rt,
-            '-pi', self.pi,
-            '-audio', wav_file
-        ]
-
         try:
-            Log.broadcast_message(f"Playing {wav_file} (Duration: {duration:.1f}s) at {self.frequency}MHz")
-            self.current_process = subprocess.Popen(
-                cmd,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                preexec_fn=os.setsid
-            )
+            # 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)
 
             if self.on_track_change:
                 self.on_track_change(wav_file)
 
-            # 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
+            if self.loop:
+                while not self.stop_event.is_set():
+                    if self.stop_event.wait(timeout=0.1):
+                        self._stop_current_process()
+                        return False
+                    
+                    if self.current_process.poll() is not None:
+                        Log.error("Process ended unexpectedly while looping")
+                        return False
+            else:
+                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
+                    elapsed = time.time() - start_time
+                    if elapsed >= duration:
+                        self._stop_current_process()
+                        break
 
             return True
 
@@ -424,7 +375,8 @@ class PiWave:
         
         .. note::
            Files are automatically converted to WAV format if needed.
-           Only local files are supported.
+           Only local files are supported. If loop is enabled, the file will
+           repeat continuously until stop() is called.
         
         Example:
             >>> pw.play('song.mp3')
@@ -509,6 +461,8 @@ class PiWave:
                pi: Optional[str] = None,
                debug: Optional[bool] = None,
                silent: Optional[bool] = None,
+               loop: Optional[bool] = None,
+               backend: Optional[str] = None,
                on_track_change: Optional[Callable] = None,
                on_error: Optional[Callable] = None):
         """Update PiWave settings.
@@ -525,6 +479,10 @@ class PiWave:
         :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 backend: Backend used to broadcast
+        :type backend: Optional[str]
         :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
@@ -535,9 +493,38 @@ class PiWave:
         
         Example:
             >>> pw.update(frequency=101.5, ps="NewName")
-            >>> pw.update(rt="Updated radio text", debug=True)
+            >>> pw.update(rt="Updated radio text", debug=True, loop=True)
         """
         updated_settings = []
+
+        freq_to_use = frequency if frequency is not None else self.frequency
+
+        if backend is not None:
+            if backend == "auto":
+                backend_name = get_best_backend("file_broadcast", freq_to_use)
+                if not backend_name:
+                    available = list(backends.keys())
+                    raise PiWaveError(f"No suitable backend found for {freq_to_use}MHz. Available: {available}")
+            else:
+                if backend not in backends:
+                    available = list(backends.keys())
+                    raise PiWaveError(f"Backend '{backend}' not available. Available: {available}")
+                backend_name = backend
+
+            backend_instance = backends[backend_name](
+                frequency=freq_to_use,
+                ps=ps or self.ps,
+                rt=rt or self.rt,
+                pi=pi or self.pi
+            )
+
+            min_freq, max_freq = backend_instance.frequency_range
+            if not (min_freq <= freq_to_use <= max_freq):
+                raise PiWaveError(f"Backend '{backend_name}' doesn't support {freq_to_use}MHz (supports {min_freq}-{max_freq}MHz)")
+
+            self.backend_name = backend_name
+            self.backend = backend_instance
+            updated_settings.append(f"backend: {backend_name}")
         
         if frequency is not None:
             self.frequency = frequency
@@ -563,6 +550,10 @@ class PiWave:
             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")
@@ -591,6 +582,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.
 
@@ -602,22 +610,33 @@ class PiWave:
         - **is_playing** (bool): Whether playback is active
         - **frequency** (float): Current broadcast frequency
         - **current_file** (str|None): Path of currently playing file
+        - **current_backend** (str): Currently used backend
+        - **backend_frequency_range** (str): Frequency range supported by the backend
+        - **backend_supports_rds** (bool): Backend support of Radio Data System
+        - **avalible_backends** (list): List of avalible backends
         - **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"Current file: {status['current_file']}")
+            >>> print(f"Looping: {status['loop']}")
         """
         return {
             'is_playing': self.is_playing,
             'frequency': self.frequency,
             'current_file': self.current_file,
+            'current_backend': self.backend_name,
+            'backend_frequency_range': f"{self.backend.frequency_range[0]}-{self.backend.frequency_range[1]}MHz",
+            'backend_supports_rds': self.backend.supports_rds,
+            'available_backends': list(backends.keys()),
             'ps': self.ps,
             'rt': self.rt,
-            'pi': self.pi
+            'pi': self.pi,
+            'loop': self.loop
         }
 
     def cleanup(self):