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

spectre_core/file_handlers/configs.py

@@ -1,271 +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 Any, Optional, Type, Tuple
-from abc import ABC
-import ast
-
-from spectre_core.file_handlers.json import JsonHandler
-from spectre_core.cfg import CONFIGS_DIR_PATH
-from spectre_core.exceptions import InvalidTagError
-
-
-def _unpack_param(param: str) -> list[str, str]:
-    """Seperate a string of the form "a=b" into a list [a,b]."""
-    if not param or '=' not in param:
-        raise ValueError(f'Invalid format: "{param}". Expected "KEY=VALUE".')
-    if param.startswith('=') or param.endswith('='):
-        raise ValueError(f'Invalid format: "{param}". Expected "KEY=VALUE".')
-    # remove leading and trailing whitespace.
-    param = param.strip()
-    return param.split('=', 1)
-
-
-def _params_to_string_dict(params: list[str]) -> dict[str, str]:
-    """Converts a list with string elements of the form "a=b" into a dictionary where the key value pairs are "a": "b"."""
-    d = {}
-    for param in params:
-        key, value = _unpack_param(param)
-        d[key] = value
-    return d
-
-
-def _convert_to_dict(v: str) -> dict:
-    """Evaluate literally a string containing a Python dictionary expression."""
-    return ast.literal_eval(v)
-
-
-def _convert_to_bool(v: str) -> bool:
-    """Evaluate literally a string representation of a boolean as a boolean"""
-    v = v.lower()
-    if v in ('true', '1', 't', 'y', 'yes'):
-        return True
-    if v in ('false', '0', 'f', 'n', 'no'):
-        return False
-    raise ValueError(f'Cannot convert {v} to bool.')
-    
-
-def _convert_string_to_type(value: str, 
-                           target_type: Type) -> Any:
-    """Cast a string as the target type."""
-    if target_type == bool:
-        return _convert_to_bool(value)
-    elif target_type == dict:
-        return _convert_to_dict(value)
-    return target_type(value)
-
-
-def _type_cast_string_dict(d: dict[str, str], 
-                           type_template: dict[str, Type]) -> dict[str, Any]:
-    """Cast the values of the input dictionary according to a type template."""
-    casted_d = {}
-    for key, value in d.items():
-        target_type = type_template.get(key)
-        if target_type is None:
-            raise KeyError(f'Key "{key}" not found in type template. Expected keys: {list(type_template.keys())}')
-        try:
-            casted_d[key] = _convert_string_to_type(value, target_type)
-        except ValueError:
-            raise ValueError(f'Failed to convert key "{key}" with value "{value}" to {target_type.__name__}.')
-    return casted_d
-
-
-def _validate_keys(d: dict[str, Any], 
-                   type_template: dict[str, type], 
-                   ignore_keys: Optional[list] = None) -> None:
-    """Validate that the keys in the input dictionary map one-to-one to the input type template."""
-    if ignore_keys is None:
-        ignore_keys = []
-
-    type_template_keys = set(type_template.keys())
-    input_keys = set(d.keys())
-    ignore_keys = set(ignore_keys)
-
-    missing_keys = type_template_keys - input_keys
-    invalid_keys = input_keys - type_template_keys - ignore_keys
-
-    errors = []
-    
-    if missing_keys:
-        errors.append(f"Missing keys: {', '.join(missing_keys)}")
-
-    if invalid_keys:
-        errors.append(f"Invalid keys: {', '.join(invalid_keys)}")
-    
-    if errors:
-        raise KeyError("Key errors found! " + " ".join(errors))
-
-
-def _validate_types(d: dict[str, Any], 
-                    type_template: dict[str, type], 
-                    ignore_keys: Optional[list] = None) -> None:
-    """Validate the types in the input dictionary are consistent with the input type template."""
-
-    if ignore_keys is None:
-        ignore_keys = []
-        
-    for k, v in d.items():
-        if k in ignore_keys:
-            continue
-        expected_type = type_template[k]
-        if expected_type is None:
-            raise KeyError(f'Type not found for key "{k}" in the type template.')
-        
-        if not isinstance(v, expected_type):
-            raise TypeError(f'Expected {expected_type} for "{k}", but got {type(v)}.')
-
-
-def validate_against_type_template(d: dict[str, Any], 
-                                   type_template: dict[str, type], 
-                                   ignore_keys: Optional[list] = None) -> None:
-    """Validates the keys and values of the input dictionary, according to the input type template."""
-    _validate_keys(d, 
-                   type_template, 
-                   ignore_keys = ignore_keys)
-    _validate_types(d, 
-                    type_template, 
-                    ignore_keys = ignore_keys)
-
-
-def type_cast_params(params: list[str], 
-                     type_template: dict[str, type]) -> dict[str, Any]:
-    d = _params_to_string_dict(params)
-    return _type_cast_string_dict(d, 
-                                  type_template)
-
-
-
-class SPECTREConfig(JsonHandler, ABC):
-    def __init__(self, 
-                 tag: str, 
-                 config_type: str, 
-                 **kwargs):
-        self._validate_tag(tag)
-        self._tag = tag
-        self._config_type = config_type
-
-        self._dict = None # cache
-        super().__init__(CONFIGS_DIR_PATH, 
-                         f"{config_type}_{tag}", 
-                         **kwargs)
-
-
-    @property
-    def tag(self) -> str:
-        return self._tag
-    
-
-    @property
-    def config_type(self) -> str:
-        return self._config_type
-    
-
-    @property
-    def dict(self) -> dict[str, Any]:
-        if self._dict is None:
-            self._dict = self.read()
-        return self._dict
-    
-
-    def _validate_tag(self, tag: str) -> None:
-        if "_" in tag:
-            raise InvalidTagError(f"Tags cannot contain an underscore. Received {tag}")
-        if "callisto" in tag:
-            raise InvalidTagError(f'"callisto" cannot be a substring in a native tag. Received "{tag}"')
-
-    
-    def __getitem__(self, 
-                    key: str) -> Any:
-        return self.dict[key]
-    
-
-    def get(self, 
-            *args, 
-            **kwargs) -> Any:
-        return self.dict.get(*args, 
-                             **kwargs)
-    
-    
-    def update(self, 
-               *args, 
-               **kwargs) -> None:
-        self.dict.update(*args, **kwargs)
-
-    
-    def items(self):
-        return self.dict.items()
-    
-    
-    def keys(self):
-        return self.dict.keys()
-    
-    
-    def values(self):
-        return self.dict.values()
-
-
-class FitsConfig(SPECTREConfig):
-
-    type_template = {
-        "ORIGIN": str,
-        "TELESCOP": str,
-        "INSTRUME": str,
-        "OBJECT": str,
-        "OBS_LAT": float,
-        "OBS_LONG": float,
-        "OBS_ALT": float
-    }
-
-    def __init__(self, 
-                 tag: str, 
-                 **kwargs):
-        super().__init__(tag, 
-                         "fits", 
-                         **kwargs)
-
-    def get_create_fits_config_cmd(self, 
-                                   tag: str, 
-                                   as_string: bool = False) -> list[str] | str:
-        command_as_list = ["spectre", "create", "fits-config", "-t", tag]
-        for key, value in self.type_template.items():
-            command_as_list += ["-p"]
-            command_as_list += [f"{key}={value.__name__}"]
-        if as_string:
-            return " ".join(command_as_list)
-        else:
-            return command_as_list
-        
-
-    def save_params(self, 
-                    params: list[str], 
-                    force: bool = False
-                    ) -> None:
-        d = type_cast_params(params, 
-                             self.type_template)
-        validate_against_type_template(d, 
-                                       self.type_template)
-        self.save(d, 
-                  force = force)
-        
-    
-class CaptureConfig(SPECTREConfig):
-    def __init__(self, 
-                 tag: str, 
-                 **kwargs):
-        super().__init__(tag, 
-                         "capture", 
-                         **kwargs)
-        
-
-    def get_receiver_metadata(self) -> Tuple[str, str]:
-
-        receiver_name, mode = self.get("receiver"), self.get("mode")
-
-        if receiver_name is None:
-            raise ValueError("Invalid capture config! Receiver name is not specified.")
-    
-        if mode is None:
-            raise ValueError("Invalid capture config! Receiver mode is not specified.")
-        
-        return receiver_name, mode

spectre_core/file_handlers/json.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 typing import Any
-import json
-
-from spectre_core.file_handlers.base import BaseFileHandler
-
-class JsonHandler(BaseFileHandler):
-    def __init__(self, 
-                 parent_path: str, 
-                 base_file_name: str,
-                 extension: str = "json",
-                 **kwargs):
-        super().__init__(parent_path, 
-                         base_file_name, 
-                         extension,
-                         **kwargs)
-    
-    
-    def read(self) -> dict[str, Any]:
-        with open(self.file_path, 'r') as f:
-            return json.load(f)
-        
-
-    def save(self, 
-             d: dict, 
-             force: bool = False) -> None:
-        self.make_parent_path()
-
-        if self.exists:
-            if force:
-                pass
-            else:
-                raise RuntimeError((f"{self.file_name} already exists, write has been abandoned. "
-                                    f"You can override this functionality with `force`"))
-
-        with open(self.file_path, 'w') as file:
-                json.dump(d, file, indent=4)

spectre_core/file_handlers/text.py

@@ -1,21 +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 spectre_core.file_handlers.base import BaseFileHandler
-
-class TextHandler(BaseFileHandler):
-    def __init__(self, 
-                 parent_path: str,
-                 base_file_name: str, 
-                 extension: str = "txt",
-                 **kwargs):
-        super().__init__(parent_path,
-                         base_file_name,
-                         extension, 
-                         **kwargs)
-    
-
-    def read(self) -> dict:
-        with open(self.file_path, 'r') as f:
-            return f.read()

spectre_core/plotting/factory.py

@@ -1,26 +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 spectre_core.spectrograms.spectrogram import Spectrogram
-from spectre_core.plotting.base import BasePanel
-from spectre_core.plotting.panel_register import panels
-from spectre_core.exceptions import PanelNotFoundError
-
-def get_panel(panel_name: str, 
-              spectrogram: Spectrogram,
-              time_type: str,
-              *args, 
-              **kwargs) -> BasePanel:
-   
-    Panel = panels.get(panel_name)
-    if Panel is None:
-        valid_panels = list(panels.keys())
-        raise PanelNotFoundError(f"Could not find panel with name {panel_name}. "
-                                 f"Expected one of {valid_panels}")
-    
-    return Panel(panel_name,
-                 spectrogram, 
-                 time_type,
-                 *args, 
-                 **kwargs)

spectre_core/plotting/format.py

@@ -1,19 +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 dataclasses import dataclass
-
-@dataclass
-class DefaultFormats:
-    small_size: int = 18
-    medium_size: int = 21
-    large_size: int = 24
-    line_width: int = 3
-    style: str = "dark_background"
-    spectrogram_cmap: str = "gnuplot2"
-    cuts_cmap: str = "winter"
-    integral_over_frequency_color: str = "lime"
-
-
-DEFAULT_FORMATS = DefaultFormats()

spectre_core/plotting/library/__init__.py

@@ -1,7 +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 spectre_core.dynamic_imports import import_target_modules
-
-import_target_modules(__file__, __name__, "panel")

spectre_core/plotting/library/frequency_cuts/panel.py

@@ -1,74 +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 datetime import datetime
-
-from spectre_core.spectrograms.spectrogram import FrequencyCut
-from spectre_core.spectrograms.spectrogram import Spectrogram
-from spectre_core.plotting.base import BaseSpectrumPanel, CutsPanel
-from spectre_core.plotting.panel_register import register_panel
-from spectre_core.plotting.format import DEFAULT_FORMATS
-
-FREQUENCY_CUTS_PANEL_NAME = "frequency_cuts"
-
-@register_panel(FREQUENCY_CUTS_PANEL_NAME)
-class Panel(BaseSpectrumPanel, CutsPanel):
-    def __init__(self, 
-                 name: str,
-                 spectrogram: Spectrogram, 
-                 time_type: str = "seconds",
-                 *times: list[float | str],
-                 dBb: bool = False,
-                 peak_normalise: bool = False,
-                 cmap: str = DEFAULT_FORMATS.cuts_cmap,
-                 **kwargs):
-        super().__init__(name, 
-                         spectrogram, 
-                         time_type, 
-                         **kwargs)
-        self._times = times
-        self._cmap = cmap
-        self._dBb = dBb
-        self._peak_normalise = peak_normalise
-        # map each time cut to the corresponding FrequencyCut dataclass
-        self._frequency_cuts: Optional[dict[float | datetime, FrequencyCut]] = {}
-
-
-    @property
-    def frequency_cuts(self) -> dict[float | str, FrequencyCut]:
-        if not self._frequency_cuts:
-            for time in self._times:
-                frequency_cut = self._spectrogram.get_frequency_cut(time,
-                                                                    dBb = self._dBb,
-                                                                    peak_normalise = self._peak_normalise)
-                self._frequency_cuts[frequency_cut.time] = frequency_cut
-        return self._frequency_cuts
-
-
-    @property
-    def times(self) -> list[float | datetime]:
-        return list(self.frequency_cuts.keys())
-    
-
-    def draw(self):
-        for time, color in self.bind_to_colors():
-            frequency_cut = self.frequency_cuts[time]
-            self.ax.step(self.frequencies*1e-6, # convert to MHz
-                         frequency_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.times, cmap = self._cmap)

spectre_core/plotting/library/integral_over_frequency/panel.py

@@ -1,34 +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 spectre_core.plotting.base import BaseTimeSeriesPanel
-from spectre_core.plotting.panel_register import register_panel
-from spectre_core.plotting.format import DEFAULT_FORMATS
-
-INTEGRAL_OVER_FREQUENCY_PANEL_NAME = "integral_over_frequency"
-
-@register_panel(INTEGRAL_OVER_FREQUENCY_PANEL_NAME)
-class Panel(BaseTimeSeriesPanel):
-    def __init__(self, 
-                 *args, 
-                 peak_normalise: bool = False,
-                 background_subtract: bool = False,
-                 color: str = DEFAULT_FORMATS.integral_over_frequency_color,
-                 **kwargs):
-        super().__init__(*args, **kwargs)
-        self._peak_normalise = peak_normalise
-        self._background_subtract = background_subtract
-        self._color = color
-
-
-    def draw(self):
-        I = self._spectrogram.integrate_over_frequency(correct_background = self._background_subtract,
-                                                       peak_normalise = self._peak_normalise)
-        self.ax.step(self.times, I, where="mid", color = self._color)
- 
-
-    def annotate_y_axis(self):
-        return # no y-axis label
-
-    

spectre_core/plotting/library/spectrogram/panel.py

@@ -1,92 +0,0 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
-# This file is part of SPECTRE
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import numpy as np
-from matplotlib.colors import LogNorm
-from matplotlib.figure import Figure
-from matplotlib.axes import Axes
-from warnings import warn
-
-from spectre_core.plotting.base import BaseTimeSeriesPanel
-from spectre_core.plotting.panel_register import register_panel
-from spectre_core.plotting.base import CutsPanel
-from spectre_core.plotting.library.time_cuts.panel import Panel as TimeCutsPanel
-from spectre_core.plotting.library.frequency_cuts.panel import Panel as FrequencyCutsPanel
-from spectre_core.plotting.format import DEFAULT_FORMATS
-
-SPECTROGRAM_PANEL_NAME = "spectrogram"
-
-@register_panel(SPECTROGRAM_PANEL_NAME)
-class Panel(BaseTimeSeriesPanel):
-    def __init__(self, 
-                 *args, 
-                 log_norm: bool = False,
-                 dBb: bool = False,
-                 vmin: float | None = -1,
-                 vmax: float | None = 2,
-                 cmap: str = DEFAULT_FORMATS.spectrogram_cmap,
-                 **kwargs):
-        super().__init__(*args, **kwargs)
-        self._log_norm = log_norm
-        self._dBb = dBb
-        self._vmin = vmin
-        self._vmax = vmax
-        self._cmap = cmap
-
-
-    def draw(self):
-        dynamic_spectra = self._spectrogram.dynamic_spectra_as_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
-        
-
-        if self._log_norm and (self._vmin or self._vmax):
-            warn("vmin/vmax will be ignored while using log_norm.")
-            self._vmin = None 
-            self._vmax = None
-        
-        # Plot the spectrogram with kwargs
-        pcm = self.ax.pcolormesh(self.times, 
-                            self._spectrogram.frequencies * 1e-6, 
-                            dynamic_spectra,
-                            vmin=self._vmin, 
-                            vmax=self._vmax,
-                            norm=norm, 
-                            cmap=self._cmap)
-        
-        # Add colorbar if dBb is used
-        if self._dBb:
-            cbar = self.fig.colorbar(pcm, 
-                                      ax=self.ax, 
-                                      ticks=np.linspace(self._vmin, self._vmax, 6, dtype=int))
-            cbar.set_label('dBb')
-
-
-    def annotate_y_axis(self) -> None:
-        self.ax.set_ylabel('Frequency [MHz]')
-        return
-    
-    
-    def overlay_cuts(self, cuts_panel: CutsPanel) -> None:
-        if isinstance(cuts_panel, TimeCutsPanel):
-            self._overlay_time_cuts(cuts_panel)
-        elif isinstance(cuts_panel, FrequencyCutsPanel):
-            self._overlay_frequency_cuts(cuts_panel)
-
-
-    def _overlay_time_cuts(self, time_cuts_panel: TimeCutsPanel) -> None:
-        for frequency, color in time_cuts_panel.bind_to_colors():
-            self.ax.axhline(frequency*1e-6, # convert to MHz
-                            color = color,
-                            linewidth=DEFAULT_FORMATS.line_width
-                            )
-            
-            
-    def _overlay_frequency_cuts(self, frequency_cuts_panel: FrequencyCutsPanel) -> None:
-        for time, color in frequency_cuts_panel.bind_to_colors():
-            self.ax.axvline(time,
-                            color = color,
-                            linewidth=DEFAULT_FORMATS.line_width
-                            )

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