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

spectre_core/spectrograms/_spectrogram.py

@@ -12,7 +12,7 @@ import numpy as np
 from astropy.io import fits
 
 from spectre_core.capture_configs import CaptureConfig, PNames
-from spectre_core.config import get_chunks_dir_path, TimeFormats
+from spectre_core.config import get_batches_dir_path, TimeFormats
 from ._array_operations import (
     find_closest_index,
     normalise_peak_intensity,
@@ -21,16 +21,10 @@ from ._array_operations import (
     subtract_background,
 )
 
-__all__ = [
-    "FrequencyCut",
-    "TimeCut",
-    "TimeTypes",
-    "SpectrumTypes",
-    "Spectrogram"
-]
 
 @dataclass
 class FrequencyCut:
+    """A container to hold a cut of a dynamic spectra at a particular instant of time."""
     time: float | datetime
     frequencies: np.ndarray
     cut: np.ndarray
@@ -39,6 +33,7 @@ class FrequencyCut:
 
 @dataclass
 class TimeCut:
+    """A container to hold a cut of a dynamic spectra at a particular frequency."""
     frequency: float
     times: np.ndarray
     cut: np.ndarray
@@ -47,178 +42,211 @@ class TimeCut:
 
 @dataclass(frozen=True)
 class TimeTypes:
+    """Container to hold the different types of time we can assign to each spectrum in the dynamic spectra.
+    
+    'SECONDS' is equivalent to 'seconds elapsed since the first spectrum'.
+    'DATETIMES' is equivalent to 'the datetime associated with each spectrum'.
+    """
     SECONDS  : str = "seconds"
     DATETIMES: str = "datetimes"
     
 
 @dataclass(frozen=True)
 class SpectrumTypes:
+    """A container for defined units of dynamic spectra."""
     AMPLITUDE: str = "amplitude"
     POWER    : str = "power"
     DIGITS   : str = "digits"
 
 
 class Spectrogram:
+    """A convenient, standardised wrapper for spectrogram data."""
     def __init__(self, 
-                 dynamic_spectra: np.ndarray, # holds the spectrogram data
-                 times: np.ndarray, # holds the time stamp [s] for each spectrum
-                 frequencies: np.ndarray,  # physical frequencies [Hz] for each spectral component
+                 dynamic_spectra: np.ndarray,
+                 times: np.ndarray, 
+                 frequencies: np.ndarray, 
                  tag: str,
-                 chunk_start_time: Optional[str] = None, 
-                 microsecond_correction: int = 0, 
-                 spectrum_type: Optional[str] = None,
-                 start_background: Optional[str] = None, 
-                 end_background: Optional[str] = None): 
+                 start_datetime: Optional[datetime] = None, 
+                 spectrum_type: Optional[str] = None): 
         
         # dynamic spectra
         self._dynamic_spectra = dynamic_spectra
-        self._dynamic_spectra_as_dBb: Optional[np.ndarray] = None # cache
+        self._dynamic_spectra_dBb: Optional[np.ndarray] = None # cache
 
         # assigned times and frequencies
         if times[0] != 0:
-            raise ValueError(f"The first spectrum must correspond to t=0 [s]")
+            raise ValueError(f"The first spectrum must correspond to t=0")
         
         self._times = times
-        self._datetimes: Optional[list[datetime]] = None # cache
         self._frequencies = frequencies
 
         # general metadata
         self._tag = tag
-        self._chunk_start_time = chunk_start_time
-        self._chunk_start_datetime: Optional[datetime] = None # cache
-        self._microsecond_correction = microsecond_correction
         self._spectrum_type = spectrum_type
-
+        
+        # datetime information 
+        self._start_datetime = start_datetime
+        self._datetimes: Optional[list[datetime]] = None # cache
+        
         # background metadata     
         self._background_spectrum: Optional[np.ndarray] = None # cache
-        self._start_background = start_background
-        self._end_background = end_background
-        self._start_background_index = 0 # by default
-        self._end_background_index = self.num_times # by default
+        self._start_background_index = 0 
+        self._end_background_index   = self.num_times 
+        # background interval can be set after instanitation.
+        self._start_background = None
+        self._end_background   = None
+        
+        # finally check that the spectrogram arrays are matching in shape
         self._check_shapes()
 
 
     @property
     def dynamic_spectra(self) -> np.ndarray:
+        """The dynamic spectra."""
         return self._dynamic_spectra
     
 
     @property
     def times(self) -> np.ndarray:
+        """The physical time assigned to each spectrum.
+        
+        Equivalent to the 'seconds elapsed since the first spectrum'. So, by convention, the
+        first spectrum is at t=0.
+        """
         return self._times
     
     
     @property
     def num_times(self) -> int:
+        """The size of the times array. Equivalent to the number of spectrums in the spectrogram."""
         return len(self._times)
     
 
     @property
     def time_resolution(self) -> float:
+        """The time resolution of the dynamic spectra."""
         return compute_resolution(self._times)
     
 
     @property
     def time_range(self) -> float:
+        """The time range of the dynamic spectra."""
         return compute_range(self._times)
     
 
-    @property
-    def datetimes(self) -> list[datetime]:
-        if self._datetimes is None:
-            self._datetimes = [self.chunk_start_datetime + timedelta(seconds=(t + self.microsecond_correction*1e-6)) for t in self._times]
-        return self._datetimes
-    
-
     @property
     def frequencies(self) -> np.ndarray:
+        """The physical frequency assigned to each spectral component."""
         return self._frequencies
 
 
     @property
     def num_frequencies(self) -> int:
+        """The number of spectral components."""
         return len(self._frequencies)
     
     
     @property
     def frequency_resolution(self) -> float:
+        """The frequency resolution of the dynamic spectra."""
         return compute_resolution(self._frequencies)
     
 
     @property
     def frequency_range(self) -> float:
+        """The frequency range covered by the dynamic spectra."""
         return compute_range(self._frequencies)
     
 
     @property
     def tag(self) -> str:
+        """The tag identifier corresponding to the dynamic spectra."""
         return self._tag
     
 
     @property
-    def chunk_start_time(self) -> str:
-        if self._chunk_start_time is None:
-            raise AttributeError(f"Chunk start time has not been set.")
-        return self._chunk_start_time
+    def start_datetime_is_set(self) -> bool:
+        """Returns true if the start datetime for the spectrogram has been set."""
+        return (self._start_datetime is not None)
+    
     
-
     @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
-
-
+    def start_datetime(self) -> datetime:
+        """The datetime assigned to the first spectrum in the dynamic spectra."""
+        if self._start_datetime is None:
+            raise AttributeError(f"A start time has not been set.")
+        return self._start_datetime
+    
+    
+    def format_start_time(self,
+                          precise: bool = False) -> str:
+        """The datetime assigned to the first spectrum in the dynamic spectra, formatted as a string."""
+        if precise:
+            return datetime.strftime(self.start_datetime, TimeFormats.PRECISE_DATETIME)
+        return datetime.strftime(self.start_datetime, TimeFormats.DATETIME)
+    
+    
     @property
-    def microsecond_correction(self) -> int:
-        return self._microsecond_correction
+    def datetimes(self) -> list[datetime]:
+        """The datetimes associated with each spectrum in the dynamic spectra."""
+        if self._datetimes is None:
+            self._datetimes = [self.start_datetime + timedelta( seconds=(float(t)) ) for t in self._times]
+        return self._datetimes
     
 
     @property
     def spectrum_type(self) -> Optional[str]:
+        """The units of the dynamic spectra."""
         return self._spectrum_type
     
 
     @property
     def start_background(self) -> Optional[str]:
+        """The start of the background interval, as a datetime string up to seconds precision."""
         return self._start_background
     
 
     @property
     def end_background(self) -> Optional[str]:
+        """The end of the background interval, as a datetime string up to seconds precision."""
         return self._end_background
     
     
     @property
     def background_spectrum(self) -> np.ndarray:
+        """The background spectrum, computed by averaging the dynamic spectra according to the specified background interval.
+        
+        By default, the entire dynamic spectra is averaged over.
+        """
         if self._background_spectrum is None:
             self._background_spectrum = np.nanmean(self._dynamic_spectra[:, self._start_background_index:self._end_background_index+1], 
-                                               axis=-1)
+                                                   axis=-1)
         return self._background_spectrum
     
 
     @property
-    def dynamic_spectra_as_dBb(self) -> np.ndarray:
-        if self._dynamic_spectra_as_dBb is None:
+    def dynamic_spectra_dBb(self) -> np.ndarray:
+        """The dynamic spectra in units of decibels above the background spectrum."""
+        if self._dynamic_spectra_dBb is None:
             # Create an artificial spectrogram where each spectrum is identically the background spectrum
             background_spectra = self.background_spectrum[:, np.newaxis]
             # Suppress divide by zero and invalid value warnings for this block of code
             with np.errstate(divide='ignore'):
                 # Depending on the spectrum type, compute the dBb values differently
                 if self._spectrum_type == SpectrumTypes.AMPLITUDE or self._spectrum_type == SpectrumTypes.DIGITS:
-                    self._dynamic_spectra_as_dBb = 10 * np.log10(self._dynamic_spectra / background_spectra)
+                    self._dynamic_spectra_dBb = 10 * np.log10(self._dynamic_spectra / background_spectra)
                 elif self._spectrum_type == SpectrumTypes.POWER:
-                    self._dynamic_spectra_as_dBb = 20 * np.log10(self._dynamic_spectra / background_spectra)
+                    self._dynamic_spectra_dBb = 20 * np.log10(self._dynamic_spectra / background_spectra)
                 else:
                     raise NotImplementedError(f"{self.spectrum_type} unrecognised, uncertain decibel conversion!")
-        return self._dynamic_spectra_as_dBb  
+        return self._dynamic_spectra_dBb  
     
     
     def set_background(self, 
                        start_background: str, 
                        end_background: str) -> None:
         """Public setter for start and end of the background"""
-        self._dynamic_spectra_as_dBb = None # reset cache
+        self._dynamic_spectra_dBb = None # reset cache
         self._background_spectrum = None # reset cache
         self._start_background = start_background
         self._end_background = end_background
@@ -228,14 +256,13 @@ class Spectrogram:
     
     def _update_background_indices_from_interval(self) -> None:
         start_background = datetime.strptime(self._start_background, TimeFormats.DATETIME)
+        end_background   = datetime.strptime(self._end_background, TimeFormats.DATETIME)
         self._start_background_index = find_closest_index(start_background, 
                                                           self.datetimes, 
                                                           enforce_strict_bounds=True)
-        
-        end_background = datetime.strptime(self._end_background, TimeFormats.DATETIME)
-        self._end_background_index = find_closest_index(end_background, 
-                                                        self.datetimes, 
-                                                        enforce_strict_bounds=True)
+        self._end_background_index   = find_closest_index(end_background, 
+                                                          self.datetimes, 
+                                                          enforce_strict_bounds=True)
 
 
     def _check_shapes(self) -> None:
@@ -253,19 +280,14 @@ class Spectrogram:
         
 
     def save(self) -> None:
-        chunk_parent_path = get_chunks_dir_path(year  = self.chunk_start_datetime.year,
-                                                month = self.chunk_start_datetime.month,
-                                                day   = self.chunk_start_datetime.day)
-        file_name = f"{self.chunk_start_time}_{self._tag}.fits"
-        write_path = os.path.join(chunk_parent_path, 
-                                  file_name)
-        _save_spectrogram(write_path, self)
+        """Save the spectrogram as a fits file."""
+        _save_spectrogram(self)
     
 
     def integrate_over_frequency(self, 
                                  correct_background: bool = False, 
                                  peak_normalise: bool = False) -> np.ndarray[np.float32]:
-        
+        """Return the dynamic spectra, numerically integrated over frequency."""
         # integrate over frequency
         I = np.trapz(self._dynamic_spectra, self._frequencies, axis=0)
 
@@ -282,10 +304,12 @@ class Spectrogram:
                           at_time: float | str,
                           dBb: bool = False,
                           peak_normalise: bool = False) -> FrequencyCut:
-        
-        # it is important to note that the "at time" specified by the user likely does not correspond
-        # exactly to one of the times assigned to each spectrogram. So, we compute the nearest achievable,
-        # and return it from the function as output too.
+        """Get a cut of the dynamic spectra at a particular instant of time.
+
+        It is important to note that the 'at_time' as specified at input may not correspond exactly
+        to one of the times assigned to each spectrogram. 
+        """
+
         if isinstance(at_time, str):
             at_time = datetime.strptime(at_time, TimeFormats.DATETIME)
             index_of_cut = find_closest_index(at_time, 
@@ -303,7 +327,7 @@ class Spectrogram:
             raise ValueError(f"Type of at_time is unsupported: {type(at_time)}")
         
         if dBb:
-            ds = self.dynamic_spectra_as_dBb
+            ds = self.dynamic_spectra_dBb
         else:
             ds = self._dynamic_spectra
         
@@ -328,10 +352,11 @@ class Spectrogram:
                      peak_normalise = False, 
                      correct_background = False, 
                      return_time_type: str = TimeTypes.SECONDS) -> TimeCut:
-        
-        # it is important to note that the "at frequency" specified by the user likely does not correspond
-        # exactly to one of the physical frequencies assigned to each spectral component. So, we compute the nearest achievable,
-        # and return it from the function as output too.
+        """Get a cut of the dynamic spectra at a particular frequency.
+
+        It is important to note that the 'at_frequency' as specified at input may not correspond exactly
+        to one of the times assigned to each spectrogram. 
+        """
         index_of_cut = find_closest_index(at_frequency, 
                                           self._frequencies, 
                                           enforce_strict_bounds = True)
@@ -346,7 +371,7 @@ class Spectrogram:
 
         # dependent on the requested cut type, we return the dynamic spectra in the preferred units
         if dBb:
-            ds = self.dynamic_spectra_as_dBb
+            ds = self.dynamic_spectra_dBb
         else:
             ds = self.dynamic_spectra
         
@@ -379,9 +404,18 @@ def _seconds_of_day(dt: datetime) -> float:
 
 
 # Function to create a FITS file with the specified structure
-def _save_spectrogram(write_path: str, 
-                      spectrogram: Spectrogram) -> None:
+def _save_spectrogram(spectrogram: Spectrogram) -> None:
+    
+    # making the write path
+    batch_parent_path = get_batches_dir_path(year  = spectrogram.start_datetime.year,
+                                             month = spectrogram.start_datetime.month,
+                                             day   = spectrogram.start_datetime.day)
+    # file name formatted as a batch file
+    file_name = f"{spectrogram.format_start_time()}_{spectrogram.tag}.fits"
+    write_path = os.path.join(batch_parent_path, 
+                                file_name)
     
+    # get optional metadata from the capture config
     capture_config = CaptureConfig(spectrogram.tag)
     ORIGIN    = capture_config.get_parameter_value(PNames.ORIGIN)
     INSTRUME  = capture_config.get_parameter_value(PNames.INSTRUMENT)

spectre_core/spectrograms/_transform.py

@@ -11,13 +11,6 @@ from spectre_core.config import TimeFormats
 from ._array_operations import find_closest_index, average_array
 from ._spectrogram import Spectrogram
 
-__all__ = [
-    "frequency_chop",
-    "time_chop",
-    "frequency_average",
-    "time_average",
-    "join_spectrograms"
-]
 
 def frequency_chop(input_spectrogram: Spectrogram, 
                    start_frequency: float | int, 
@@ -50,9 +43,8 @@ def frequency_chop(input_spectrogram: Spectrogram,
                        input_spectrogram.times,
                        transformed_frequencies,
                        input_spectrogram.tag,
-                       chunk_start_time = input_spectrogram.chunk_start_time,
-                       microsecond_correction = input_spectrogram.microsecond_correction,
-                       spectrum_type = input_spectrogram.spectrum_type)
+                       input_spectrogram.start_datetime,
+                       input_spectrogram.spectrum_type)
 
 
 def time_chop(input_spectrogram: Spectrogram, 
@@ -84,9 +76,6 @@ def time_chop(input_spectrogram: Spectrogram,
 
     # compute the new start datetime following the time chop
     transformed_start_datetime = input_spectrogram.datetimes[start_index]
-    # compute the microsecond correction, and chunk start time
-    transformed_chunk_start_time = datetime.strftime(transformed_start_datetime, TimeFormats.DATETIME)
-    transformed_microsecond_correction = transformed_start_datetime.microsecond
 
     # chop the times array
     transformed_times = input_spectrogram.times[start_index:end_index+1]
@@ -97,8 +86,7 @@ def time_chop(input_spectrogram: Spectrogram,
                        transformed_times, 
                        input_spectrogram.frequencies, 
                        input_spectrogram.tag, 
-                       chunk_start_time = transformed_chunk_start_time,
-                       microsecond_correction = transformed_microsecond_correction,
+                       start_time = transformed_start_datetime,
                        spectrum_type = input_spectrogram.spectrum_type)
 
 
@@ -107,8 +95,8 @@ def time_average(input_spectrogram: Spectrogram,
                  average_over: Optional[int] = None) -> Spectrogram:
 
     # spectre does not currently support averaging of non-datetime assigned spectrograms
-    if input_spectrogram.chunk_start_time is None:
-        raise ValueError(f"Input spectrogram is missing chunk start time. Averaging is not yet supported for non-datetime assigned spectrograms")
+    if not input_spectrogram.start_datetime_is_set:
+        raise NotImplementedError(f"Time averaging is not yet supported for spectrograms without an assigned datetime.")
     
     # if nothing is specified, do nothing
     if (resolution is None) and (average_over is None):
@@ -130,28 +118,26 @@ def time_average(input_spectrogram: Spectrogram,
 
     # average the dynamic spectra array
     transformed_dynamic_spectra = average_array(input_spectrogram.dynamic_spectra, 
-                                                 average_over, 
-                                                 axis=1)
+                                                average_over, 
+                                                axis=1)
 
     # We need to assign timestamps to the averaged spectrums in the spectrograms. 
     # The natural way to do this is to assign the i'th averaged spectrogram 
     # to the i'th averaged time
     transformed_times = average_array(input_spectrogram.times, average_over)
     
-    # find the new chunk start time, which we will assign to the first spectrum after averaging
-    corrected_start_datetime = input_spectrogram.datetimes[0] + timedelta(seconds = float(transformed_times[0]))
-    transformed_chunk_start_time = corrected_start_datetime.strftime(TimeFormats.DATETIME)
-    transformed_microsecond_correction = corrected_start_datetime.microsecond
+    # find the new batch start time, which we will assign to the first spectrum after averaging
+    transformed_start_datetime = input_spectrogram.datetimes[0] + timedelta(seconds = float(transformed_times[0]))
 
     # finally, translate the averaged time seconds to begin at t=0 [s]
     transformed_times -= transformed_times[0]
+    
     return Spectrogram(transformed_dynamic_spectra, 
                        transformed_times, 
                        input_spectrogram.frequencies, 
                        input_spectrogram.tag,
-                       chunk_start_time = transformed_chunk_start_time,
-                       microsecond_correction = transformed_microsecond_correction,
-                       spectrum_type = input_spectrogram.spectrum_type)
+                       transformed_start_datetime,
+                       input_spectrogram.spectrum_type)
 
 
 
@@ -189,9 +175,8 @@ def frequency_average(input_spectrogram: Spectrogram,
                        input_spectrogram.times, 
                        transformed_frequencies, 
                        input_spectrogram.tag,
-                       chunk_start_time = input_spectrogram.chunk_start_time, 
-                       microsecond_correction = input_spectrogram.microsecond_correction,
-                       spectrum_type = input_spectrogram.spectrum_type)
+                       input_spectrogram.start_datetime,
+                       input_spectrogram.spectrum_type)
 
 
 def _time_elapsed(datetimes: np.ndarray) -> np.ndarray:
@@ -203,7 +188,7 @@ def _time_elapsed(datetimes: np.ndarray) -> np.ndarray:
     return np.array(elapsed_time, dtype=np.float32)
 
 
-# we assume that the spectrogram list is ORDERED chronologically
+# we assume that the spectrogram list is ordered chronologically
 # we assume there is no time overlap in any of the spectrograms in the list
 def join_spectrograms(spectrograms: list[Spectrogram]) -> Spectrogram:
 
@@ -224,9 +209,8 @@ def join_spectrograms(spectrograms: list[Spectrogram]) -> Spectrogram:
             raise ValueError(f"All tags must be equal for each spectrogram in the input list!")
         if spectrogram.spectrum_type != reference_spectrogram.spectrum_type:
             raise ValueError(f"All units must be equal for each spectrogram in the input list!")
-        if spectrogram.chunk_start_time is None:
-            raise ValueError(f"All spectrograms must have chunk_start_time set. Received {spectrogram.chunk_start_time}")
-
+        if not spectrogram.start_datetime_is_set:
+            raise ValueError(f"All spectrograms must have their start datetime set.")
 
     # build a list of the time array of each spectrogram in the list
     conc_datetimes = np.concatenate([s.datetimes for s in spectrograms])
@@ -249,6 +233,5 @@ def join_spectrograms(spectrograms: list[Spectrogram]) -> Spectrogram:
                        transformed_times, 
                        reference_spectrogram.frequencies, 
                        reference_spectrogram.tag, 
-                       chunk_start_time = reference_spectrogram.chunk_start_time,
-                       microsecond_correction = reference_spectrogram.microsecond_correction,
-                       spectrum_type = reference_spectrogram.spectrum_type) 
+                       reference_spectrogram.start_datetime,
+                       reference_spectrogram.spectrum_type) 

spectre_core/wgetting/_callisto.py

@@ -9,7 +9,7 @@ import gzip
 from datetime import datetime
 from typing import Optional
 
-from spectre_core.config import get_spectre_data_dir_path, get_chunks_dir_path, TimeFormats
+from spectre_core.config import get_spectre_data_dir_path, get_batches_dir_path, TimeFormats
 
 CALLISTO_INSTRUMENT_CODES = [
     "ALASKA-ANCHORAGE",
@@ -70,13 +70,13 @@ CALLISTO_INSTRUMENT_CODES = [
 _temp_dir = os.path.join(get_spectre_data_dir_path(), "temp")
 
 
-def _get_chunk_name(station: str, date: str, time: str, instrument_code: str) -> str:
+def _get_batch_name(station: str, date: str, time: str, instrument_code: str) -> str:
     dt = datetime.strptime(f"{date}T{time}", '%Y%m%dT%H%M%S')
     formatted_time = dt.strftime(TimeFormats.DATETIME)
     return f"{formatted_time}_callisto-{station.lower()}-{instrument_code}.fits"
 
 
-def _get_chunk_components(gz_path: str):
+def _get_batch_components(gz_path: str):
     file_name = os.path.basename(gz_path)
     if not file_name.endswith(".fit.gz"):
         raise ValueError(f"Unexpected file extension in {file_name}. Expected .fit.gz")
@@ -89,29 +89,29 @@ def _get_chunk_components(gz_path: str):
     return parts
 
 
-def _get_chunk_path(gz_path: str) -> str:
-    station, date, time, instrument_code = _get_chunk_components(gz_path)
-    fits_chunk_name = _get_chunk_name(station, date, time, instrument_code)
-    chunk_start_time = fits_chunk_name.split('_')[0]
-    chunk_start_datetime = datetime.strptime(chunk_start_time, TimeFormats.DATETIME)
-    chunk_parent_path = get_chunks_dir_path(year = chunk_start_datetime.year,
-                                            month = chunk_start_datetime.month,
-                                            day = chunk_start_datetime.day)
-    if not os.path.exists(chunk_parent_path):
-        os.makedirs(chunk_parent_path)
-    return os.path.join(chunk_parent_path, fits_chunk_name)
+def _get_batch_path(gz_path: str) -> str:
+    station, date, time, instrument_code = _get_batch_components(gz_path)
+    fits_batch_name = _get_batch_name(station, date, time, instrument_code)
+    batch_start_time = fits_batch_name.split('_')[0]
+    batch_start_datetime = datetime.strptime(batch_start_time, TimeFormats.DATETIME)
+    batch_parent_path = get_batches_dir_path(year = batch_start_datetime.year,
+                                            month = batch_start_datetime.month,
+                                            day = batch_start_datetime.day)
+    if not os.path.exists(batch_parent_path):
+        os.makedirs(batch_parent_path)
+    return os.path.join(batch_parent_path, fits_batch_name)
 
 
-def _unzip_file_to_chunks(gz_path: str):
-    fits_path = _get_chunk_path(gz_path)
+def _unzip_file_to_batches(gz_path: str):
+    fits_path = _get_batch_path(gz_path)
     with gzip.open(gz_path, 'rb') as f_in, open(fits_path, 'wb') as f_out:
         shutil.copyfileobj(f_in, f_out)
 
 
-def _unzip_to_chunks():
+def _unzip_to_batches():
     for entry in os.scandir(_temp_dir):
         if entry.is_file() and entry.name.endswith('.gz'):
-            _unzip_file_to_chunks(entry.path)
+            _unzip_file_to_batches(entry.path)
             os.remove(entry.path)
 
 
@@ -128,11 +128,7 @@ def _wget_callisto_data(instrument_code: str,
         '-P', _temp_dir,
         base_url
     ]
-
-    try:
-        subprocess.run(command, check=True)
-    except subprocess.CalledProcessError as e:
-        print(f"An error occurred: {e}")
+    subprocess.run(command, check=True)
 
 
 def download_callisto_data(instrument_code: Optional[str], 
@@ -151,5 +147,5 @@ def download_callisto_data(instrument_code: Optional[str],
         raise ValueError(f"No match found for '{instrument_code}'. Expected one of {CALLISTO_INSTRUMENT_CODES}")
 
     _wget_callisto_data(instrument_code, year, month, day)
-    _unzip_to_chunks()
+    _unzip_to_batches()
     shutil.rmtree(_temp_dir)

{spectre_core-0.0.11.dist-info → spectre_core-0.0.12.dist-info}/METADATA

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