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

piwave/backends/__init__.py

@@ -21,13 +21,20 @@ def get_best_backend(mode: str, frequency: float):
                 return "pi_fm_rds"
             elif "fm_transmitter" in backends:
                 return "fm_transmitter"
-        
         else:
             if "fm_transmitter" in backends:
                 return "fm_transmitter"
             elif "pi_fm_rds" in backends:
                 return "pi_fm_rds"
     
+    elif mode == "live_broadcast":
+        if "fm_transmitter" in backends:
+            backend = backends["fm_transmitter"]()
+            min_freq, max_freq = backend.frequency_range
+            if min_freq <= frequency <= max_freq:
+                return "fm_transmitter"
+        
+        return None
     
     return None
 

piwave/backends/base.py

@@ -38,6 +38,11 @@ class Backend(ABC):
     @abstractmethod  
     def supports_rds(self):
         pass
+
+    @property
+    @abstractmethod
+    def supports_live_streaming(self):
+        pass
     
     @property 
     def cache_file(self):
@@ -205,6 +210,10 @@ class Backend(ABC):
     @abstractmethod
     def build_command(self, wav_file: str):
         pass
+
+    @abstractmethod
+    def build_live_command(self):
+        pass
     
     def validate_settings(self):
         min_freq, max_freq = self.frequency_range

piwave/backends/fm_transmitter.py

@@ -19,15 +19,26 @@ class FmTransmitterBackend(Backend):
     def supports_rds(self):
         return False
     
+    @property
+    def supports_live_streaming(self):
+        return True
+    
     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", "/home/pi"]
+        return ["/opt/PiWave/fm_transmitter", "/opt", "/usr/local/bin", "/usr/bin", "/bin", "/home"]
     
     def build_command(self, wav_file: str):
         return [
             'sudo', self.required_executable,
             '-f', str(self.frequency),
             wav_file
+        ]
+    
+    def build_live_command(self):
+        return [
+            'sudo', self.required_executable,
+            '-f', str(self.frequency),
+            '-'
         ]

piwave/backends/pi_fm_rds.py

@@ -19,6 +19,10 @@ class PiFmRdsBackend(Backend):
     def supports_rds(self):
         return True
     
+    @property
+    def supports_live_streaming(self):
+        return False
+    
     def _get_executable_name(self):
         return "pi_fm_rds"
     
@@ -40,3 +44,6 @@ class PiFmRdsBackend(Backend):
             cmd.extend(['-pi', self.pi])
             
         return cmd
+
+    def build_live_command(self):
+        return None # not supported sadly

piwave/piwave.py

@@ -10,7 +10,7 @@ import time
 
 import tempfile
 import shutil
-import sys
+import queue
 from typing import Optional, Callable
 from pathlib import Path
 from urllib.parse import urlparse
@@ -24,16 +24,17 @@ class PiWaveError(Exception):
 
 class PiWave:
     def __init__(self, 
-                 frequency: float = 90.0, 
-                 ps: str = "PiWave", 
-                 rt: str = "PiWave: The best python module for managing your pi radio", 
-                 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):
+                frequency: float = 90.0, 
+                ps: str = "PiWave", 
+                rt: str = "PiWave: The best python module for managing your pi radio", 
+                pi: str = "FFFF", 
+                debug: bool = False,
+                silent: bool = False,
+                loop: bool = False,
+                backend: str = "auto",
+                used_for: str = "file_broadcast",
+                on_track_change: Optional[Callable] = None,
+                on_error: Optional[Callable] = None):
         """Initialize PiWave FM transmitter.
 
         :param frequency: FM frequency to broadcast on (80.0-108.0 MHz)
@@ -50,7 +51,9 @@ class PiWave:
         :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)
+        :param backend: Chose a specific backend to handle the broadcast (default: auto). Supports `pi_fm_rds`, `fm_transmitter` and `auto`
+        :type backend: str
+        :param backend: Give the main use for the current instance, will be used if backend: auto (default: file_broadcast). Supports `file_broadcast` and `live_broadcast`
         :type backend: str
         :param on_track_change: Callback function called when track changes
         :type on_track_change: Optional[Callable]
@@ -59,7 +62,7 @@ class PiWave:
         :raises PiWaveError: If not running on Raspberry Pi or without root privileges
         
         .. note::
-           This class requires pi_fm_rds to be installed and accessible.
+           This class requires pi_fm_rds or fm_transmitter to be installed and accessible.
            Must be run on a Raspberry Pi with root privileges.
         """
         
@@ -79,6 +82,10 @@ class PiWave:
         self.playback_thread: Optional[threading.Thread] = None
         self.stop_event = threading.Event()
         self.temp_dir = tempfile.mkdtemp(prefix="piwave_")
+
+        self.is_live_streaming = False
+        self.live_thread: Optional[threading.Thread] = None
+        self.audio_queue: Optional[queue.Queue] = None
         
         Log.config(silent=silent)
 
@@ -87,11 +94,13 @@ class PiWave:
         
         discover_backends()
 
+        self.backend_use = used_for
+
         if backend == "auto":
-            backend_name = get_best_backend("file_broadcast", self.frequency)
+            backend_name = get_best_backend(self.backend_use, self.frequency)
             if not backend_name:
                 available = list(backends.keys())
-                raise PiWaveError(f"No suitable backend found for {self.frequency}MHz. Available backends: {available}")
+                raise PiWaveError(f"No suitable backend found for {self.frequency}MHz and {self.backend_use} mode. Available backends: {available}")
         else:
             if backend not in backends:
                 available = list(backends.keys())
@@ -113,6 +122,7 @@ class PiWave:
             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})")
@@ -255,7 +265,7 @@ class PiWave:
         except (subprocess.CalledProcessError, subprocess.TimeoutExpired, ValueError):
             return 0.0
 
-    def _play_wav(self, wav_file: str) -> bool:
+    def _play_file(self, wav_file: str) -> bool:
         if self.stop_event.is_set():
             return False
 
@@ -315,6 +325,141 @@ class PiWave:
                 self.on_error(e)
             self._stop_current_process()
             return False
+        
+    def _playback_worker_wrapper(self):
+        # wrapper for non-blocking playback
+        try:
+            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 os.path.exists(wav_file):
+                Log.error(f"File not found: {wav_file}")
+                self.is_playing = False
+                return
+
+            self._play_file(wav_file)
+        except Exception as e:
+            Log.error(f"Playback error: {e}")
+            if self.on_error:
+                self.on_error(e)
+        finally:
+            self.is_playing = False
+        
+
+    def _play_live(self, audio_source, sample_rate: int, channels: int, chunk_size: int) -> bool:
+        if self.is_playing or self.is_live_streaming:
+            self.stop()
+        
+        if not self.backend.supports_live_streaming:
+            raise PiWaveError(
+                f"Backend '{self.backend_name}' doesn't support live streaming. Try using fm_transmitter instead.")
+
+        
+        min_freq, max_freq = self.backend.frequency_range
+        if not (min_freq <= self.frequency <= max_freq):
+            raise PiWaveError(
+                f"Backend '{self.backend_name}' doesn't support {self.frequency}MHz"
+            )
+        
+        self.stop_event.clear()
+        self.is_live_streaming = True
+        self.audio_queue = queue.Queue(maxsize=20)
+        
+        try:
+            cmd = self.backend.build_live_command()
+            if not cmd:
+                raise PiWaveError(f"Backend doesn't support live streaming") # since we checked before, we shouldnt get this but meh
+            
+            self.current_process = subprocess.Popen(
+                cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                preexec_fn=os.setsid
+            )
+        except Exception as e:
+            Log.error(f"Failed to start live stream: {e}")
+            self.is_live_streaming = False
+            if self.on_error:
+                self.on_error(e)
+            return False
+        
+        self.live_thread = threading.Thread(
+            target=self._live_producer_worker,
+            args=(audio_source, chunk_size)
+        )
+        self.live_thread.daemon = True
+        self.live_thread.start()
+        
+        consumer_thread = threading.Thread(target=self._live_consumer_worker)
+        consumer_thread.daemon = True
+        consumer_thread.start()
+        
+        Log.broadcast_message(f"Live streaming at {self.frequency}MHz ({sample_rate}Hz, {channels}ch)")
+        return True
+    
+    def _live_producer_worker(self, audio_source, chunk_size: int):
+        # producer: reads from audio source, puts in queue; consumer will play it
+        try:
+            if hasattr(audio_source, '__iter__') and not isinstance(audio_source, (str, bytes)):
+                for chunk in audio_source:
+                    if self.stop_event.is_set():
+                        break
+                    if chunk:
+                        self.audio_queue.put(chunk, timeout=1)
+            
+            elif callable(audio_source):
+                while not self.stop_event.is_set():
+                    chunk = audio_source()
+                    if not chunk:
+                        break
+                    self.audio_queue.put(chunk, timeout=1)
+            
+            elif hasattr(audio_source, 'read'):
+                while not self.stop_event.is_set():
+                    chunk = audio_source.read(chunk_size)
+                    if not chunk:
+                        break
+                    self.audio_queue.put(chunk, timeout=1)
+            
+        except Exception as e:
+            Log.error(f"Producer error: {e}")
+            if self.on_error:
+                self.on_error(e)
+        finally:
+            self.audio_queue.put(None)
+
+    def _live_consumer_worker(self):
+        # consumer reads from queue and puts in process
+        try:
+            while not self.stop_event.is_set():
+                try:
+                    chunk = self.audio_queue.get(timeout=0.1)
+                    if chunk is None:
+                        break
+                    
+                    if self.current_process and self.current_process.stdin:
+                        self.current_process.stdin.write(chunk)
+                        self.current_process.stdin.flush()
+                    
+                except queue.Empty:
+                    continue
+                except BrokenPipeError:
+                    Log.error(f"Stream process terminated: make sure that the stream you provided compiles with {self.backend_name} stdin support.")
+                    break
+                except Exception as e:
+                    Log.error(f"Write error: {e}")
+                    break
+        finally:
+            if self.current_process and self.current_process.stdin:
+                try:
+                    self.current_process.stdin.close()
+                except:
+                    pass
+            self.is_live_streaming = False
 
 
     def _stop_current_process(self):
@@ -365,38 +510,45 @@ class PiWave:
         self.stop()
         os._exit(0)
 
-    def play(self, file_path: str) -> bool:
-        """Start playing the specified audio file.
-
-        :param file_path: Path to local audio file
-        :type file_path: str
-        :return: True if playback started successfully, False otherwise
-        :rtype: bool
+    def play(self, source, sample_rate: int = 44100, channels: int = 2, chunk_size: int = 4096, blocking: bool = False):
+        """Play audio from file or live source.
         
-        .. note::
-           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.
+        :param source: Either a file path (str) or live audio source (generator/callable/file-like)
+        :param sample_rate: Sample rate for live audio (ignored for files)
+        :param channels: Channels for live audio (ignored for files)
+        :param chunk_size: Chunk size for live audio (ignored for files)
+        :param blocking: If the playback should be blocking or not (ignored for live, always non-blocking)
+        :return: True if playback/streaming started successfully
+        :rtype: bool
         
         Example:
-            >>> pw.play('song.mp3')
-            >>> pw.play('audio.wav')
+            >>> pw.play('song.mp3')  # File playback
+            >>> pw.play(mic_generator())  # Live streaming
         """
+
+        # autodetect if source is live or file
+        if isinstance(source, str):
+            # file (string)
+            if blocking:
+                return self._play_file(source)
+            else:
+                if self.is_playing:
+                    self.stop()
+                
+                self.current_file = source
+                self.is_playing = True
+                self.stop_event.clear()
+                
+                self.playback_thread = threading.Thread(
+                    target=self._playback_worker_wrapper,
+                    daemon=True
+                )
+                self.playback_thread.start()
+                return True
         
-        if self.is_playing:
-            self.stop()
-        
-        self.current_file = file_path
-        self.stop_event.clear()
-        self.is_stopped = False
-        self.is_playing = True
-        
-        self.playback_thread = threading.Thread(target=self._playback_worker)
-        self.playback_thread.daemon = True
-        self.playback_thread.start()
-        
-        Log.success("Playback started")
-        return True
+        else:
+            # live
+            return self._play_live(source, sample_rate, channels, chunk_size)
 
     def stop(self):
         """Stop all playback and streaming.
@@ -407,14 +559,21 @@ class PiWave:
         Example:
             >>> pw.stop()
         """
-        if not self.is_playing:
+        if not self.is_playing and not self.is_live_streaming:
             return
         
-        Log.warning("Stopping playback...")
-
+        Log.warning("Stopping...")
+        
         self.is_stopped = True
         self.stop_event.set()
-
+        
+        if self.audio_queue:
+            while not self.audio_queue.empty():
+                try:
+                    self.audio_queue.get_nowait()
+                except queue.Empty:
+                    break
+        
         if self.current_process:
             try:
                 os.killpg(os.getpgid(self.current_process.pid), signal.SIGTERM)
@@ -423,12 +582,15 @@ class PiWave:
                 pass
             finally:
                 self.current_process = None
-
+        
         if self.playback_thread and self.playback_thread.is_alive():
             self.playback_thread.join(timeout=5)
-
+        if self.live_thread and self.live_thread.is_alive():
+            self.live_thread.join(timeout=3)
+        
         self.is_playing = False
-        Log.success("Playback stopped")
+        self.is_live_streaming = False
+        Log.success("Stopped")
 
     def pause(self):
         """Pause the current playback.
@@ -455,16 +617,17 @@ class PiWave:
             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,
-               backend: Optional[str] = None,
-               on_track_change: Optional[Callable] = None,
-               on_error: Optional[Callable] = None):
+                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,
+                backend: Optional[str] = None,
+                used_for: Optional[str] = None,
+                on_track_change: Optional[Callable] = None,
+                on_error: Optional[Callable] = None):
         """Update PiWave settings.
 
         :param frequency: FM frequency to broadcast on (80.0-108.0 MHz)
@@ -483,6 +646,8 @@ class PiWave:
         :type loop: Optional[bool]
         :param backend: Backend used to broadcast
         :type backend: Optional[str]
+        :param backend: Give the main use for the current instance, will be used if backend: auto. Supports `file_broadcast` and `live_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
@@ -499,9 +664,12 @@ class PiWave:
 
         freq_to_use = frequency if frequency is not None else self.frequency
 
+        if used_for is not None:
+            self.backend_use = used_for
+
         if backend is not None:
             if backend == "auto":
-                backend_name = get_best_backend("file_broadcast", freq_to_use)
+                backend_name = get_best_backend(self.backend_use, 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}")
@@ -608,6 +776,7 @@ class PiWave:
         The returned dictionary contains:
         
         - **is_playing** (bool): Whether playback is active
+        - **is_live_streaming** (bool): Whether live playback is active
         - **frequency** (float): Current broadcast frequency
         - **current_file** (str|None): Path of currently playing file
         - **current_backend** (str): Currently used backend
@@ -627,6 +796,7 @@ class PiWave:
         """
         return {
             'is_playing': self.is_playing,
+            'is_live_streaming': self.is_live_streaming,
             'frequency': self.frequency,
             'current_file': self.current_file,
             'current_backend': self.backend_name,

{piwave-2.1.0.dist-info → piwave-2.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: piwave
-Version: 2.1.0
+Version: 2.1.2
 Summary: A python module to broadcast radio waves with your Raspberry Pi.
 Home-page: https://github.com/douxxtech/piwave
 Author: Douxx
@@ -37,6 +37,7 @@ Dynamic: license-file
 - **Multi-Backend Architecture**: Supports multiple backends for different actions
 - **Wide Frequency Support**: 1-250 MHz coverage through different backends
 - **RDS Support**: Program Service, Radio Text, and Program Identifier broadcasting
+- **Live Stream Support**: Broadcast live from a stream source.
 - **Smart Backend Selection**: Automatically chooses the best backend to suit your needs
 - **Audio Format Support**: Converts most audio formats (MP3, FLAC, M4A, etc.) to WAV
 - **Real-time Settings Updates**: Change frequency, RDS data, and settings without restart
@@ -51,12 +52,14 @@ Dynamic: license-file
 ### PiFmRds Backend
 - **Frequency Range**: 80.0 - 108.0 MHz (Standard FM band)
 - **RDS Support**: ✅ Full support (PS, RT, PI)
+- **Live Support**: ❌ No live support
 - **Repository**: [ChristopheJacquet/PiFmRds](https://github.com/ChristopheJacquet/PiFmRds)
 - **Best For**: Standard FM broadcasting with RDS features
 
 ### FmTransmitter Backend  
 - **Frequency Range**: 1.0 - 250.0 MHz (Extended range)
 - **RDS Support**: ❌ No RDS support
+- **Live Support**: ✅ Experimental support
 - **Repository**: [markondej/fm_transmitter](https://github.com/markondej/fm_transmitter)
 - **Best For**: Non-standard frequencies and experimental broadcasting
 
@@ -141,42 +144,6 @@ curl -sL https://setup.piwave.xyz/uninstall | sudo bash
    make
    ```
 
-## Backend Management
-
-### CLI Commands
-
-```bash
-# Search for available backends on system
-python3 -m piwave search
-
-# List cached backends
-python3 -m piwave list
-
-# Manually add backend executable path
-python3 -m piwave add pi_fm_rds /path/to/pi_fm_rds
-
-# Show package information
-python3 -m piwave info
-
-# Broadcast a file directly
-python3 -m piwave broadcast song.mp3 --frequency 101.5 --ps "MyRadio"
-```
-
-### Programmatic Backend Discovery
-
-```python
-from piwave.backends import discover_backends, list_backends, search_backends
-
-# Load cached backends
-discover_backends()
-
-# Search for new backends (ignores cache)
-search_backends()
-
-# List available backends with details
-backends_info = list_backends()
-```
-
 ## Quick Start
 
 ### Basic Usage
@@ -256,6 +223,44 @@ print(f"Backend supports RDS: {status['backend_supports_rds']}")
 print(f"Frequency range: {status['backend_frequency_range']}")
 ```
 
+
+## Backend Management
+
+### CLI Commands
+
+```bash
+# Search for available backends on system
+python3 -m piwave search
+
+# List cached backends
+python3 -m piwave list
+
+# Manually add backend executable path
+python3 -m piwave add pi_fm_rds /path/to/pi_fm_rds
+
+# Show package information
+python3 -m piwave info
+
+# Broadcast a file directly
+python3 -m piwave broadcast song.mp3 --frequency 101.5 --ps "MyRadio"
+```
+
+### Programmatic Backend Discovery
+
+```python
+from piwave.backends import discover_backends, list_backends, search_backends
+
+# Load cached backends
+discover_backends()
+
+# Search for new backends (ignores cache)
+search_backends()
+
+# List available backends with details
+backends_info = list_backends()
+```
+
+
 ## Complete Examples
 
 <details>
@@ -443,16 +448,17 @@ if __name__ == "__main__":
 
 ```python
 PiWave(
-    frequency=90.0,           # Broadcast frequency (1.0-250.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
-    loop=False,              # Loop current track continuously
-    backend="auto",          # Backend selection ("auto", "pi_fm_rds", "fm_transmitter")
-    on_track_change=None,    # Callback for track changes
-    on_error=None            # Callback for errors
+    frequency=90.0,            # Broadcast frequency (1.0-250.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
+    loop=False,                # Loop current track continuously
+    backend="auto",            # Backend selection ("auto", "pi_fm_rds", "fm_transmitter")
+    used_for="file_broadcast", # Backend main purpose, used if backend = auto ("file_broadcast", "live_broadcast")
+    on_track_change=None,      # Callback for track changes
+    on_error=None              # Callback for errors
 )
 ```
 
@@ -495,6 +501,7 @@ status = pw.get_status()
 # Returns:
 {
     'is_playing': bool,
+    'is_live_streaming': bool,
     'frequency': float,
     'current_file': str|None,
     'current_backend': str,

piwave-2.1.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+piwave/__init__.py,sha256=jz2r-qclltKTxJjlGnqhAwIlUgjvRTR31f4hjTHP5NA,230
+piwave/__main__.py,sha256=ygl6F8VmOZjsnnUbAbzLoA7_1qv18ruG6TW4EocSaQE,3927
+piwave/logger.py,sha256=lPG3cz3ByqC1p1UKpwlv3R9KgiAb0zzyu6c3bhTpST0,2766
+piwave/piwave.py,sha256=7gowAQxWco-ZYtf5O-8x1un0lCK4BeSkz1-gjwLpQF4,32750
+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.2.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+piwave-2.1.2.dist-info/METADATA,sha256=xItxk81Sl2CLt2YIHw9kgG7Uv6oap_kqkQeDgReYnf0,20563
+piwave-2.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+piwave-2.1.2.dist-info/top_level.txt,sha256=xUbZ7Rk6OymSdDxmb9bfO8N-avJ9VYxP41GnXfwKYi8,7
+piwave-2.1.2.dist-info/RECORD,,

piwave-2.1.0.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=jmd10s2FUzL18GXjhyvIS6XwJl2K34G-xhMNHsvMKYk,25437
-piwave/backends/__init__.py,sha256=1lEfdEl-I9I4awRi0EHTVtRYAoSNC5T2zJhF0RS_xtA,3462
-piwave/backends/base.py,sha256=DGlDG9ybe6RNB7dUM7xedOD8DAo2e6nrtbS_LjnicAY,7513
-piwave/backends/fm_transmitter.py,sha256=Zj6NUKvDJ6yC6xEV67leusaNZAYo_FIFAvw7eVp2diw,1105
-piwave/backends/pi_fm_rds.py,sha256=TEHjn11GFIp4ZizEaD-0P3Cx_Agu7XFbyT6OxB1PpGk,1274
-piwave-2.1.0.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-piwave-2.1.0.dist-info/METADATA,sha256=HxoDpTSGbLXhQR86G9gFI-Ko1_QtP-V-4Zu3-Ahq08c,20247
-piwave-2.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-piwave-2.1.0.dist-info/top_level.txt,sha256=xUbZ7Rk6OymSdDxmb9bfO8N-avJ9VYxP41GnXfwKYi8,7
-piwave-2.1.0.dist-info/RECORD,,