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

spectre_core/plotting/library/time_cuts/panel.py

@@ -1,77 +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 typing import Optional
-
-from spectre_core.spectrograms.spectrogram import TimeCut
-from spectre_core.spectrograms.spectrogram import Spectrogram
-from spectre_core.plotting.base import BaseTimeSeriesPanel, CutsPanel
-from spectre_core.plotting.format import DEFAULT_FORMATS
-from spectre_core.plotting.panel_register import register_panel
-
-TIME_CUTS_PANEL_NAME = "time_cuts"
-
-@register_panel(TIME_CUTS_PANEL_NAME)
-class Panel(BaseTimeSeriesPanel, CutsPanel):
-    def __init__(self, 
-                 name: str,
-                 spectrogram: Spectrogram, 
-                 time_type: str = "seconds",
-                 *frequencies: list[float],
-                 dBb: bool = False,
-                 peak_normalise: bool = False,
-                 background_subtract: bool = False,
-                 cmap: str = DEFAULT_FORMATS.cuts_cmap,
-                 **kwargs):
-        super().__init__(name, 
-                         spectrogram, 
-                         time_type, 
-                         **kwargs)
-        self._frequencies = frequencies
-        self._cmap = cmap
-        self._dBb = dBb
-        self._peak_normalise = peak_normalise
-        self._background_subtract = background_subtract
-        # map each cut frequency to the corresponding TimeCut dataclass
-        self._time_cuts: Optional[dict[float, TimeCut]] = {} 
-    
-
-    @property
-    def time_cuts(self) -> dict[float, TimeCut]:
-        if not self._time_cuts:
-            for frequency in self._frequencies:
-                time_cut =  self._spectrogram.get_time_cut(frequency,
-                                                           dBb = self._dBb,
-                                                           peak_normalise = self._peak_normalise,
-                                                           correct_background = self._background_subtract,
-                                                           return_time_type=self._time_type)
-                self._time_cuts[time_cut.frequency] = time_cut
-        return self._time_cuts
-    
-
-    @property
-    def frequencies(self) -> list[float]:
-        return list(self.time_cuts.keys())
-
-
-    def draw(self):
-        for frequency, color in self.bind_to_colors():
-            time_cut = self.time_cuts[frequency]
-            self.ax.step(self.times, 
-                         time_cut.cut, 
-                         where='mid', 
-                         color = color)
-    
-
-    def annotate_y_axis(self) -> None:
-        if self._dBb:
-            self.ax.set_ylabel('dBb')
-        elif self._peak_normalise:
-            return # no y-axis label
-        else:
-            self.ax.set_ylabel(f'{self._spectrogram.spectrum_type.capitalize()}')
-
-    
-    def bind_to_colors(self):
-        return super().bind_to_colors(self.frequencies, cmap = self._cmap)

spectre_core/plotting/panel_register.py

@@ -1,13 +0,0 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
-# This file is part of SPECTRE
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-
-# Global dictionaries to hold the mappings
-panels = {}
-    
-def register_panel(panel_name: str): 
-    def decorator(cls):
-        panels[panel_name] = cls
-        return cls
-    return decorator

spectre_core/post_processing/base.py

@@ -1,132 +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
-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/post_processing/library/fixed/event_handler.py

@@ -1,40 +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
-
-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):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-
-    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()
-
-        spectrogram = self._average_in_time(spectrogram)
-        spectrogram = self._average_in_frequency(spectrogram)
-        self._join_spectrogram(spectrogram)
-
-        bin_chunk = chunk.get_file('bin')
-        _LOGGER.info(f"Deleting {bin_chunk.file_path}")
-        bin_chunk.delete()
-
-        hdr_chunk = chunk.get_file('hdr')
-        _LOGGER.info(f"Deleting {hdr_chunk.file_path}")
-        hdr_chunk.delete()

spectre_core/post_processing/library/sweep/event_handler.py

@@ -1,54 +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
-
-from spectre_core.chunks.base import BaseChunk
-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):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self.previous_chunk: BaseChunk = None # cache for previous chunk
-        
-
-    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)
-
-        spectrogram = self._average_in_time(spectrogram)
-        spectrogram = self._average_in_frequency(spectrogram)
-        self._join_spectrogram(spectrogram)
-
-        # 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
-            self.previous_chunk = chunk
-            
-        # otherwise the previous chunk is defined (and by this point has already been processed)
-        else:
-            bin_chunk = self.previous_chunk.get_file('bin')
-            _LOGGER.info(f"Deleting {bin_chunk.file_path}")
-            bin_chunk.delete()
-
-            hdr_chunk = self.previous_chunk.get_file('hdr')
-            _LOGGER.info(f"Deleting {hdr_chunk.file_path}")
-            hdr_chunk.delete()
-
-            # and reassign the current chunk to be used as the previous chunk at the next call of this method
-            self.previous_chunk = chunk