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

spectre_core/chunks/__init__.py

@@ -2,205 +2,21 @@
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-from logging import getLogger
-_LOGGER = getLogger(__name__)
+# decorators run on import
+from .library._fixed_center_frequency import _Chunk
+from .library._swept_center_frequency import _Chunk
+from .library._callisto import _Chunk
+
+from ._base import BaseChunk, ChunkFile
+from ._factory import get_chunk_from_tag
+from ._chunks import Chunks
+from .library._swept_center_frequency import SweepMetadata
+
+__all__ = [
+    "BaseChunk",
+    "ChunkFile",
+    "get_chunk_from_tag",
+    "Chunks",
+    "SweepMetadata"
+]
 
-import os
-from typing import Optional
-from collections import OrderedDict
-import warnings
-from datetime import datetime
-
-# dynamically import all chunks
-import spectre_core.chunks.library
-from spectre_core.chunks.factory import get_chunk_from_tag
-from spectre_core.chunks.base import BaseChunk
-from spectre_core.spectrograms.spectrogram import Spectrogram
-from spectre_core.spectrograms import transform
-from spectre_core.cfg import (
-    DEFAULT_DATETIME_FORMAT,
-    get_chunks_dir_path
-)
-from spectre_core.exceptions import (
-    SpectrogramNotFoundError,
-    ChunkNotFoundError
-)
-
-class Chunks:
-    def __init__(self, 
-                 tag: str,
-                 year: Optional[int] = None, 
-                 month: Optional[int] = None, 
-                 day: Optional[int] = None):
-        self._tag = tag
-        self._Chunk = get_chunk_from_tag(tag)
-        self._chunk_map: dict[str, BaseChunk] = OrderedDict()
-        self._chunk_list: list[BaseChunk] = []
-        self._chunk_names: list[str] = []
-        self.set_date(year, month, day)
-
-
-    @property
-    def year(self) -> int:
-        return self._year
-
-
-    @property 
-    def month(self) -> int:
-        return self._month
-    
-
-    @property
-    def day(self) -> int:
-        return self._day
-
-
-    @property
-    def chunks_dir_path(self) -> str:
-        return get_chunks_dir_path(self.year, self.month, self.day)
-    
-
-    @property 
-    def chunk_map(self) -> dict[str, BaseChunk]:
-        return self._chunk_map
-    
-
-    @property
-    def chunk_list(self) -> list[BaseChunk]:
-        return  self._chunk_list
-    
-
-    @property
-    def chunk_names(self) -> list[str]:
-        return self._chunk_names
-
-
-    @property
-    def num_chunks(self) -> int:
-        return len(self.chunk_list)
-
-
-    def set_date(self, 
-                 year: Optional[int],
-                 month: Optional[int],
-                 day: Optional[int]) -> None:
-        self._year = year
-        self._month = month
-        self._day = day
-        self._update_chunk_map()
-
-
-    def _update_chunk_map(self) -> None:
-        self._chunk_map = OrderedDict() # reset cache
-        self._chunk_list = [] # reset cache
-        self._chunk_names = [] # reset cache
-
-        chunk_files = [f for (_, _, files) in os.walk(self.chunks_dir_path) for f in files]
-        
-        if len(chunk_files) == 0:
-            warning_message = "No chunks found, setting chunk map with empty dictionary."
-            _LOGGER.warning(warning_message)
-            warnings.warn(warning_message)
-            return
-        
-        for chunk_file in chunk_files:
-            file_name, _ = os.path.splitext(chunk_file)
-            chunk_start_time, tag = file_name.split("_", 1)
-            if tag == self._tag:
-                self._chunk_map[chunk_start_time] = self._Chunk(chunk_start_time, tag)
-        
-        self._chunk_map = OrderedDict(sorted(self._chunk_map.items()))
-        self._chunk_names = list(self._chunk_map.keys())
-        self._chunk_list = list(self._chunk_map.values())
-
-
-    def update(self) -> None:
-        """Public alias for setting chunk map"""
-        self._update_chunk_map()
-    
-
-    def __iter__(self):
-        yield from self.chunk_list
-
-
-    def _get_chunk_by_chunk_start_time(self, 
-                                      chunk_start_time: str) -> BaseChunk:
-        try:
-            return self.chunk_map[chunk_start_time]
-        except KeyError:
-            raise ChunkNotFoundError(f"Chunk with chunk start time {chunk_start_time} could not be found within {self.chunks_dir_path}")
-
-
-    def _get_chunk_by_index(self, 
-                           chunk_index: int) -> BaseChunk:
-        num_chunks = len(self.chunk_map)
-        if num_chunks == 0:
-            raise ChunkNotFoundError("No chunks are available")
-        index = chunk_index % num_chunks  # Use modulo to make the index wrap around. Allows the user to iterate over all the chunks via index cyclically.
-        return self.chunk_list[index]
-
-
-    def __getitem__(self, subscript: str | int):
-        if isinstance(subscript, str):
-            return self._get_chunk_by_chunk_start_time(subscript)
-        elif isinstance(subscript, int):
-            return self._get_chunk_by_index(subscript)
-
-
-    def get_index_by_chunk(self, 
-                           chunk_to_match: BaseChunk) -> int:
-        for i, chunk in enumerate(self):
-            if chunk.chunk_start_time == chunk_to_match.chunk_start_time:
-                return i
-        raise ChunkNotFoundError(f"No matching chunk found for chunk {chunk_to_match.chunk_name}")
-    
-
-    def count_chunk_files(self, 
-                          extension: str) -> int:
-        return sum(1 for chunk_file in self if chunk_file.has_file(extension))
-
-
-    def get_spectrogram_from_range(self, 
-                                   start_time: str, 
-                                   end_time: str) -> Spectrogram:
-        # Convert input strings to datetime objects
-        start_datetime = datetime.strptime(start_time, DEFAULT_DATETIME_FORMAT)
-        end_datetime = datetime.strptime(end_time, DEFAULT_DATETIME_FORMAT)
-
-        if start_datetime.day != end_datetime.day:
-            warning_message = "Joining spectrograms across multiple days"
-            _LOGGER.warning(warning_message)
-            warnings.warn(warning_message, RuntimeWarning)
-
-        spectrograms = []
-        num_fits_chunks = self.count_chunk_files("fits")
-
-        for i, chunk in enumerate(self):
-            # skip chunks without fits files
-            if not chunk.has_file("fits"):
-                continue
-            
-            # rather than reading all files to evaluate the actual upper bound to their time range (slow)
-            # place an upper bound by using the chunk start datetime for the next chunk
-            # this assumes that the chunks are non-overlapping (reasonable assumption)
-            lower_bound = chunk.chunk_start_datetime
-            if i < num_fits_chunks:
-                next_chunk = self[i + 1]
-                upper_bound = next_chunk.chunk_start_datetime
-            # if there is no "next chunk" then we do have to read the file
-            else:
-                fits_chunk = chunk.get_file("fits")
-                upper_bound = fits_chunk.datetimes[-1]
-
-            # if the chunk overlaps with the input time range, then read the fits file
-            if start_datetime <= upper_bound and lower_bound <= end_datetime:
-                spectrogram = chunk.read_file("fits")
-                spectrogram = transform.time_chop(spectrogram, start_time, end_time)
-                # if we have a non-empty spectrogram, append it to the list of spectrograms
-                if spectrogram:
-                    spectrograms.append(spectrogram)
-
-        if spectrograms:
-            return transform.join_spectrograms(spectrograms)
-        else:
-            raise SpectrogramNotFoundError("No spectrogram data found for the given time range")

spectre_core/chunks/{base.py → _base.py}

@@ -3,16 +3,10 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from datetime import datetime
-from abc import abstractmethod
 from typing import Optional
 
-from scipy.signal import ShortTimeFFT, get_window
-
-from spectre_core.file_handlers.base import BaseFileHandler
-from spectre_core.cfg import get_chunks_dir_path
-from spectre_core.file_handlers.configs import CaptureConfig
-from spectre_core.spectrograms.spectrogram import Spectrogram
-from spectre_core.cfg import DEFAULT_DATETIME_FORMAT
+from spectre_core._file_io import BaseFileHandler
+from spectre_core.config import get_chunks_dir_path, TimeFormats
 from spectre_core.exceptions import ChunkFileNotFoundError
 
 class ChunkFile(BaseFileHandler):
@@ -35,15 +29,15 @@ class ChunkFile(BaseFileHandler):
     
 
     @property
-    def chunk_start_datetime(self) -> datetime:
-        if self._chunk_start_datetime is None:
-            self._chunk_start_datetime = datetime.strptime(self.chunk_start_time, DEFAULT_DATETIME_FORMAT)
-        return self._chunk_start_datetime
+    def tag(self) -> str:
+        return self._tag
     
 
     @property
-    def tag(self) -> str:
-        return self._tag
+    def chunk_start_datetime(self) -> datetime:
+        if self._chunk_start_datetime is None:
+            self._chunk_start_datetime = datetime.strptime(self.chunk_start_time, TimeFormats.DATETIME)
+        return self._chunk_start_datetime
     
 
 
@@ -64,18 +58,18 @@ class BaseChunk:
     @property
     def chunk_start_time(self) -> str:
         return self._chunk_start_time
-    
 
-    @property
-    def chunk_start_datetime(self) -> datetime:
-        if self._chunk_start_datetime is None:
-            self._chunk_start_datetime = datetime.strptime(self.chunk_start_time, DEFAULT_DATETIME_FORMAT)
-        return self._chunk_start_datetime
-    
 
     @property
     def tag(self) -> str:
         return self._tag
+      
+
+    @property
+    def chunk_start_datetime(self) -> datetime:
+        if self._chunk_start_datetime is None:
+            self._chunk_start_datetime = datetime.strptime(self.chunk_start_time, TimeFormats.DATETIME)
+        return self._chunk_start_datetime
 
 
     @property
@@ -120,42 +114,3 @@ class BaseChunk:
             return False
 
 
-class SPECTREChunk(BaseChunk):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self._capture_config = CaptureConfig(self._tag)
-        self._SFT = None # cache
-
-
-    @abstractmethod
-    def build_spectrogram(self) -> Spectrogram:
-        """Create a spectrogram object derived from chunk files for this chunk."""
-        pass
-
-
-    @property
-    def capture_config(self) -> CaptureConfig:
-        return self._capture_config
-    
-
-    @property
-    def SFT(self) -> ShortTimeFFT:
-        if self._SFT is None:
-            self._SFT = self.__get_SFT_instance()
-        return self._SFT
-    
-
-    def __get_SFT_instance(self) -> ShortTimeFFT:
-        hop = self.capture_config.get("hop")
-        window_type = self.capture_config.get("window_type")
-        window_params = self.capture_config.get("window_kwargs").values()
-        window_size = self.capture_config.get("window_size")
-        window = get_window((window_type, 
-                             *window_params), 
-                             window_size)
-        samp_rate = self.capture_config.get("samp_rate")
-        return ShortTimeFFT(window, 
-                            hop,
-                            samp_rate, 
-                            fft_mode = "centered")

spectre_core/chunks/_chunks.py

@@ -0,0 +1,200 @@
+# 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 typing import Optional
+from collections import OrderedDict
+import warnings
+from datetime import datetime
+
+from spectre_core.spectrograms import Spectrogram, time_chop, join_spectrograms
+from spectre_core.config import get_chunks_dir_path, TimeFormats
+from spectre_core.exceptions import (
+    SpectrogramNotFoundError,
+    ChunkNotFoundError
+)
+from ._base import BaseChunk
+from ._factory import get_chunk_from_tag
+
+class Chunks:
+    def __init__(self, 
+                 tag: str,
+                 year: Optional[int] = None, 
+                 month: Optional[int] = None, 
+                 day: Optional[int] = None):
+        self._tag = tag
+        self._Chunk = get_chunk_from_tag(tag)
+        self._chunk_map: dict[str, BaseChunk] = OrderedDict()
+        self._chunk_list: list[BaseChunk] = []
+        self._chunk_names: list[str] = []
+        self.set_date(year, month, day)
+
+
+    @property
+    def year(self) -> int:
+        return self._year
+
+
+    @property 
+    def month(self) -> int:
+        return self._month
+    
+
+    @property
+    def day(self) -> int:
+        return self._day
+
+
+    @property
+    def chunks_dir_path(self) -> str:
+        return get_chunks_dir_path(self.year, self.month, self.day)
+    
+
+    @property 
+    def chunk_map(self) -> dict[str, BaseChunk]:
+        return self._chunk_map
+    
+
+    @property
+    def chunk_list(self) -> list[BaseChunk]:
+        return  self._chunk_list
+    
+
+    @property
+    def chunk_names(self) -> list[str]:
+        return self._chunk_names
+
+
+    @property
+    def num_chunks(self) -> int:
+        return len(self.chunk_list)
+
+
+    def set_date(self, 
+                 year: Optional[int],
+                 month: Optional[int],
+                 day: Optional[int]) -> None:
+        self._year = year
+        self._month = month
+        self._day = day
+        self._update_chunk_map()
+
+
+    def _update_chunk_map(self) -> None:
+        self._chunk_map = OrderedDict() # reset cache
+        self._chunk_list = [] # reset cache
+        self._chunk_names = [] # reset cache
+
+        chunk_files = [f for (_, _, files) in os.walk(self.chunks_dir_path) for f in files]
+        
+        if len(chunk_files) == 0:
+            warning_message = "No chunks found, setting chunk map with empty dictionary."
+            _LOGGER.warning(warning_message)
+            warnings.warn(warning_message)
+            return
+        
+        for chunk_file in chunk_files:
+            file_name, _ = os.path.splitext(chunk_file)
+            chunk_start_time, tag = file_name.split("_", 1)
+            if tag == self._tag:
+                self._chunk_map[chunk_start_time] = self._Chunk(chunk_start_time, tag)
+        
+        self._chunk_map = OrderedDict(sorted(self._chunk_map.items()))
+        self._chunk_names = list(self._chunk_map.keys())
+        self._chunk_list = list(self._chunk_map.values())
+
+
+    def update(self) -> None:
+        """Public alias for setting chunk map"""
+        self._update_chunk_map()
+    
+
+    def __iter__(self):
+        yield from self.chunk_list
+
+
+    def _get_chunk_by_chunk_start_time(self, 
+                                      chunk_start_time: str) -> BaseChunk:
+        try:
+            return self.chunk_map[chunk_start_time]
+        except KeyError:
+            raise ChunkNotFoundError(f"Chunk with chunk start time {chunk_start_time} could not be found within {self.chunks_dir_path}")
+
+
+    def _get_chunk_by_index(self, 
+                           chunk_index: int) -> BaseChunk:
+        num_chunks = len(self.chunk_map)
+        if num_chunks == 0:
+            raise ChunkNotFoundError("No chunks are available")
+        index = chunk_index % num_chunks  # Use modulo to make the index wrap around. Allows the user to iterate over all the chunks via index cyclically.
+        return self.chunk_list[index]
+
+
+    def __getitem__(self, subscript: str | int):
+        if isinstance(subscript, str):
+            return self._get_chunk_by_chunk_start_time(subscript)
+        elif isinstance(subscript, int):
+            return self._get_chunk_by_index(subscript)
+
+
+    def get_index_by_chunk(self, 
+                           chunk_to_match: BaseChunk) -> int:
+        for i, chunk in enumerate(self):
+            if chunk.chunk_start_time == chunk_to_match.chunk_start_time:
+                return i
+        raise ChunkNotFoundError(f"No matching chunk found for chunk {chunk_to_match.chunk_name}")
+    
+
+    def count_chunk_files(self, 
+                          extension: str) -> int:
+        return sum(1 for chunk_file in self if chunk_file.has_file(extension))
+
+
+    def get_spectrogram_from_range(self, 
+                                   start_time: str, 
+                                   end_time: str) -> Spectrogram:
+        # Convert input strings to datetime objects
+        start_datetime = datetime.strptime(start_time, TimeFormats.DATETIME)
+        end_datetime = datetime.strptime(end_time, TimeFormats.DATETIME)
+
+        if start_datetime.day != end_datetime.day:
+            warning_message = "Joining spectrograms across multiple days"
+            _LOGGER.warning(warning_message)
+            warnings.warn(warning_message, RuntimeWarning)
+
+        spectrograms = []
+        num_fits_chunks = self.count_chunk_files("fits")
+
+        for i, chunk in enumerate(self):
+            # skip chunks without fits files
+            if not chunk.has_file("fits"):
+                continue
+            
+            # rather than reading all files to evaluate the actual upper bound to their time range (slow)
+            # place an upper bound by using the chunk start datetime for the next chunk
+            # this assumes that the chunks are non-overlapping (reasonable assumption)
+            lower_bound = chunk.chunk_start_datetime
+            if i < num_fits_chunks:
+                next_chunk = self[i + 1]
+                upper_bound = next_chunk.chunk_start_datetime
+            # if there is no "next chunk" then we do have to read the file
+            else:
+                fits_chunk = chunk.get_file("fits")
+                upper_bound = fits_chunk.datetimes[-1]
+
+            # if the chunk overlaps with the input time range, then read the fits file
+            if start_datetime <= upper_bound and lower_bound <= end_datetime:
+                spectrogram = chunk.read_file("fits")
+                spectrogram = time_chop(spectrogram, start_time, end_time)
+                # if we have a non-empty spectrogram, append it to the list of spectrograms
+                if spectrogram:
+                    spectrograms.append(spectrogram)
+
+        if spectrograms:
+            return join_spectrograms(spectrograms)
+        else:
+            raise SpectrogramNotFoundError("No spectrogram data found for the given time range")

spectre_core/chunks/{factory.py → _factory.py}

@@ -2,13 +2,12 @@
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-# after we decorate all chunks, we can import the chunk_key -> chunk maps
-from spectre_core.chunks.base import BaseChunk
-from spectre_core.file_handlers.configs import CaptureConfig
+from spectre_core.capture_configs import CaptureConfig, PNames
 from spectre_core.exceptions import ChunkNotFoundError
-from spectre_core.chunks.chunk_register import chunk_map
+from ._register import chunk_map
+from ._base import BaseChunk
 
-def get_chunk(chunk_key: str) -> BaseChunk:
+def _get_chunk(chunk_key: str) -> BaseChunk:
     Chunk = chunk_map.get(chunk_key)
     if Chunk is None:
         valid_chunk_keys = list(chunk_map.keys())
@@ -22,5 +21,5 @@ def get_chunk_from_tag(tag: str) -> BaseChunk:
     # otherwise, we fetch the chunk key from the capture config
     else:
         capture_config= CaptureConfig(tag)
-        chunk_key = capture_config.get('chunk_key')
-    return get_chunk(chunk_key)
+        chunk_key = capture_config.get_parameter_value(PNames.CHUNK_KEY)
+    return _get_chunk(chunk_key)

spectre_core/chunks/library/{callisto/chunk.py → _callisto.py}

@@ -11,16 +11,13 @@ from astropy.io.fits.hdu.image import PrimaryHDU
 from astropy.io.fits.hdu.table import BinTableHDU
 from astropy.io.fits.hdu.hdulist import HDUList
 
-from spectre_core.chunks.chunk_register import register_chunk
-from spectre_core.spectrograms.spectrogram import Spectrogram
-from spectre_core.chunks.base import (
-    BaseChunk, 
-    ChunkFile
-)
+from spectre_core.spectrograms import Spectrogram
+from .._register import register_chunk
+from .._base import BaseChunk, ChunkFile
 
 
 @register_chunk('callisto')
-class Chunk(BaseChunk):
+class _Chunk(BaseChunk):
     def __init__(self, chunk_start_time: str, tag: str):
         super().__init__(chunk_start_time, tag) 
         self.add_file(FitsChunk(self.chunk_parent_path, self.chunk_name))

spectre_core/chunks/library/{fixed/chunk.py → _fixed_center_frequency.py}

@@ -11,15 +11,13 @@ from astropy.io.fits.hdu.image import PrimaryHDU
 from astropy.io.fits.hdu.table import BinTableHDU
 from astropy.io.fits.hdu.hdulist import HDUList
 
-from spectre_core.chunks.chunk_register import register_chunk
-from spectre_core.spectrograms.spectrogram import Spectrogram
-from spectre_core.chunks.base import (
-    SPECTREChunk, 
-    ChunkFile
-)
-
-@register_chunk("fixed")
-class Chunk(SPECTREChunk):
+from spectre_core.spectrograms import Spectrogram
+from spectre_core.capture_configs import CaptureModes
+from .._register import register_chunk
+from .._base import BaseChunk, ChunkFile
+
+@register_chunk(CaptureModes.FIXED_CENTER_FREQUENCY)
+class _Chunk(BaseChunk):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs) 
         
@@ -28,61 +26,6 @@ class Chunk(SPECTREChunk):
         self.add_file(HdrChunk(self.chunk_parent_path, self.chunk_name))
 
 
-    def build_spectrogram(self) -> Spectrogram:
-        """Create a spectrogram by performing a Short Time FFT on the IQ samples for this chunk."""
-        iq_data = self.read_file("bin")
-        millisecond_correction = self.read_file("hdr")
-
-        # units conversion
-        microsecond_correction = millisecond_correction * 1e3
-
-        times, frequencies, dynamic_spectra = self.__do_STFFT(iq_data)
-
-        # explicitly type cast data arrays to 32-bit floats
-        times = np.array(times, dtype = 'float32')
-        frequencies = np.array(frequencies, dtype = 'float32')
-        dynamic_spectra = np.array(dynamic_spectra, dtype = 'float32')
-
-        return Spectrogram(dynamic_spectra, 
-                           times, 
-                           frequencies, 
-                           self.tag, 
-                           chunk_start_time = self.chunk_start_time, 
-                           microsecond_correction = microsecond_correction,
-                           spectrum_type = "amplitude")
-
-
-    def __do_STFFT(self, 
-                   iq_data: np.array) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
-        """For reference: https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.ShortTimeFFT.html"""
-
-        # set p0=0, since by convention in the STFFT docs, p=0 corresponds to the slice centred at t=0
-        p0=0
-
-        # set p1 to the index of the first slice where the "midpoint" of the window is still inside the signal
-        num_samples = len(iq_data)
-        p1 = self.SFT.upper_border_begin(num_samples)[1]
-        
-        # compute a ShortTimeFFT on the IQ samples
-        complex_spectra = self.SFT.stft(iq_data, 
-                                        p0 = p0, 
-                                        p1 = p1) 
-        
-        # compute the magnitude of each spectral component
-        dynamic_spectra = np.abs(complex_spectra)
-
-
-        # assign a physical time to each spectrum
-        times = self.SFT.t(num_samples, 
-                           p0 = 0, 
-                           p1 = p1)
-
-        # assign physical frequencies to each spectral component
-        frequencies = self.SFT.f + self.capture_config.get('center_freq', 0.0) 
-
-        return times, frequencies, dynamic_spectra
-
-
 class BinChunk(ChunkFile):
     def __init__(self, chunk_parent_path: str, chunk_name: str):
         super().__init__(chunk_parent_path, chunk_name, "bin")