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

spectre_core/{chunks → batches}/library/_fixed_center_frequency.py

@@ -11,24 +11,29 @@ 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.config import TimeFormats
 from spectre_core.spectrograms import Spectrogram
 from spectre_core.capture_configs import CaptureModes
-from .._register import register_chunk
-from .._base import BaseChunk, ChunkFile
+from .._register import register_batch
+from .._base import BaseBatch, BatchFile
 
-@register_chunk(CaptureModes.FIXED_CENTER_FREQUENCY)
-class _Chunk(BaseChunk):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs) 
-        
-        self.add_file(BinChunk(self.chunk_parent_path, self.chunk_name))
-        self.add_file(FitsChunk(self.chunk_parent_path, self.chunk_name))
-        self.add_file(HdrChunk(self.chunk_parent_path, self.chunk_name))
+
+@register_batch(CaptureModes.FIXED_CENTER_FREQUENCY)
+class _Batch(BaseBatch):
+    def __init__(self,
+                 start_time: str,
+                 tag: str):
+        super().__init__(start_time, tag) 
+        self.add_file( BinFile(self.parent_dir_path, self.name) )
+        self.add_file( HdrFile(self.parent_dir_path, self.name) )
+        self.add_file( FitsFile(self.parent_dir_path, self.name))
 
 
-class BinChunk(ChunkFile):
-    def __init__(self, chunk_parent_path: str, chunk_name: str):
-        super().__init__(chunk_parent_path, chunk_name, "bin")
+class BinFile(BatchFile):
+    def __init__(self, 
+                 parent_dir_path: str, 
+                 base_file_name: str):
+        super().__init__(parent_dir_path, base_file_name, "bin")
 
     def read(self) -> np.ndarray:
         with open(self.file_path, "rb") as fh:
@@ -36,9 +41,11 @@ class BinChunk(ChunkFile):
 
 
   
-class HdrChunk(ChunkFile):
-    def __init__(self, chunk_parent_path: str, chunk_name: str):
-        super().__init__(chunk_parent_path, chunk_name, "hdr")
+class HdrFile(BatchFile):
+    def __init__(self, 
+                 parent_dir_path: str, 
+                 base_file_name: str):
+        super().__init__(parent_dir_path, base_file_name, "hdr")
 
 
     def read(self) -> int:
@@ -63,11 +70,11 @@ class HdrChunk(ChunkFile):
         return int(millisecond_correction_as_float)
         
 
-
-
-class FitsChunk(ChunkFile):
-    def __init__(self, chunk_parent_path: str, chunk_name: str):
-        super().__init__(chunk_parent_path, chunk_name, "fits")
+class FitsFile(BatchFile):
+    def __init__(self, 
+                 parent_dir_path: str, 
+                 base_file_name: str):
+        super().__init__(parent_dir_path, base_file_name, "fits")
 
 
     @property
@@ -75,25 +82,24 @@ class FitsChunk(ChunkFile):
         with fits.open(self.file_path, mode='readonly') as hdulist:
             bintable_data = hdulist[1].data
             times = bintable_data['TIME'][0]
-            return [self.chunk_start_datetime + timedelta(seconds=t) for t in times]
+            return [self.start_datetime + timedelta(seconds=t) for t in times]
         
 
     def read(self) -> Spectrogram:
         with fits.open(self.file_path, mode='readonly') as hdulist:
-            primary_hdu = self._get_primary_hdu(hdulist)
-            dynamic_spectra = self._get_dynamic_spectra(primary_hdu)
-            spectrum_type = self._get_spectrum_type(primary_hdu)
-            microsecond_correction = self._get_microsecond_correction(primary_hdu)
-            bintable_hdu = self._get_bintable_hdu(hdulist)
-            times, frequencies = self._get_time_and_frequency(bintable_hdu)
+            primary_hdu                = self._get_primary_hdu(hdulist)
+            dynamic_spectra            = self._get_dynamic_spectra(primary_hdu)
+            spectrum_type              = self._get_spectrum_type(primary_hdu)
+            spectrogram_start_datetime = self._get_spectrogram_start_datetime(primary_hdu)
+            bintable_hdu               = self._get_bintable_hdu(hdulist)
+            times, frequencies         = self._get_time_and_frequency(bintable_hdu)
 
         return Spectrogram(dynamic_spectra, 
                            times, 
                            frequencies, 
-                           self.tag, 
-                           chunk_start_time=self.chunk_start_time, 
-                           microsecond_correction=microsecond_correction,
-                           spectrum_type = spectrum_type)
+                           self.tag,
+                           spectrogram_start_datetime,
+                           spectrum_type)
 
 
     def _get_primary_hdu(self, hdulist: HDUList) -> PrimaryHDU:
@@ -105,14 +111,13 @@ class FitsChunk(ChunkFile):
 
 
     def _get_spectrum_type(self, primary_hdu: PrimaryHDU) -> str:
-        return primary_hdu.header.get('BUNIT', None)
+        return primary_hdu.header['BUNIT']
 
 
-    def _get_microsecond_correction(self, primary_hdu: PrimaryHDU) -> int:
-        date_obs = primary_hdu.header.get('DATE-OBS', None)
-        time_obs = primary_hdu.header.get('TIME-OBS', None)
-        datetime_obs = datetime.strptime(f"{date_obs}T{time_obs}", "%Y-%m-%dT%H:%M:%S.%f")
-        return datetime_obs.microsecond
+    def _get_spectrogram_start_datetime(self, primary_hdu: PrimaryHDU) -> datetime:
+        date_obs = primary_hdu.header['DATE-OBS']
+        time_obs = primary_hdu.header['TIME-OBS']
+        return datetime.strptime(f"{date_obs}T{time_obs}", TimeFormats.PRECISE_DATETIME)
 
 
     def _get_bintable_hdu(self, hdulist: HDUList) -> BinTableHDU:

spectre_core/{chunks → batches}/library/_swept_center_frequency.py

@@ -9,14 +9,14 @@ import numpy as np
 
 from spectre_core.exceptions import InvalidSweepMetadataError
 from spectre_core.capture_configs import CaptureModes
-from ._fixed_center_frequency import BinChunk, FitsChunk
-from .._register import register_chunk
-from .._base import BaseChunk, ChunkFile
+from ._fixed_center_frequency import BinFile, FitsFile
+from .._register import register_batch
+from .._base import BaseBatch, BatchFile
 
 
 @dataclass
 class SweepMetadata:
-    """Wrapper for metadata required to assign center frequencies to each IQ sample in the chunk.
+    """Wrapper for metadata required to assign center frequencies to each IQ sample in the batch.
     
     center_frequencies is an ordered list containing all the center frequencies that the IQ samples
     were collected at. Typically, these will be ordered in "steps", where each step corresponds to
@@ -25,10 +25,8 @@ class SweepMetadata:
     (freq_0, freq_1, ..., freq_M, freq_0, freq_1, ..., freq_M, ...), freq_0 < freq_1 < ... < freq_M
 
     The n'th element of the num_samples list, tells us how many samples were collected at the n'th
-    element of center_frequencies:
-chunks.library.fixed_center_frequency.chunk import (
-    BinChunk, FitsChunk
-)
+    element of center_frequencies.
+
     Number of samples: (num_samples_at_freq_0, num_samples_at_freq_1, ...)
 
     Both these lists together allow us to map for each IQ sample, the center frequency it was collected at.
@@ -37,19 +35,23 @@ chunks.library.fixed_center_frequency.chunk import (
     num_samples: np.ndarray
 
 
-@register_chunk(CaptureModes.SWEPT_CENTER_FREQUENCY)
-class _Chunk(BaseChunk):
-    def __init__(self, chunk_start_time, tag):
-        super().__init__(chunk_start_time, tag)
-
-        self.add_file(BinChunk(self.chunk_parent_path, self.chunk_name))
-        self.add_file(FitsChunk(self.chunk_parent_path, self.chunk_name))
-        self.add_file(HdrChunk(self.chunk_parent_path, self.chunk_name))
-
+@register_batch(CaptureModes.SWEPT_CENTER_FREQUENCY)
+class _Batch(BaseBatch):
+    def __init__(self,
+                 start_time: str,
+                 tag: str):
+        super().__init__(start_time, tag) 
+        self.add_file( HdrFile(self.parent_dir_path, self.name) )
+        # reuse the binary and fits batch from the fixed center frequency case.
+        self.add_file( BinFile(self.parent_dir_path, self.name) )
+        self.add_file( FitsFile(self.parent_dir_path, self.name))
+        
     
-class HdrChunk(ChunkFile):
-    def __init__(self, chunk_parent_path: str, chunk_name: str):
-        super().__init__(chunk_parent_path, chunk_name, "hdr")
+class HdrFile(BatchFile):
+    def __init__(self, 
+                 parent_dir_path: str, 
+                 base_file_name: str):
+        super().__init__(parent_dir_path, base_file_name, "hdr")
 
     def read(self) -> Tuple[int, SweepMetadata]:
         hdr_contents = self._read_file_contents()

spectre_core/capture_configs/_capture_templates.py

@@ -138,7 +138,7 @@ def _make_fixed_frequency_capture_template(
     capture_template = make_base_capture_template(
         PNames.BATCH_SIZE,
         PNames.CENTER_FREQUENCY,
-        PNames.CHUNK_KEY,
+        PNames.BATCH_KEY,
         PNames.EVENT_HANDLER_KEY,
         PNames.FREQUENCY_RESOLUTION,
         PNames.INSTRUMENT,
@@ -158,12 +158,12 @@ def _make_fixed_frequency_capture_template(
     )
     capture_template.set_defaults(
             (PNames.EVENT_HANDLER_KEY,     CaptureModes.FIXED_CENTER_FREQUENCY),
-            (PNames.CHUNK_KEY,             CaptureModes.FIXED_CENTER_FREQUENCY),
+            (PNames.BATCH_KEY,             CaptureModes.FIXED_CENTER_FREQUENCY),
             (PNames.WATCH_EXTENSION,       "bin")
     )
     capture_template.enforce_defaults(
         PNames.EVENT_HANDLER_KEY,
-        PNames.CHUNK_KEY,
+        PNames.BATCH_KEY,
         PNames.WATCH_EXTENSION
     )
     return capture_template
@@ -173,7 +173,7 @@ def _make_swept_frequency_capture_template(
     """The absolute minimum required parameters for any swept frequency capture template."""
     capture_template = make_base_capture_template(
         PNames.BATCH_SIZE,
-        PNames.CHUNK_KEY,
+        PNames.BATCH_KEY,
         PNames.EVENT_HANDLER_KEY,
         PNames.FREQUENCY_RESOLUTION,
         PNames.FREQUENCY_STEP,
@@ -196,12 +196,12 @@ def _make_swept_frequency_capture_template(
         PNames.WINDOW_TYPE)
     capture_template.set_defaults(
             (PNames.EVENT_HANDLER_KEY,     CaptureModes.SWEPT_CENTER_FREQUENCY),
-            (PNames.CHUNK_KEY,             CaptureModes.SWEPT_CENTER_FREQUENCY),
+            (PNames.BATCH_KEY,             CaptureModes.SWEPT_CENTER_FREQUENCY),
             (PNames.WATCH_EXTENSION,       "bin")
     )
     capture_template.enforce_defaults(
         PNames.EVENT_HANDLER_KEY,
-        PNames.CHUNK_KEY,
+        PNames.BATCH_KEY,
         PNames.WATCH_EXTENSION
     )
     return capture_template

spectre_core/capture_configs/_parameters.py

@@ -47,14 +47,11 @@ class Parameters:
 
     def add_parameter(self, 
                       name: str,
-                      value: Optional[T] = None,
-                      force: bool = False) -> None:
+                      value: Optional[T] = None) -> None:
         """Add a new parameter."""
-        if name in self._parameters and not force:
+        if name in self._parameters:
             raise ValueError(f"Cannot add a parameter with name '{name}', "
-                             f"since a parameter already exists with that name. "
-                             f"You can overrride this functionality with 'force', "
-                             f"to overwrite the existing parameter.")
+                             f"since a parameter already exists with that name. ")
         self._parameters[name] = Parameter(name, value)
 
 

spectre_core/capture_configs/_ptemplates.py

@@ -178,7 +178,7 @@ class PNames:
     WINDOW_SIZE             : str = "window_size"
     EVENT_HANDLER_KEY       : str = "event_handler_key"
     WATCH_EXTENSION         : str = "watch_extension"
-    CHUNK_KEY               : str = "chunk_key"
+    BATCH_KEY               : str = "batch_key"
     SAMPLES_PER_STEP        : str = "samples_per_step"
     MIN_SAMPLES_PER_STEP    : str = "min_samples_per_step"
     MAX_SAMPLES_PER_STEP    : str = "max_samples_per_step"
@@ -271,10 +271,10 @@ _base_ptemplates = {
                                                     Identifies which post-processing functions to invoke
                                                     on newly created files.
                                                     """),
-    PNames.CHUNK_KEY:              PTemplate(PNames.CHUNK_KEY,              
+    PNames.BATCH_KEY:              PTemplate(PNames.BATCH_KEY,              
                                              str,
                                              help = """
-                                                    Identifies the type of data is stored in each chunk.
+                                                    Identifies the type of data is stored in each batch.
                                                     """,
                                              ),
     PNames.WINDOW_SIZE:            PTemplate(PNames.WINDOW_SIZE,            

spectre_core/capture_configs/_pvalidators.py

@@ -26,9 +26,9 @@ def _validate_window(
     
     window_interval = window_size*(1 / sample_rate)
     if window_interval > batch_size:
-        raise ValueError((f"The windowing interval must be strictly less than the chunk size. "
+        raise ValueError((f"The windowing interval must be strictly less than the batch size. "
                           f"Computed the windowing interval to be {window_interval} [s], "
-                          f"but the chunk size is {batch_size} [s]"))
+                          f"but the batch size is {batch_size} [s]"))
     
     try:
         _ = get_window(window_type, window_size)
@@ -90,9 +90,9 @@ def _validate_sweep_interval(
     num_samples_per_sweep = num_steps_per_sweep * samples_per_step
     sweep_interval = num_samples_per_sweep * 1/sample_rate
     if sweep_interval > batch_size:
-        raise ValueError((f"Sweep interval must be less than the chunk size. "
+        raise ValueError((f"Sweep interval must be less than the batch size. "
                           f"The computed sweep interval is {sweep_interval} [s], "
-                          f"but the given chunk size is {batch_size} [s]"))
+                          f"but the given batch size is {batch_size} [s]"))
     
 
 def _validate_num_samples_per_step(
@@ -131,10 +131,8 @@ def _validate_step_interval(
 
     step_interval = samples_per_step * 1/ sample_rate # [s]
     if step_interval < api_latency:
-        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!")
-        warn(warning_message)
-        _LOGGER.warning(warning_message)
+        raise ValueError(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!")
 
 
 def _validate_fixed_center_frequency_parameters(

spectre_core/config/__init__.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from ._paths import (
-    get_spectre_data_dir_path, get_chunks_dir_path, get_configs_dir_path, get_logs_dir_path
+    get_spectre_data_dir_path, get_batches_dir_path, get_configs_dir_path, get_logs_dir_path
 )
 from ._time_formats import (
     TimeFormats
@@ -11,7 +11,7 @@ from ._time_formats import (
 
 __all__ = [
     "get_spectre_data_dir_path",
-    "get_chunks_dir_path",
+    "get_batches_dir_path",
     "get_configs_dir_path",
     "get_logs_dir_path",
     "DEFAULT_DATE_FORMAT",

spectre_core/config/_paths.py

@@ -12,9 +12,9 @@ _SPECTRE_DATA_DIR_PATH = os.environ.get("SPECTRE_DATA_DIR_PATH")
 if _SPECTRE_DATA_DIR_PATH is None:
     raise ValueError("The environment variable SPECTRE_DATA_DIR_PATH has not been set")
 
-_CHUNKS_DIR_PATH = os.environ.get("SPECTRE_CHUNKS_DIR_PATH", 
-                                  os.path.join(_SPECTRE_DATA_DIR_PATH, 'chunks'))
-os.makedirs(_CHUNKS_DIR_PATH, 
+_BATCHES_DIR_PATH = os.environ.get("SPECTRE_BATCHES_DIR_PATH", 
+                                  os.path.join(_SPECTRE_DATA_DIR_PATH, 'batches'))
+os.makedirs(_BATCHES_DIR_PATH, 
             exist_ok=True)
 
 _LOGS_DIR_PATH = os.environ.get("SPECTRE_LOGS_DIR_PATH",
@@ -52,11 +52,11 @@ def _get_date_based_dir_path(base_dir: str, year: int = None,
     return os.path.join(base_dir, *date_dir_components)
 
 
-def get_chunks_dir_path(year: int = None, 
+def get_batches_dir_path(year: int = None, 
                         month: int = None, 
                         day: int = None
 ) -> str:
-    return _get_date_based_dir_path(_CHUNKS_DIR_PATH, 
+    return _get_date_based_dir_path(_BATCHES_DIR_PATH, 
                                     year, 
                                     month, 
                                     day)

spectre_core/config/_time_formats.py

@@ -10,6 +10,8 @@ from dataclasses import dataclass
 
 @dataclass(frozen=True)
 class TimeFormats:
-    TIME     = "%H:%M:%S"
-    DATE     = "%Y-%m-%d"
-    DATETIME = f"{DATE}T{TIME}"
+    DATE             = "%Y-%m-%d"
+    TIME             = "%H:%M:%S"
+    PRECISE_TIME     = "%H:%M:%S.%f"
+    DATETIME         = f"{DATE}T{TIME}"
+    PRECISE_DATETIME = f"{DATE}T{PRECISE_TIME}"

spectre_core/exceptions.py

@@ -6,8 +6,8 @@
 SPECTRE custom exceptions.
 """
 
-class ChunkNotFoundError(FileNotFoundError): ...
-class ChunkFileNotFoundError(FileNotFoundError): ...
+class BatchNotFoundError(FileNotFoundError): ...
+class BatchFileNotFoundError(FileNotFoundError): ...
 class SpectrogramNotFoundError(FileNotFoundError): ...
 class ModeNotFoundError(KeyError): ...
 class EventHandlerNotFoundError(KeyError): ...

spectre_core/logging/_configure.py

@@ -16,7 +16,7 @@ def configure_root_logger(process_type: str,
     datetime_stamp = system_datetime.strftime(TimeFormats.DATETIME)
     pid = os.getpid()
     log_handler = LogHandler(datetime_stamp, pid, process_type)
-    log_handler.make_parent_path()
+    log_handler.make_parent_dir_path()
 
     # configure the root logger
     logger = logging.getLogger()

spectre_core/logging/_log_handlers.py

@@ -66,8 +66,8 @@ class LogHandlers:
                  year: Optional[int] = None, 
                  month: Optional[int] = None, 
                  day: Optional[int] = None):
-        self._log_handler_map: dict[str, LogHandler] = OrderedDict()
         self._process_type = process_type
+        self._log_handler_map: dict[str, LogHandler] = OrderedDict()
         self.set_date(year, month, day)
 
 

spectre_core/plotting/_panels.py

@@ -170,7 +170,7 @@ class _SpectrogramPanel(BaseTimeSeriesPanel):
 
 
     def draw(self):
-        dynamic_spectra = self._spectrogram.dynamic_spectra_as_dBb if self._dBb else self._spectrogram.dynamic_spectra
+        dynamic_spectra = self._spectrogram.dynamic_spectra_dBb if self._dBb else self._spectrogram.dynamic_spectra
 
         norm = LogNorm(vmin=np.nanmin(dynamic_spectra[dynamic_spectra > 0]), 
                        vmax=np.nanmax(dynamic_spectra)) if self._log_norm else None

spectre_core/post_processing/__init__.py

@@ -6,9 +6,9 @@
 from .library._fixed_center_frequency import _EventHandler
 from .library._swept_center_frequency import _EventHandler
 
-from ._factory import get_event_handler_from_tag
+from ._factory import get_event_handler_cls_from_tag
 from ._post_processor import PostProcessor
 
 __all__ = [
-    "PostProcessor", "get_event_handler_from_tag"
+    "PostProcessor", "get_event_handler_cls_from_tag"
 ]

spectre_core/post_processing/_base.py

@@ -12,7 +12,7 @@ from scipy.signal import ShortTimeFFT, get_window
 from watchdog.events import FileSystemEventHandler, FileCreatedEvent
 
 from spectre_core.capture_configs import CaptureConfig, PNames
-from spectre_core.chunks import BaseChunk, get_chunk_from_tag
+from spectre_core.batches import BaseBatch, get_batch_cls_from_tag
 from spectre_core.spectrograms import Spectrogram, join_spectrograms
 
 
@@ -35,8 +35,8 @@ class BaseEventHandler(ABC, FileSystemEventHandler):
                  tag: str):
         self._tag = tag
 
-        # the tag tells us 'what type' of data is stored in the files for each chunk
-        self._Chunk: BaseChunk = get_chunk_from_tag(tag)
+        # the tag tells us 'what type' of data is stored in the files for each batch
+        self._Batch = get_batch_cls_from_tag(tag)
         # load the capture config corresponding to the tag
         self._capture_config   = CaptureConfig(tag)
 
@@ -104,7 +104,7 @@ class BaseEventHandler(ABC, FileSystemEventHandler):
             self._cached_spectrogram = join_spectrograms([self._cached_spectrogram, spectrogram])
 
         # if the time range is not specified
-        time_range = self._capture_config.get_parameter_value(PNames.TIME_RANGE) or self._capture_config.get_parameter_value(PNames.BATCH_SIZE)
+        time_range = self._capture_config.get_parameter_value(PNames.TIME_RANGE) or 0.0
   
         if self._cached_spectrogram.time_range >= time_range:
             self._flush_cache()
@@ -112,8 +112,8 @@ class BaseEventHandler(ABC, FileSystemEventHandler):
 
     def _flush_cache(self) -> None:
         if self._cached_spectrogram:
-            _LOGGER.info(f"Flushing spectrogram to file with chunk start time "
-                         f"'{self._cached_spectrogram.chunk_start_time}'")
+            _LOGGER.info(f"Flushing spectrogram to file with start time "
+                         f"'{self._cached_spectrogram.format_start_time(precise=True)}'")
             self._cached_spectrogram.save()
             _LOGGER.info("Flush successful, resetting spectrogram cache")
             self._cached_spectrogram = None # reset the cache

spectre_core/post_processing/_factory.py

@@ -8,7 +8,7 @@ from spectre_core.capture_configs import CaptureConfig, PNames
 from spectre_core.exceptions import EventHandlerNotFoundError
 
 
-def _get_event_handler(event_handler_key: str) -> BaseEventHandler:
+def _get_event_handler_cls(event_handler_key: str) -> BaseEventHandler:
     EventHandler = event_handler_map.get(event_handler_key)
     if EventHandler is None:
         valid_event_handler_keys = list(event_handler_map.keys())
@@ -17,7 +17,7 @@ def _get_event_handler(event_handler_key: str) -> BaseEventHandler:
     return EventHandler
 
 
-def get_event_handler_from_tag(tag: str) -> BaseEventHandler:
+def get_event_handler_cls_from_tag(tag: str) -> BaseEventHandler:
     capture_config = CaptureConfig(tag)
     event_handler_key = capture_config.get_parameter_value(PNames.EVENT_HANDLER_KEY)
-    return _get_event_handler(event_handler_key)
+    return _get_event_handler_cls(event_handler_key)

spectre_core/post_processing/_post_processor.py

@@ -8,8 +8,8 @@ _LOGGER = getLogger(__name__)
 from watchdog.observers import Observer
 from watchdog.events import FileCreatedEvent
 
-from ._factory import get_event_handler_from_tag
-from spectre_core.config import get_chunks_dir_path
+from ._factory import get_event_handler_cls_from_tag
+from spectre_core.config import get_batches_dir_path
 
 class PostProcessor:
     def __init__(self, 
@@ -17,14 +17,14 @@ class PostProcessor:
         
         self._observer = Observer()
 
-        EventHandler = get_event_handler_from_tag(tag)
+        EventHandler = get_event_handler_cls_from_tag(tag)
         self._event_handler = EventHandler(tag)
 
 
     def start(self):
-        """Start an observer to process newly created files in the chunks directory"""
+        """Start an observer to process newly created files in the batches directory"""
         self._observer.schedule(self._event_handler, 
-                                get_chunks_dir_path(), 
+                                get_batches_dir_path(), 
                                 recursive=True,
                                 event_filter=[FileCreatedEvent])
         

spectre_core/post_processing/library/_fixed_center_frequency.py

@@ -7,11 +7,12 @@ _LOGGER = getLogger(__name__)
 
 import numpy as np
 from typing import Tuple
+from datetime import timedelta
 
 import os
 
 from spectre_core.capture_configs import CaptureConfig, PNames, CaptureModes
-from spectre_core.chunks import BaseChunk
+from spectre_core.batches import BaseBatch
 from spectre_core.spectrograms import Spectrogram, time_average, frequency_average
 from .._base import BaseEventHandler, make_sft_instance
 from .._register import register_event_handler
@@ -51,16 +52,13 @@ def _do_stfft(iq_data: np.array,
     return times, frequencies, dynamic_spectra
 
 
-def _build_spectrogram(chunk: BaseChunk,
+def _build_spectrogram(batch: BaseBatch,
                        capture_config: CaptureConfig) -> Spectrogram:
-    """Create a spectrogram by performing a Short Time FFT on the IQ samples for this chunk."""
+    """Create a spectrogram by performing a Short Time FFT on the IQ samples for this batch."""
 
-    # read the data from the chunk
-    millisecond_correction = chunk.read_file("hdr")
-    iq_data = chunk.read_file("bin")
-
-    # units conversion
-    microsecond_correction = millisecond_correction * 1e3
+    # read the data from the batch
+    millisecond_correction = batch.read_file("hdr")
+    iq_data = batch.read_file("bin")
 
     times, frequencies, dynamic_spectra = _do_stfft(iq_data,
                                                     capture_config)
@@ -70,12 +68,13 @@ def _build_spectrogram(chunk: BaseChunk,
     frequencies = np.array(frequencies, dtype = 'float32')
     dynamic_spectra = np.array(dynamic_spectra, dtype = 'float32')
 
-    return Spectrogram(dynamic_spectra, 
-                       times, 
-                       frequencies, 
-                       chunk.tag, 
-                       chunk_start_time = chunk.chunk_start_time, 
-                       microsecond_correction = microsecond_correction,
+    # compute the start datetime for the spectrogram by adding the millisecond component to the batch start time
+    spectrogram_start_datetime = batch.start_datetime + timedelta(milliseconds=millisecond_correction)
+    return Spectrogram(dynamic_spectra,
+                       times,
+                       frequencies,
+                       batch.tag,
+                       spectrogram_start_datetime,
                        spectrum_type = "amplitude")
 
 
@@ -89,13 +88,13 @@ class _EventHandler(BaseEventHandler):
         _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, tag = base_file_name.split('_')
+        batch_start_time, tag = base_file_name.split('_')
 
-        # create an instance of the current chunk being processed
-        chunk = self._Chunk(chunk_start_time, tag)
+        # create an instance of the current batch being processed
+        batch = self._Batch(batch_start_time, tag)
 
         _LOGGER.info("Creating spectrogram")
-        spectrogram = _build_spectrogram(chunk,
+        spectrogram = _build_spectrogram(batch,
                                         self._capture_config)
 
         spectrogram = time_average(spectrogram,
@@ -106,10 +105,10 @@ class _EventHandler(BaseEventHandler):
         
         self._cache_spectrogram(spectrogram)
 
-        bin_chunk = chunk.get_file('bin')
-        _LOGGER.info(f"Deleting {bin_chunk.file_path}")
-        bin_chunk.delete()
+        bin_file = batch.get_file('bin')
+        _LOGGER.info(f"Deleting {bin_file.file_path}")
+        bin_file.delete()
 
-        hdr_chunk = chunk.get_file('hdr')
-        _LOGGER.info(f"Deleting {hdr_chunk.file_path}")
-        hdr_chunk.delete()
+        hdr_file = batch.get_file('hdr')
+        _LOGGER.info(f"Deleting {hdr_file.file_path}")
+        hdr_file.delete()