spectre-core 0.0.8__py3-none-any.whl → 0.0.9__py3-none-any.whl

spectre_core/plotting/panel_stack.py

@@ -15,7 +15,9 @@ from spectre_core.plotting.factory import get_panel
 from spectre_core.plotting.library.spectrogram.panel import Panel as SpectrogramPanel
 
 class PanelStack:
-    def __init__(self, time_type: str, figsize: Tuple[int, int] = (10, 10)):
+    def __init__(self, 
+                 time_type: str = "seconds", 
+                 figsize: Tuple[int, int] = (10, 10)):
         self._time_type = time_type
         self._figsize = figsize
         self._panels: List[BasePanel] = []

spectre_core/{watchdog → post_processing}/__init__.py

@@ -3,4 +3,4 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 # dynamically import all event handlers
-import spectre_core.watchdog.library
+import spectre_core.post_processing.library

spectre_core/post_processing/base.py

@@ -0,0 +1,132 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from logging import getLogger
+_LOGGER = getLogger(__name__)
+
+from queue import Queue
+from typing import Optional
+from abc import ABC, abstractmethod
+from math import floor
+
+from watchdog.events import (
+    FileSystemEventHandler, 
+    FileCreatedEvent, 
+)
+
+from spectre_core.chunks.factory import get_chunk_from_tag
+from spectre_core.file_handlers.configs import CaptureConfig
+from spectre_core.spectrograms.spectrogram import Spectrogram
+from spectre_core.spectrograms.transform import join_spectrograms
+from spectre_core.spectrograms.transform import (
+    time_average, 
+    frequency_average
+)
+
+
+class BaseEventHandler(ABC, FileSystemEventHandler):
+    def __init__(self, 
+                 tag: str):
+        self._tag = tag
+
+        self._Chunk = get_chunk_from_tag(tag)
+
+        self._capture_config = CaptureConfig(tag)
+
+        self._watch_extension = self._capture_config.get("watch_extension")
+        if self._watch_extension is None:
+            raise KeyError("The watch extension has not been specified in the capture config")
+
+        # attribute to store the next file to be processed 
+        # (specifically, the absolute file path of the file)
+        self._queued_file: Optional[str] = None
+
+        # spectrogram cache stores spectrograms in memory
+        # such that they can be periodically written to files
+        # according to the joining time.
+        self._spectrogram: Optional[Spectrogram] = None
+        
+
+
+    @abstractmethod
+    def process(self, 
+                absolute_file_path: str) -> None:
+        """Process the file stored at the input absolute file path.
+        
+        To be implemented by derived classes.
+        """
+
+
+    def on_created(self, 
+                   event: FileCreatedEvent):
+        """Process a newly created batch file, only once the next batch is created.
+        
+        Since we assume that the batches are non-overlapping in time, this guarantees
+        we avoid post processing a file while it is being written to. Files are processed
+        sequentially, in the order they are created.
+        """
+
+        # the 'src_path' attribute holds the absolute path of the newly created file
+        absolute_file_path = event.src_path
+        
+        # only 'notice' a file if it ends with the appropriate extension
+        # as defined in the capture config
+        if absolute_file_path.endswith(self._watch_extension):
+            _LOGGER.info(f"Noticed {absolute_file_path}")
+            
+            # If there exists a queued file, try and process it
+            if self._queued_file is not None:
+                try:
+                    self.process(self._queued_file)
+                except Exception:
+                    _LOGGER.error(f"An error has occured while processing {self._queued_file}",
+                                  exc_info=True)
+                     # flush any internally stored spectrogram on error to avoid lost data
+                    self._flush_spectrogram()
+                    # re-raise the exception to the main thread
+                    raise
+            
+            # Queue the current file for processing next
+            _LOGGER.info(f"Queueing {absolute_file_path} for post processing")
+            self._queued_file = absolute_file_path
+
+
+    def _average_in_time(self, 
+                         spectrogram: Spectrogram) -> Spectrogram:
+        _LOGGER.info("Averaging spectrogram in time")
+        requested_time_resolution = self._capture_config['time_resolution'] # [s]
+        if requested_time_resolution is None:
+            raise KeyError(f"Time resolution has not been specified in the capture config")
+        average_over = floor(requested_time_resolution/spectrogram.time_resolution) if requested_time_resolution > spectrogram.time_resolution else 1
+        return time_average(spectrogram, average_over)
+    
+    
+    def _average_in_frequency(self, 
+                              spectrogram: Spectrogram) -> Spectrogram:
+        _LOGGER.info("Averaging spectrogram in frequency")
+        frequency_resolution = self._capture_config['frequency_resolution'] # [Hz]
+        if frequency_resolution is None:
+            raise KeyError(f"Frequency resolution has not been specified in the capture config")
+        average_over = floor(frequency_resolution/spectrogram.frequency_resolution) if frequency_resolution > spectrogram.frequency_resolution else 1
+        return frequency_average(spectrogram, average_over)
+    
+
+    def _join_spectrogram(self, 
+                          spectrogram: Spectrogram) -> None:
+        _LOGGER.info("Joining spectrogram")
+        if self._spectrogram is None:
+            self._spectrogram = spectrogram
+        else:
+            self._spectrogram = join_spectrograms([self._spectrogram, spectrogram])
+
+        if self._spectrogram.time_range >= self._capture_config['joining_time']:
+            self._flush_spectrogram()
+    
+
+    def _flush_spectrogram(self) -> None:
+        if self._spectrogram:
+            _LOGGER.info(f"Flushing spectrogram to file with chunk start time {self._spectrogram.chunk_start_time}")
+            self._spectrogram.save()
+            _LOGGER.info("Flush successful, resetting spectrogram cache")
+            self._spectrogram = None # reset the cache

spectre_core/{watchdog → post_processing}/factory.py

@@ -2,17 +2,17 @@
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-from spectre_core.watchdog.event_handler_register import event_handler_map
-from spectre_core.watchdog.base import BaseEventHandler
+from spectre_core.post_processing.event_handler_register import event_handler_map
+from spectre_core.post_processing.base import BaseEventHandler
 from spectre_core.file_handlers.configs import CaptureConfig
 from spectre_core.exceptions import EventHandlerNotFoundError
 
 def get_event_handler(event_handler_key: str) -> BaseEventHandler:
-    # try and fetch the capture config mount
     EventHandler = event_handler_map.get(event_handler_key)
     if EventHandler is None:
         valid_event_handler_keys = list(event_handler_map.keys())
-        raise EventHandlerNotFoundError(f"No event handler found for the event handler key: {event_handler_key}. Please specify one of the following event handler keys {valid_event_handler_keys}")
+        raise EventHandlerNotFoundError((f"No event handler found for the event handler key '{event_handler_key}'. "
+                                         f"Please specify one of the following event handler keys: {valid_event_handler_keys}"))
     return EventHandler
 
 

spectre_core/{watchdog → post_processing}/library/fixed/event_handler.py

@@ -7,8 +7,8 @@ _LOGGER = getLogger(__name__)
 
 import os
 
-from spectre_core.watchdog.base import BaseEventHandler
-from spectre_core.watchdog.event_handler_register import register_event_handler
+from spectre_core.post_processing.base import BaseEventHandler
+from spectre_core.post_processing.event_handler_register import register_event_handler
 
 @register_event_handler("fixed")
 class EventHandler(BaseEventHandler):
@@ -16,20 +16,19 @@ class EventHandler(BaseEventHandler):
         super().__init__(*args, **kwargs)
 
 
-    def process(self, file_path: str):
-        _LOGGER.info(f"Processing: {file_path}")
-        file_name = os.path.basename(file_path)
-        chunk_start_time, _ = os.path.splitext(file_name)[0].split('_')
+    def process(self, 
+                absolute_file_path: str):
+        _LOGGER.info(f"Processing: {absolute_file_path}")
+        file_name = os.path.basename(absolute_file_path)
+        base_file_name, _ = os.path.splitext(file_name)
+        chunk_start_time, _ = base_file_name.split('_')
         chunk = self._Chunk(chunk_start_time, self._tag)
 
         _LOGGER.info("Creating spectrogram")
         spectrogram = chunk.build_spectrogram()
 
-        _LOGGER.info("Averaging spectrogram")
         spectrogram = self._average_in_time(spectrogram)
         spectrogram = self._average_in_frequency(spectrogram)
-
-        _LOGGER.info("Joining spectrogram")
         self._join_spectrogram(spectrogram)
 
         bin_chunk = chunk.get_file('bin')

spectre_core/{watchdog → post_processing}/library/sweep/event_handler.py

@@ -8,8 +8,8 @@ _LOGGER = getLogger(__name__)
 import os
 
 from spectre_core.chunks.base import BaseChunk
-from spectre_core.watchdog.base import BaseEventHandler
-from spectre_core.watchdog.event_handler_register import register_event_handler
+from spectre_core.post_processing.base import BaseEventHandler
+from spectre_core.post_processing.event_handler_register import register_event_handler
 
 @register_event_handler("sweep")
 class EventHandler(BaseEventHandler):
@@ -19,23 +19,22 @@ class EventHandler(BaseEventHandler):
         self.previous_chunk: BaseChunk = None # cache for previous chunk
         
 
-    def process(self, file_path: str):
-        _LOGGER.info(f"Processing: {file_path}")
-        file_name = os.path.basename(file_path)
-        chunk_start_time, _ = os.path.splitext(file_name)[0].split('_')
+    def process(self, 
+                absolute_file_path: str):
+        _LOGGER.info(f"Processing: {absolute_file_path}")
+        file_name = os.path.basename(absolute_file_path)
+        base_file_name, _ = os.path.splitext(file_name)
+        chunk_start_time, _ = base_file_name.split('_')
         chunk = self._Chunk(chunk_start_time, self._tag)
 
         _LOGGER.info("Creating spectrogram")
         spectrogram = chunk.build_spectrogram(previous_chunk = self.previous_chunk)
 
-        _LOGGER.info("Averaging spectrogram")
         spectrogram = self._average_in_time(spectrogram)
         spectrogram = self._average_in_frequency(spectrogram)
-
-        _LOGGER.info("Joining spectrogram")
         self._join_spectrogram(spectrogram)
 
-        # if the previous chunk has not yet been set, it means we were processing the first chunk
+        # if the previous chunk has not yet been set, it means we are processing the first chunk
         # so we don't need to handle the previous chunk
         if self.previous_chunk is None:
             # instead, only set it for the next time this method is called

spectre_core/post_processing/post_processor.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from logging import getLogger
+_LOGGER = getLogger(__name__)
+
+from watchdog.observers import Observer
+from watchdog.events import FileCreatedEvent
+
+from spectre_core.post_processing.factory import get_event_handler_from_tag
+from spectre_core.cfg import CHUNKS_DIR_PATH
+
+class PostProcessor:
+    def __init__(self, 
+                 tag: str):
+        
+        self._observer = Observer()
+
+        EventHandler = get_event_handler_from_tag(tag)
+        self._event_handler = EventHandler(tag)
+
+
+    def start(self):
+        """Start an observer to process newly created files in the chunks directory"""
+        self._observer.schedule(self._event_handler, 
+                                CHUNKS_DIR_PATH, 
+                                recursive=True,
+                                event_filter=[FileCreatedEvent])
+        
+        try:
+            _LOGGER.info("Starting the post processing thread...") 
+            self._observer.start()
+            self._observer.join()
+        except KeyboardInterrupt:
+            _LOGGER.warning(("Keyboard interrupt detected. Signalling "
+                             "the post processing thread to stop"))
+            self._observer.stop()
+            _LOGGER.warning(("Post processing thread has been successfully stopped"))
+

spectre_core/receivers/base.py

@@ -242,6 +242,7 @@ class SPECTREReceiver(BaseReceiver):
                 "hop": int, # STFFT window hops by so many samples
                 "chunk_key": str, # maps to the corresponding chunk class
                 "event_handler_key": str, # maps to the event handler used in post processing
+                "watch_extension": str, # event handlers watch for files with this extension
             },
             "sweep": {
                 "min_freq": float, # [Hz]
@@ -262,6 +263,7 @@ class SPECTREReceiver(BaseReceiver):
                 "hop": int, # keyword arguments for the scipy STFFT class
                 "chunk_key": str, # maps to the corresponding chunk class
                 "event_handler_key": str, # maps to the event handler used in post processing
+                "watch_extension": str, # event handlers watch for files with this extension
             }
         }
     
@@ -291,17 +293,18 @@ class SPECTREReceiver(BaseReceiver):
         window_size = capture_config["window_size"]
         hop = capture_config["hop"]
         chunk_key = capture_config["chunk_key"]
-        event_handler_key = capture_config[ "event_handler_key"]
+        event_handler_key = capture_config["event_handler_key"]
+        watch_extension = capture_config["watch_extension"]
 
         validators.center_freq_strictly_positive(min_freq)
         validators.center_freq_strictly_positive(max_freq)
         validators.samp_rate_strictly_positive(samp_rate)
         validators.bandwidth_strictly_positive(bandwidth)
         validators.nyquist_criterion(samp_rate, 
-                                              bandwidth)
+                                     bandwidth)
         validators.chunk_size_strictly_positive(chunk_size)
         validators.time_resolution(time_resolution, 
-                                             chunk_size) 
+                                   chunk_size) 
         validators.window(window_type, 
                           window_kwargs, 
                           window_size,
@@ -326,6 +329,8 @@ class SPECTREReceiver(BaseReceiver):
                                          samp_rate)
         validators.num_samples_per_step(samples_per_step, 
                                         window_size)
+        validators.watch_extension(watch_extension,
+                                   "bin")
 
         # if the api latency is defined, raise a warning if the step interval is of the same order
         api_latency = self.specifications.get("api_latency")
@@ -350,6 +355,7 @@ class SPECTREReceiver(BaseReceiver):
         hop = capture_config["hop"]
         chunk_key = capture_config["chunk_key"]
         event_handler_key = capture_config["event_handler_key"]
+        watch_extension = capture_config["watch_extension"]
 
         validators.center_freq_strictly_positive(center_freq)
         validators.samp_rate_strictly_positive(samp_rate)
@@ -369,7 +375,8 @@ class SPECTREReceiver(BaseReceiver):
                                      "fixed")
         validators.gain_is_negative(IF_gain)
         validators.gain_is_negative(RF_gain)
-    
+        validators.watch_extension(watch_extension,
+                                "bin")
 
 # parent class for shared methods and attributes of SDRPlay receivers
 class SDRPlayReceiver(SPECTREReceiver):

spectre_core/receivers/library/test/receiver.py

@@ -46,6 +46,7 @@ class Receiver(SPECTREReceiver):
                 "hop": int, # STFFT hop shifts window by so many samples
                 "chunk_key": str, # maps to the corresponding chunk class
                 "event_handler_key": str, # maps to the event handler used in post processing
+                "watch_extension": str # event handlers watch for files with this extension
             },
             "tagged-staircase": {
                 "samp_rate": int, # [Hz]
@@ -63,6 +64,7 @@ class Receiver(SPECTREReceiver):
                 "hop": int, # keyword arguments for scipy STFFT class
                 "chunk_key": str, # maps to the corresponding chunk class
                 "event_handler_key": str, # maps to the event handler used in post processing
+                "watch_extension": str # event handlers watch for files with this extension
             }
         }
     
@@ -93,27 +95,35 @@ class Receiver(SPECTREReceiver):
         event_handler_key = capture_config["event_handler_key"]
         time_resolution = capture_config["time_resolution"]
         frequency_resolution = capture_config["frequency_resolution"]
+        watch_extension = capture_config["watch_extension"]
 
         validators.samp_rate_strictly_positive(samp_rate)
         validators.chunk_size_strictly_positive(chunk_size)
         validators.time_resolution(time_resolution, chunk_size) 
         validators.window(window_type, 
-                                          {}, 
-                                          window_size,
-                                          chunk_size,
-                                          samp_rate)
+                          {}, 
+                          window_size,
+                          chunk_size,
+                          samp_rate)
         validators.hop(hop)
-        validators.chunk_key(chunk_key, "fixed")
-        validators.event_handler_key(event_handler_key, "fixed")
+        validators.chunk_key(chunk_key, 
+                             "fixed")
+        validators.event_handler_key(event_handler_key, 
+                                     "fixed")
+        validators.watch_extension(watch_extension, 
+                                   "bin")
 
         if samp_rate < self.specifications.get("samp_rate_lower_bound"):
-            raise ValueError(f"Sample rate must be greater than or equal to {self.specifications.get('samp_rate_lower_bound')}")
+            raise ValueError((f"Sample rate must be greater than or equal to "
+                              f"{self.specifications.get('samp_rate_lower_bound')}"))
 
         if time_resolution != 0:
-            raise ValueError(f"Time resolution must be zero. Received: {time_resolution}")
+            raise ValueError(f"Time resolution must be zero. "
+                             f"Got {time_resolution} [s]")
         
         if frequency_resolution != 0:
-            raise ValueError(f"Frequency resolution must be zero. Received {frequency_resolution}")
+            raise ValueError((f"Frequency resolution must be zero. "
+                              f"Got {frequency_resolution}"))
         
         # check that the sample rate is an integer multiple of the underlying signal frequency
         if samp_rate % frequency != 0:
@@ -121,22 +131,26 @@ class Receiver(SPECTREReceiver):
 
         a = samp_rate/frequency
         if a < 2:
-            raise ValueError(f"The ratio of sampling rate over frequency must be a natural number greater than two.  Received: {a}")
+            raise ValueError((f"The ratio of sampling rate over frequency must be a natural number greater than two. "
+                             f"Got {a}"))
         
         # ensuring the window type is rectangular
         if window_type != "boxcar":
-            raise ValueError(f"The window type must be \"boxcar\". Received: {window_type}")
+            raise ValueError((f"The window type must be 'boxcar'. "
+                              f"Got {window_type}"))
         
         # analytical requirement
         # if p is the number of sampled cycles, we can find that p = window_size / a
         # the number of sampled cycles must be a positive natural number.
         p = window_size / a
         if window_size % a != 0:
-            raise ValueError(f"The number of sampled cycles must be a positive natural number. Computed that p={p}")
+            raise ValueError((f"The number of sampled cycles must be a positive natural number. "
+                              f"Computed that p={p}"))
     
     
         if amplitude <= 0:
-            raise ValueError(f"The amplitude must be strictly positive. Received: {amplitude}")
+            raise ValueError((f"The amplitude must be strictly positive. "
+                              f"Got {amplitude}"))
     
 
     def __tagged_staircase_validator(self, capture_config: CaptureConfig) -> None:
@@ -153,26 +167,37 @@ class Receiver(SPECTREReceiver):
         chunk_key = capture_config["chunk_key"]
         event_handler_key = capture_config["event_handler_key"]
         time_resolution = capture_config["time_resolution"]
-
+        watch_extension = capture_config["watch_extension"]
+        
         validators.samp_rate_strictly_positive(samp_rate)
         validators.chunk_size_strictly_positive(chunk_size)
         validators.time_resolution(time_resolution, chunk_size)
-        validators.window(window_type, window_kwargs, window_size, chunk_size, samp_rate)
+        validators.window(window_type, 
+                          window_kwargs, 
+                          window_size, 
+                          chunk_size, 
+                          samp_rate)
         validators.hop(hop)
         validators.chunk_key(chunk_key, "sweep")
         validators.event_handler_key(event_handler_key, "sweep")
-
+        validators.watch_extension(watch_extension, 
+                                   "bin")
+        
         if freq_step != samp_rate:
             raise ValueError(f"The frequency step must be equal to the sampling rate")
         
         if min_samples_per_step <= 0:
-            raise ValueError(f"Minimum samples per step must be strictly positive. Received: {min_samples_per_step}")
+            raise ValueError((f"Minimum samples per step must be strictly positive. "
+                              f"Got {min_samples_per_step}"))
         
         if max_samples_per_step <= 0:
-            raise ValueError(f"Maximum samples per step must be strictly positive. Received: {max_samples_per_step}")
+            raise ValueError((f"Maximum samples per step must be strictly positive. "
+                              f"Got {max_samples_per_step}"))
         
         if step_increment <= 0:
-            raise ValueError(f"Step increment must be strictly positive. Received: {step_increment}")
+            raise ValueError((f"Step increment must be strictly positive. "
+                              f"Got {step_increment}"))
         
         if min_samples_per_step > max_samples_per_step:
-            raise ValueError(f"Minimum samples per step cannot be greater than the maximum samples per step. Received: {min_samples_per_step} > {max_samples_per_step}")
+            raise ValueError((f"Minimum samples per step cannot be greater than the maximum samples per step. "
+                              f"Got {min_samples_per_step}, which is greater than {max_samples_per_step}"))

spectre_core/receivers/validators.py

@@ -14,34 +14,39 @@ from scipy.signal import get_window
 def closed_upper_bound_RF_gain(RF_gain: float, 
                                RF_gain_upper_bound: float) -> None:
     if not (RF_gain <= RF_gain_upper_bound):
-        raise ValueError(f"RF gain must be strictly less than or equal to {RF_gain_upper_bound} [dB]. Got {RF_gain} [dB]")
+        raise ValueError((f"RF gain must be less than or equal to {RF_gain_upper_bound} [dB]. "
+                          f"Got {RF_gain} [dB]"))
 
 
 def closed_upper_bound_IF_gain(IF_gain: float, 
                                IF_gain_upper_bound: float) -> None:
     if not (IF_gain <= IF_gain_upper_bound):
-        raise ValueError(f"IF gain must be strictly less than or equal to {IF_gain_upper_bound} [dB]. Got {IF_gain} [dB]")
+        raise ValueError((f"IF gain must be less than or equal to {IF_gain_upper_bound} [dB]. "
+                          f"Got {IF_gain} [dB]"))
 
 
 def closed_confine_center_freq(center_freq: float, 
                                center_freq_lower_bound: float, 
                                center_freq_upper_bound: float) -> None:
     if not (center_freq_lower_bound <= center_freq <= center_freq_upper_bound):
-        raise ValueError(f"Center frequency must be between {center_freq_lower_bound*1e-3} [kHz] and {center_freq_upper_bound*1e-9} [GHz]. Received {center_freq*1e-6} [MHz]")
+        raise ValueError((f"Center frequency must be between {center_freq_lower_bound*1e-3} [kHz] and {center_freq_upper_bound*1e-9} [GHz]. "
+                          f"Got {center_freq*1e-6} [MHz]"))
     
 
 def closed_confine_samp_rate(samp_rate: int, 
                              samp_rate_lower_bound: int, 
                              samp_rate_upper_bound: int) -> None:
     if not (samp_rate_lower_bound <= samp_rate <= samp_rate_upper_bound):
-        raise ValueError(f"Sampling rate must be between {samp_rate_lower_bound*1e-6} [MHz] and {samp_rate_upper_bound*1e-6} [MHz]. Received {samp_rate*1e-6} [MHz]")
+        raise ValueError((f"Sampling rate must be between {samp_rate_lower_bound*1e-6} [MHz] and {samp_rate_upper_bound*1e-6} [MHz]. "
+                          f"Got {samp_rate*1e-6} [MHz]"))
     
 
 def closed_confine_bandwidth(bandwidth: float, 
                              bandwidth_lower_bound: float, 
                              bandwidth_upper_bound: float) -> None:
     if not (bandwidth_lower_bound <= bandwidth <= bandwidth_upper_bound):
-        raise ValueError(f"Bandwidth must be between {bandwidth_lower_bound*1e-3} [kHz] and {bandwidth_upper_bound*1e-6} [MHz]. Received {bandwidth*1e-6} [MHz]")
+        raise ValueError((f"Bandwidth must be between {bandwidth_lower_bound*1e-3} [kHz] and {bandwidth_upper_bound*1e-6} [MHz]. "
+                          f"Got {bandwidth*1e-6} [MHz]"))
     
     
 def is_power_of_two(n):
@@ -55,84 +60,103 @@ def window(window_type: str,
            samp_rate: float) -> None:
     
     if not is_power_of_two(window_size):
-        raise ValueError(f"Window size must be some power of two. Received: {window_size}")
+        raise ValueError((f"Window size must be some power of two. "
+                          f"Got {window_size} [samples]"))
     
-
-    if window_size*(1/samp_rate) > chunk_size:
-        raise ValueError("Windowing interval must be strictly less than the chunk size")
+    window_interval = window_size*(1/samp_rate)
+    if window_interval > chunk_size:
+        raise ValueError((f"The windowing interval must be strictly less than the chunk size. "
+                          f"Computed the windowing interval to be {window_interval} [s], "
+                          f"but the chunk size is {chunk_size} [s]"))
     
     try:
         window_params = (window_type, 
                          *window_kwargs.values())
         _ = get_window(window_params, window_size)
     except Exception as e:
-        raise Exception(f"An error has occurred while validating the window. Received: {str(e)}")
+        raise Exception((f"An error has occurred while validating the window. "
+                         f"Got {str(e)}"))
     
 
 def hop(hop: int):
     if hop < 0:
-        raise ValueError(f"\"hop\" must be strictly positive. Received: {hop_value}")
+        raise ValueError((f"Window hop must be strictly positive. "
+                          f"Got {hop} [samples]"))
     
     
 def center_freq_strictly_positive(center_freq: float):
     if center_freq <= 0:
-        raise ValueError(f"Center frequency must be strictly positive. Received: {center_freq*1e-6} [MHz]")
+        raise ValueError((f"Center frequency must be strictly positive. "
+                          f"Got {center_freq*1e-6} [MHz]"))
     
 
 def bandwidth_strictly_positive(bandwidth: float) -> None:
     if bandwidth < 0:
-        raise ValueError(f"Bandwidth must be non-negative. Received: {bandwidth*1e-6} [MHz]")
+        raise ValueError((f"Bandwidth must be non-negative. "
+                          f"Got {bandwidth*1e-6} [MHz]"))
     
 
 def nyquist_criterion(samp_rate: int, 
                       bandwidth: float) -> None:
     if samp_rate < bandwidth:
-        raise ValueError("Sample rate must be greater than or equal to the bandwidth")
+        raise ValueError((f"Sample rate must be greater than or equal to the bandwidth. "
+                          f"Got sample rate {samp_rate} [Hz], and bandwidth {bandwidth} [Hz]"))
     
 
 def samp_rate_strictly_positive(samp_rate: int) -> None:
-    if samp_rate < 0:
-        raise ValueError(f"Sample rate must be strictly positive. Received: {samp_rate} [Hz]")
+    if samp_rate <= 0:
+        raise ValueError((f"Sample rate must be strictly positive. "
+                          f"Got {samp_rate} [Hz]"))
     
 
 def chunk_size_strictly_positive(chunk_size: int) -> None:
     if chunk_size <= 0:
-        raise ValueError(f"Chunk size must be strictly positive. Received: {chunk_size} [s]")
+        raise ValueError((f"Chunk size must be strictly positive. "
+                          f"Got {chunk_size} [s]"))
     
 
 def time_resolution(time_resolution: float, 
                     chunk_size: int) -> None:
     if time_resolution < 0:
-        raise ValueError(f"Time resolution must be non-negative. Received: {time_resolution} [s]")
+        raise ValueError((f"Time resolution must be non-negative. "
+                          f"Got {time_resolution} [s]"))
     
     if time_resolution > chunk_size:
-        raise ValueError("Time resolution must be less than or equal to chunk size")
+        raise ValueError(f"Time resolution must be less than or equal to chunk size. "
+                         f"Got time resolution {time_resolution} [s], "
+                         f"and chunk size {chunk_size} [s]")
     
 
 def frequency_resolution(frequency_resolution: float,
                          bandwidth: float = None) -> None:
     if frequency_resolution < 0:
-        raise ValueError(f"Frequency resolution must be non-negative. Received {frequency_resolution} [Hz]")
+        raise ValueError((f"Frequency resolution must be non-negative. "
+                          f"Got {frequency_resolution} [Hz]"))
     
     if bandwidth is not None and frequency_resolution >= bandwidth:
-        raise ValueError(f"Frequency resolution must be less than the bandwidth. Received frequency resolution to be {frequency_resolution} [Hz], with bandwidth {bandwidth} [Hz]")
+        raise ValueError((f"Frequency resolution must be less than the bandwidth. "
+                          f"Got frequency resolution to be {frequency_resolution} [Hz], "
+                          f"with bandwidth {bandwidth} [Hz]"))
     
 
 def chunk_key(chunk_key: str, 
               expected_chunk_key: str) -> None:
     if chunk_key != expected_chunk_key:
-        raise ValueError(f"Expected \"{expected_chunk_key}\" for the chunk_key, received: {chunk_key}")
+        raise ValueError((f"Expected {expected_chunk_key} for the chunk key. "
+                          f"Got {chunk_key}"))
     
 
 def event_handler_key(event_handler_key: str, 
                       expected_event_handler_key: str) -> None:
     if event_handler_key != expected_event_handler_key:
-        raise ValueError(f"Expected \"{expected_event_handler_key}\" for the event_handler_key, received: {event_handler_key}")
+        raise ValueError((f"Expected {expected_event_handler_key} for the event handler key. "
+                          f"Got {event_handler_key}"))
     
 
 def gain_is_negative(gain: float) -> None:
     if gain > 0:
-        raise ValueError(f"Gain must be non-positive. Received {gain} [dB]")
+        raise ValueError(f"Gain must be non-positive. "
+                         f"Got {gain} [dB]")
     
 
 def _compute_num_steps_per_sweep(min_freq: float, 
@@ -151,7 +175,8 @@ def num_steps_per_sweep(min_freq: float,
                                                        samp_rate, 
                                                        freq_step)
     if num_steps_per_sweep <= 1:
-        raise ValueError(f"We need strictly greater than one sample per step. Computed: {num_steps_per_sweep}")
+        raise ValueError((f"We need strictly greater than one step per sweep. "
+                          f"Computed {num_steps_per_sweep} step per sweep"))
     
 
 def sweep_interval(min_freq: float, 
@@ -167,19 +192,25 @@ def sweep_interval(min_freq: float,
     num_samples_per_sweep = num_steps_per_sweep * samples_per_step
     sweep_interval = num_samples_per_sweep * 1/samp_rate
     if sweep_interval > chunk_size:
-        raise ValueError(f"Sweep interval must be less than the chunk size. Computed sweep interval: {sweep_interval} [s] is greater than the given chunk size {chunk_size} [s]")
+        raise ValueError((f"Sweep interval must be less than the chunk size. "
+                          f"The computed sweep interval is {sweep_interval} [s], "
+                          f"but the given chunk size is {chunk_size} [s]"))
     
 
 def num_samples_per_step(samples_per_step: int, 
                          window_size: int) -> None:
     if window_size >= samples_per_step:
-        raise ValueError(f"Window size must be strictly less than the number of samples per step. Received window size {window_size} [samples], which is more than or equal to the number of samples per step {samples_per_step}")
+        raise ValueError((f"Window size must be strictly less than the number of samples per step. "
+                          f"Got window size {window_size} [samples], which is more than or equal "
+                          f"to the number of samples per step {samples_per_step}"))
     
 
 def non_overlapping_steps(freq_step: float, 
                           samp_rate: int) -> None:
     if freq_step < samp_rate:
-        raise NotImplementedError(f"SPECTRE does not yet support spectral steps overlapping in frequency. Received frequency step {freq_step/1e6} [MHz] which is less than the sample rate {samp_rate/1e6} [MHz]")
+        raise NotImplementedError(f"SPECTRE does not yet support spectral steps overlapping in frequency. "
+                                  f"Got frequency step {freq_step/1e6} [MHz] which is less than the sample "
+                                  f"rate {samp_rate/1e6} [MHz]")
     
 
 def step_interval(samples_per_step: int, 
@@ -187,7 +218,14 @@ def step_interval(samples_per_step: int,
                   api_latency: float) -> None:
     step_interval = samples_per_step * 1/samp_rate # [s]
     if step_interval < api_latency:
-        warning_message = f"The computed step interval of {step_interval} [s] is of the order of empirically derived api latency {api_latency} [s]; you may experience undefined behaviour!"
+        warning_message = (f"The computed step interval of {step_interval} [s] is of the order of empirically "
+                           f"derived api latency {api_latency} [s]; you may experience undefined behaviour!")
         warnings.warn(warning_message)
         _LOGGER.warning(warning_message)
     
+
+def watch_extension(watch_extension: str,
+                    target_extension: str) -> None:
+    if watch_extension != target_extension:
+        raise ValueError((f"Expected {target_extension} for the watch extension. "
+                          f"Got {watch_extension}"))

spectre_core/web_fetch/callisto.py

@@ -94,7 +94,7 @@ def fetch_chunks(instrument_code: Optional[str],
         os.mkdir(temp_dir)
 
     if instrument_code not in CALLISTO_INSTRUMENT_CODES:
-        raise ValueError(f"No match found for \"{instrument_code}\". Expected one of {CALLISTO_INSTRUMENT_CODES}")
+        raise ValueError(f"No match found for '{instrument_code}'. Expected one of {CALLISTO_INSTRUMENT_CODES}")
 
     download_callisto_data(instrument_code, year, month, day)
     unzip_to_chunks()

{spectre_core-0.0.8.dist-info → spectre_core-0.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spectre-core
-Version: 0.0.8
+Version: 0.0.9
 Summary: The core Python package used by the spectre program. 
 Maintainer-email: Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{spectre_core-0.0.8.dist-info → spectre_core-0.0.9.dist-info}/RECORD

@@ -23,17 +23,26 @@ spectre_core/plotting/base.py,sha256=4HhPPP7BNe5_SUAl1Ee52_QP62Zzh3kmNJwLzCHKG3c
 spectre_core/plotting/factory.py,sha256=pYil7PbTs3e08ek6nq-y8mSEtNu7DI6uloiCwsuIoOw,940
 spectre_core/plotting/format.py,sha256=Et-uc4juDl_2spLRZOzqaUVBP8-J3LPnV5M6CllM74E,512
 spectre_core/plotting/panel_register.py,sha256=rsmG2hXnvVOy6vfWsEZlZQAXej7bRtqtvjnXObyUCg4,351
-spectre_core/plotting/panel_stack.py,sha256=PxtoXp9WzSe38gG6dILoM__X_BxwNdydXRpzs3knsF0,5191
+spectre_core/plotting/panel_stack.py,sha256=fB1kz9NgsnMl4l41cncNPaVmg5DtYRRvO4lhX8OLOOo,5239
 spectre_core/plotting/library/__init__.py,sha256=lQhj4kme2eKb-JSrHvLWkAjI7eVqexOxxUguo8LUXno,270
 spectre_core/plotting/library/frequency_cuts/panel.py,sha256=LtCWNad4Z1gxBOxi_Ni1d6KZxsgoR5Mbm2tWXN7VDqI,2772
 spectre_core/plotting/library/integral_over_frequency/panel.py,sha256=tvro2MCtY4Q0q7WdMUz9eW5Cvrweeqqse20q3x4D4fM,1274
 spectre_core/plotting/library/spectrogram/panel.py,sha256=CAaPz7sDYoWZ3-4Jb1kVRu9bvJYaBRiXvoMkV7QXWqk,3556
 spectre_core/plotting/library/time_cuts/panel.py,sha256=u9Sbnwy6ex61y5Jl-D77HlYvuuXdK8_YB-o2gCovCTY,2947
+spectre_core/post_processing/__init__.py,sha256=pRzy46C32j9sfQjbCJKuVw0tQjuOErfrievq2m1Vx8c,239
+spectre_core/post_processing/base.py,sha256=h0qtoigD6ZBkHm0_wV1lJX55AwppKC5htfXVWUWMMLQ,5403
+spectre_core/post_processing/event_handler_register.py,sha256=DwlkU92IFkZ1_qvGfhep_OfuqTOIR_efY5qFpn1perw,498
+spectre_core/post_processing/factory.py,sha256=7KZBysPymsYhpW4KI4H1jvjssmZY1mIvhkln91joeUM,1133
+spectre_core/post_processing/post_processor.py,sha256=dQX71pUh83i6mNedTk-EVAYnxjAUs6S2Q8HkCXkiwns,1428
+spectre_core/post_processing/library/__init__.py,sha256=vEwAnAV-sv7WcNYOdnjr1JVqZYr29Wr2cv01eoxwdmg,282
+spectre_core/post_processing/library/fixed/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spectre_core/post_processing/library/fixed/event_handler.py,sha256=wfOdahnY78Movu0ESbuUy-QmpBbXhNk6_DKzsXS9G0Y,1394
+spectre_core/post_processing/library/sweep/event_handler.py,sha256=ap7K8hOxgb8wsX9uJfEDW7lYXCyNKFlsva7vinW_6Ak,2194
 spectre_core/receivers/__init__.py,sha256=kKfhqrGs9sSPGLbrpTqScv816iPZOvT3ry3zSMcqLkM,227
-spectre_core/receivers/base.py,sha256=UW2L28juLWyzI6t6Ub6Ws-K4J9U4HT4JSgdVtuiYP8k,16012
+spectre_core/receivers/base.py,sha256=szW7BfJEQiZ7dEiD_Oyk2lG16Kns3zKmnl_lIqKHP1o,16478
 spectre_core/receivers/factory.py,sha256=aE-Yw_cnlkhRe5HxK0JqhDzd2AwZcKmB2QkAKwaq27Y,873
 spectre_core/receivers/receiver_register.py,sha256=xHcRnT-3NQxyIWL3nyT3P9qT14Wl5liM9HbflOvOUAM,617
-spectre_core/receivers/validators.py,sha256=aP8nbRWZxU5pOwBIXTojXuHd3i9yksHW_vIBn4cbKug,8481
+spectre_core/receivers/validators.py,sha256=ZWnFsZJsbHBB-ZIrp3WK8BPqb4ev7TYm6VPQPbljTE4,9965
 spectre_core/receivers/library/__init__.py,sha256=xmtF5p3_ZkGfso_pKnxSgUcXXFLEBwERGPq1Pek7cOU,274
 spectre_core/receivers/library/rsp1a/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 spectre_core/receivers/library/rsp1a/receiver.py,sha256=xs_aNMhwIYD83KwutizjBziyu9XsfHqGqvQXOFcglz4,2224
@@ -48,7 +57,7 @@ spectre_core/receivers/library/rspduo/gr/tuner_1_sweep.py,sha256=gR5arbjvJBJjCdQ
 spectre_core/receivers/library/rspduo/gr/tuner_2_fixed.py,sha256=O86R3tuJ-7cZXfVECuZkds-wCxKdBKJ8MhVACJFgzeo,4130
 spectre_core/receivers/library/rspduo/gr/tuner_2_sweep.py,sha256=4JgJ2QRO5DFPfqUTHBojj8ERR_4QpHyTBqnAXhOzykE,4747
 spectre_core/receivers/library/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/receivers/library/test/receiver.py,sha256=ihfmUFFFEcyjMnMrqP4ajgB1mdC0vWEe9LFkNYHZn_Y,8346
+spectre_core/receivers/library/test/receiver.py,sha256=hr6t8jpUwVEP2zMpjORKpzqLaBllxmbqF1fQE1DLWQw,9329
 spectre_core/receivers/library/test/gr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 spectre_core/receivers/library/test/gr/cosine_signal_1.py,sha256=6XgYjYMh-QNPs_UUGUQcU_VQFr6BG4OLdsW-M-RU5Ww,2943
 spectre_core/receivers/library/test/gr/tagged_staircase.py,sha256=5rJHbB-3vdXjqT8DrcAGUSebaAqZ5RQtYHBWgH9iU2E,3465
@@ -57,18 +66,9 @@ spectre_core/spectrograms/analytical.py,sha256=c5X40YgLlutP8sbz6dqODZaCmZ98sAjub
 spectre_core/spectrograms/array_operations.py,sha256=6qKd3y2z6Pmu_U8yxTR4FN4eMhS10KgZ8rH60B_IXqw,2577
 spectre_core/spectrograms/spectrogram.py,sha256=EqeQyvjzjoKaXou4vJbPbRx85BeMPB9iiJtFZcCyimI,19488
 spectre_core/spectrograms/transform.py,sha256=xo7ch2lrRkJ54cfIqbkaTHNo_AptBuK0zRELPf7SfIE,13860
-spectre_core/watchdog/__init__.py,sha256=gGjyC7MeCfarB9Yu0RycZs-Wh_of7Cbp_wIyovYvtOQ,232
-spectre_core/watchdog/base.py,sha256=xDvWtt7fXeBQoZpR-ZxopAAKNHRa8YNSmfR63bYsSlU,4178
-spectre_core/watchdog/event_handler_register.py,sha256=DwlkU92IFkZ1_qvGfhep_OfuqTOIR_efY5qFpn1perw,498
-spectre_core/watchdog/factory.py,sha256=Uqx4nIZPVRxx7hRgm1M-1p2Sc7m3ObkIKWIC_ru9ObU,1115
-spectre_core/watchdog/post_processor.py,sha256=rZwe4u_T-7F7_q485PtUUZMAxPPec35zXV81MyERIjg,1673
-spectre_core/watchdog/library/__init__.py,sha256=vEwAnAV-sv7WcNYOdnjr1JVqZYr29Wr2cv01eoxwdmg,282
-spectre_core/watchdog/library/fixed/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/watchdog/library/fixed/event_handler.py,sha256=yWWS80LukB-cTrKBsF4-pRvw2obkX2MzQ5ZGytOtmAg,1387
-spectre_core/watchdog/library/sweep/event_handler.py,sha256=wDISZiQXBeqLDPxgEMo0a2QAXqQVOO7fng3yhZWSR74,2188
-spectre_core/web_fetch/callisto.py,sha256=874osjbp61qFwRgV584fpSp7E-xz8g1FEelbNBKhCsw,3632
-spectre_core-0.0.8.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-spectre_core-0.0.8.dist-info/METADATA,sha256=ltPXaVWUSk8ggdxRsRN9RLj3SIjRvNjGueNoIk3cst4,42150
-spectre_core-0.0.8.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-spectre_core-0.0.8.dist-info/top_level.txt,sha256=-UsyjpFohXgZpgcZ9QbVeXhsIyF3Am8RxNFNDV_Ta2Y,13
-spectre_core-0.0.8.dist-info/RECORD,,
+spectre_core/web_fetch/callisto.py,sha256=yW0NkmHqfUf2uYgJjSRxou6e65_mYciPhHwQIvKLK_w,3630
+spectre_core-0.0.9.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+spectre_core-0.0.9.dist-info/METADATA,sha256=15Uh828ojJg6w-HCrIv7nka9wT_eVhv9svE33hmHI7k,42150
+spectre_core-0.0.9.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+spectre_core-0.0.9.dist-info/top_level.txt,sha256=-UsyjpFohXgZpgcZ9QbVeXhsIyF3Am8RxNFNDV_Ta2Y,13
+spectre_core-0.0.9.dist-info/RECORD,,

spectre_core/watchdog/base.py

@@ -1,105 +0,0 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
-# This file is part of SPECTRE
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-from logging import getLogger
-_LOGGER = getLogger(__name__)
-
-import os
-import time
-from queue import Queue
-from typing import Any
-from abc import ABC, abstractmethod
-from math import floor
-
-from watchdog.events import FileSystemEventHandler
-
-from spectre_core.chunks.factory import get_chunk_from_tag
-from spectre_core.file_handlers.configs import CaptureConfig
-from spectre_core.spectrograms.spectrogram import Spectrogram
-from spectre_core.spectrograms.transform import join_spectrograms
-from spectre_core.spectrograms.transform import (
-    time_average, 
-    frequency_average
-)
-
-
-class BaseEventHandler(ABC, FileSystemEventHandler):
-    def __init__(self, 
-                 tag: str, 
-                 exception_queue: Queue, 
-                 extension: str):
-        self._tag = tag
-        self._Chunk = get_chunk_from_tag(tag)
-
-        self._capture_config = CaptureConfig(tag)
-
-        self._extension = extension
-        self._exception_queue = exception_queue  # Queue to propagate exceptions
-
-        self._spectrogram: Spectrogram = None # spectrogram cache
-
-
-    @abstractmethod
-    def process(self, file_path: str) -> None:
-        pass
-
-
-    def on_created(self, event):
-        if not event.is_directory and event.src_path.endswith(self._extension):
-            _LOGGER.info(f"Noticed: {event.src_path}")
-            try:
-                self._wait_until_stable(event.src_path)
-                self.process(event.src_path)
-            except Exception as e:
-                _LOGGER.error(f"An error has occured while processing {event.src_path}",
-                              exc_info=True)
-                self._flush_spectrogram() # flush the internally stored spectrogram
-                # Capture the exception and propagate it through the queue
-                self._exception_queue.put(e)
-
-
-    def _wait_until_stable(self, file_path: str):
-        _LOGGER.info(f"Waiting for file stability: {file_path}")
-        size = -1
-        while True:
-            current_size = os.path.getsize(file_path)
-            if current_size == size:
-                _LOGGER.info(f"File is now stable: {file_path}")
-                break  # File is stable when the size hasn't changed
-            size = current_size
-            time.sleep(0.25)
-
-
-    def _average_in_time(self, spectrogram: Spectrogram) -> Spectrogram:
-        requested_time_resolution = self._capture_config.get('time_resolution') # [s]
-        if requested_time_resolution is None:
-            raise KeyError(f"Time resolution has not been specified in the capture config!")
-        average_over = floor(requested_time_resolution/spectrogram.time_resolution) if requested_time_resolution > spectrogram.time_resolution else 1
-        return time_average(spectrogram, average_over)
-    
-    
-    def _average_in_frequency(self, spectrogram: Spectrogram) -> Spectrogram:
-        frequency_resolution = self._capture_config.get('frequency_resolution') # [Hz]
-        if frequency_resolution is None:
-            raise KeyError(f"Frequency resolution has not been specified in the capture config!")
-        average_over = floor(frequency_resolution/spectrogram.frequency_resolution) if frequency_resolution > spectrogram.frequency_resolution else 1
-        return frequency_average(spectrogram, average_over)
-    
-
-    def _join_spectrogram(self, spectrogram: Spectrogram) -> None:
-        if self._spectrogram is None:
-            self._spectrogram = spectrogram
-        else:
-            self._spectrogram = join_spectrograms([self._spectrogram, spectrogram])
-
-        if self._spectrogram.time_range >= self._capture_config.get("joining_time"):
-            self._flush_spectrogram()
-    
-
-    def _flush_spectrogram(self) -> None:
-        if self._spectrogram:
-            _LOGGER.info(f"Flushing spectrogram to file with chunk start time {self._spectrogram.chunk_start_time}")
-            self._spectrogram.save()
-            _LOGGER.info("Flush successful, resetting spectrogram cache")
-            self._spectrogram = None # reset the cache

spectre_core/watchdog/post_processor.py

@@ -1,50 +0,0 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
-# This file is part of SPECTRE
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-from logging import getLogger
-_LOGGER = getLogger(__name__)
-
-from queue import Queue, Empty
-
-from watchdog.observers import Observer
-
-from spectre_core.watchdog.factory import get_event_handler_from_tag
-from spectre_core.cfg import CHUNKS_DIR_PATH
-
-class PostProcessor:
-    def __init__(self, 
-                 tag: str):
-        self._observer: Observer = Observer()
-        self._exception_queue: Queue = Queue()  # A thread-safe queue for exceptions
-
-        EventHandler = get_event_handler_from_tag(tag)
-        self._event_handler = EventHandler(tag, 
-                                           self._exception_queue,
-                                           "bin")
-
-
-    def start(self):
-        _LOGGER.info("Starting post processor...")
-
-        # Schedule and start the observer
-        self._observer.schedule(self._event_handler, 
-                               CHUNKS_DIR_PATH, 
-                               recursive=True)
-        self._observer.start()
-
-        try:
-            # Monitor the observer and handle exceptions
-            while self._observer.is_alive():
-                try:
-                    exc = self._exception_queue.get(block=True, timeout=0.25)
-                    if exc:
-                        raise exc  # Propagate the exception
-                except Empty:
-                    pass  # Continue looping if no exception in queue
-        finally:
-            # Ensure the observer is properly stopped
-            self._observer.stop()
-            self._observer.join()
-
-