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

spectre_core/receivers/library/rspduo/receiver.py

@@ -4,7 +4,12 @@
 
 from spectre_core.receivers.base import SDRPlayReceiver
 from spectre_core.receivers.receiver_register import register_receiver
-from spectre_core.receivers.library.rspduo.gr import tuner_1_fixed, tuner_1_sweep
+from spectre_core.receivers.library.rspduo.gr import (
+    tuner_1_fixed, 
+    tuner_1_sweep,
+    tuner_2_fixed,
+    tuner_2_sweep
+)
 from spectre_core.file_handlers.configs import CaptureConfig
 
 
@@ -17,14 +22,18 @@ class Receiver(SDRPlayReceiver):
     def _set_capture_methods(self) -> None:
         self._capture_methods = {
             "tuner-1-fixed": self.__tuner_1_fixed,
-            "tuner-1-sweep": self.__tuner_1_sweep
+            "tuner-1-sweep": self.__tuner_1_sweep,
+            "tuner-2-fixed": self.__tuner_2_fixed,
+            "tuner-2-sweep": self.__tuner_2_sweep
         }
     
 
     def _set_validators(self) -> None:
         self._validators = {
             "tuner-1-fixed": self.__tuner_1_fixed_validator,
-            "tuner-1-sweep": self.__tuner_1_sweep_validator
+            "tuner-1-sweep": self.__tuner_1_sweep_validator,
+            "tuner-2-fixed": self.__tuner_2_fixed_validator,
+            "tuner-2-sweep": self.__tuner_2_sweep_validator,
         }
         return
     
@@ -33,6 +42,8 @@ class Receiver(SDRPlayReceiver):
         self._type_templates = {
             "tuner-1-fixed": self._get_default_type_template("fixed"),
             "tuner-1-sweep": self._get_default_type_template("sweep"),
+            "tuner-2-fixed": self._get_default_type_template("fixed"),
+            "tuner-2-sweep": self._get_default_type_template("sweep"),
         }
 
     def _set_specifications(self) -> None:
@@ -55,14 +66,32 @@ class Receiver(SDRPlayReceiver):
 
     def __tuner_1_sweep(self, capture_config: CaptureConfig) -> None:
         tuner_1_sweep.main(capture_config)
+
+    
+    def __tuner_2_fixed(self, capture_config: CaptureConfig) -> None:
+        tuner_2_fixed.main(capture_config)
     
 
+    def __tuner_2_sweep(self, capture_config: CaptureConfig) -> None:
+        tuner_2_sweep.main(capture_config)
+
+
     def __tuner_1_fixed_validator(self, capture_config: CaptureConfig) -> None:
         self._default_fixed_validator(capture_config)
         self._sdrplay_validator(capture_config)
-    
-    
+ 
+
     def __tuner_1_sweep_validator(self, capture_config: CaptureConfig) -> None:
+        self._default_sweep_validator(capture_config)
+        self._sdrplay_validator(capture_config)  
+
+
+    def __tuner_2_fixed_validator(self, capture_config: CaptureConfig) -> None:
+        self._default_fixed_validator(capture_config)
+        self._sdrplay_validator(capture_config)
+
+
+    def __tuner_2_sweep_validator(self, capture_config: CaptureConfig) -> None:
         self._default_sweep_validator(capture_config)
         self._sdrplay_validator(capture_config)
     

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.7.dist-info → spectre_core-0.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spectre-core
-Version: 0.0.7
+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
@@ -698,7 +698,7 @@ Requires-Dist: watchdog==4.0.0
   
 :loudspeaker: **This project is under active development. Contributors welcome.** :loudspeaker:  
 
-```spectre-core``` provides a SDR receiver-agnostic digital signal processing framework. It is the core Python package used by the [`spectre`](https://github.com/jcfitzpatrick12/spectre.git) program. 
+```spectre-core``` provides a SDR receiver-agnostic digital signal processing framework. It is the core Python package used by the [`spectre`](https://github.com/jcfitzpatrick12/spectre.git) program.  
 
 
 ## Installation

{spectre_core-0.0.7.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
@@ -41,12 +50,14 @@ spectre_core/receivers/library/rsp1a/gr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5J
 spectre_core/receivers/library/rsp1a/gr/fixed.py,sha256=P39JwuOe-ydk9m8BNOHFDpzaqjenRnTIA7tpECshfUM,3369
 spectre_core/receivers/library/rsp1a/gr/sweep.py,sha256=9ZAoI0u1814lOM_cVwJnLUNSgM3VMstfvWKP67dVEV4,4741
 spectre_core/receivers/library/rspduo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/receivers/library/rspduo/receiver.py,sha256=3pxWXKt9IS4tpUKjYKwnCePzT0Zu3XIShi-LRI8VAH4,2362
+spectre_core/receivers/library/rspduo/receiver.py,sha256=EMBFWwFjoIP2buwwamyb3uaYqMQwQHMzNi-we7_OfcU,3377
 spectre_core/receivers/library/rspduo/gr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/receivers/library/rspduo/gr/tuner_1_fixed.py,sha256=YaRS9oNRry-6eZPIsFjNlKcZqhNcQw3X9N8Dw877aeM,3603
-spectre_core/receivers/library/rspduo/gr/tuner_1_sweep.py,sha256=0WDfR1R6uOnIEb_4aPQN-O5Gh62utZrvRukPEF3xzDU,5113
+spectre_core/receivers/library/rspduo/gr/tuner_1_fixed.py,sha256=xO9F_GBwgNnebrxoZYPwbXLL2HmH0CNLrVlpQ6Z7bx0,3887
+spectre_core/receivers/library/rspduo/gr/tuner_1_sweep.py,sha256=gR5arbjvJBJjCdQnpAdwNd7bEtnvDbhL_ttUhKk0Zss,5066
+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
@@ -55,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.7.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-spectre_core-0.0.7.dist-info/METADATA,sha256=mSmKzIO9I8ps1yKp-jJjZ_D_OhDQH_lUKfgzeW2-VFc,42149
-spectre_core-0.0.7.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-spectre_core-0.0.7.dist-info/top_level.txt,sha256=-UsyjpFohXgZpgcZ9QbVeXhsIyF3Am8RxNFNDV_Ta2Y,13
-spectre_core-0.0.7.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