astroemu 0.1.2__tar.gz

astroemu-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Harry Bevins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

astroemu-0.1.2/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: astroemu
+Version: 0.1.2
+Summary: Generalised framework for emulating spectral signals.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jax
+Requires-Dist: jaxlib
+Requires-Dist: torch
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Dynamic: license-file
+
+# Next Generation Emulators for Cosmology and Astrophysics
+
+| | |
+|---| ---|
+| Author| Harry Bevins|
+| Version| 0.1.2 |
+| Homepage | https://github.com/htjb/astroemu |
+
+UNDER DEVELOPMENT
+
+`astroemu` implements a generalized framework for emulating 
+spectral signals
+and is inspired by the [`globalemu`](https://github.com/htjb/globalemu) package.
+
+The neural network emulators are implemented in JAX and the dataloaders are
+built on top of PyTorch.
+
+As with `globalemu` the idea is to input the independent variables alongside 
+the physical parameters of your model then predicting a single corresponding 
+spectral value. Full spectra can then be generated via a vectorised call to 
+the network. The training data is tiled in the dataloaders so that the 
+parameters and independent variables are concatenated as inputs and
+stacked up alongside the outputs. For example if we have a signal 
+$y = f(x, \theta)$ and we have N $\theta$ samples and m $x$ and $y$ values then
+our training data looks like
+
+|Input|Output|
+|--|--|
+|[$\theta_{0}$, $x_0$]| $y_0$ |
+|[$\theta_{0}$, $x_1$]| $y_1$ |
+|[$\theta_{0}$, $x_2$]| $y_2$ |
+|[$\theta_{0}$, ...]|...|
+|[$\theta_{0}$, $x_m$]|$y_m$|
+|[..., ...]| ...|
+|[$\theta_N$, $x_m$]|$y_m$|
+
+For more details see the `globalemu` [paper](https://arxiv.org/abs/2104.04336).
+A paper is in preparation demonstrating applications of this package to a broad 
+range of astrophysical signals.
+
+## Contributions
+
+Contributions are welcome! Please open an issue to discuss and have a 
+read of the Contribution guidelines.

astroemu-0.1.2/README.md

@@ -0,0 +1,44 @@
+# Next Generation Emulators for Cosmology and Astrophysics
+
+| | |
+|---| ---|
+| Author| Harry Bevins|
+| Version| 0.1.2 |
+| Homepage | https://github.com/htjb/astroemu |
+
+UNDER DEVELOPMENT
+
+`astroemu` implements a generalized framework for emulating 
+spectral signals
+and is inspired by the [`globalemu`](https://github.com/htjb/globalemu) package.
+
+The neural network emulators are implemented in JAX and the dataloaders are
+built on top of PyTorch.
+
+As with `globalemu` the idea is to input the independent variables alongside 
+the physical parameters of your model then predicting a single corresponding 
+spectral value. Full spectra can then be generated via a vectorised call to 
+the network. The training data is tiled in the dataloaders so that the 
+parameters and independent variables are concatenated as inputs and
+stacked up alongside the outputs. For example if we have a signal 
+$y = f(x, \theta)$ and we have N $\theta$ samples and m $x$ and $y$ values then
+our training data looks like
+
+|Input|Output|
+|--|--|
+|[$\theta_{0}$, $x_0$]| $y_0$ |
+|[$\theta_{0}$, $x_1$]| $y_1$ |
+|[$\theta_{0}$, $x_2$]| $y_2$ |
+|[$\theta_{0}$, ...]|...|
+|[$\theta_{0}$, $x_m$]|$y_m$|
+|[..., ...]| ...|
+|[$\theta_N$, $x_m$]|$y_m$|
+
+For more details see the `globalemu` [paper](https://arxiv.org/abs/2104.04336).
+A paper is in preparation demonstrating applications of this package to a broad 
+range of astrophysical signals.
+
+## Contributions
+
+Contributions are welcome! Please open an issue to discuss and have a 
+read of the Contribution guidelines.

astroemu-0.1.2/astroemu/__init__.py

@@ -0,0 +1 @@
+"""init file for emu package."""

astroemu-0.1.2/astroemu/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

astroemu-0.1.2/astroemu/dataloaders.py

@@ -0,0 +1,154 @@
+"""Data loaders for emu package."""
+
+import jax.numpy as jnp
+import torch
+from torch.utils.data import Dataset
+
+from emu.normalisation import NormalisationPipeline
+
+
+def load_spectrum(file: str) -> dict:
+    """Load spectrum data from .npz file.
+
+    Args:
+        file (str): Path to .npz file.
+
+    Returns:
+        dict: Dictionary containing data from .npz file.
+    """
+    data = jnp.load(file)
+    input = {k: data[k] for k in data.files}
+    return input
+
+
+class SpectrumDataset(Dataset):
+    """Dataset for loading spectra from .npz files.
+
+    Allows for optional preprocessing via a forward pipeline and
+    selection of variable input parameters.
+    """
+
+    def __init__(
+        self,
+        files: list[str],
+        x: str,
+        y: str,
+        forward_pipeline: NormalisationPipeline | None = None,
+        variable_input: list[str] | str | None = None,
+    ) -> None:
+        """Initialize SpectrumDataset.
+
+        Args:
+            files (list[str]): List of file paths to .npz files.
+            x (str): Key for independent variable in .npz files.
+            y (str): Key for dependent variable in .npz files.
+            forward_pipeline (Any, optional): Preprocessing pipeline.
+                Defaults to None.
+            variable_input (list[str] | str | None, optional): Keys
+                for variable input parameters.
+                If None, all parameters except x and y are used.
+                Defaults to None.
+        """
+        self.files = files
+        self.varied_input = variable_input
+        self.forward_pipeline = forward_pipeline
+        self.x = x
+        self.y = y
+
+    def __len__(self) -> int:
+        """Return number of files in dataset."""
+        return len(self.files)
+
+    def __getitem__(self, idx: int) -> tuple[torch.Tensor, torch.Tensor]:
+        """Get spectrum and input parameters for given index.
+
+        Args:
+            idx (int): Index of the data point.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]: Tuple of (spectrum,
+                input parameters).
+        """
+        input = load_spectrum(self.files[idx])
+        x = torch.tensor(input[self.x])
+        y = torch.tensor(input[self.y])
+        if self.varied_input:
+            input = torch.tensor(
+                [input[k].item() for k in self.varied_input],
+                dtype=torch.float32,
+            )
+        else:
+            input = torch.tensor(
+                [
+                    input[k].item()
+                    for k in sorted(input.keys())
+                    if k not in [self.x, self.y]
+                ],
+                dtype=torch.float32,
+            )
+        input = torch.tile(
+            input, (y.shape[0], 1)
+        )  # Ensure input shape matches spec
+        input = torch.cat(
+            [x[:, None], input], axis=1
+        )  # Concatenate wavelength with parameters
+        if self.forward_pipeline:
+            return self.forward_pipeline.forward(y, input)
+        else:
+            return y, input
+
+
+class NormalizeSpectrumDataset(SpectrumDataset):
+    """Dataset for loading and normalizing spectra from .npz files.
+
+    Applies a super forward pipeline followed by a normalization pipeline.
+    """
+
+    def __init__(
+        self,
+        files: list[str],
+        x: str,
+        y: str,
+        forward_pipeline: NormalisationPipeline | None = None,
+        super_forward_pipeline: NormalisationPipeline | None = None,
+        variable_input: list[str] | str | None = None,
+    ) -> None:
+        """Initialize NormalizeSpectrumDataset.
+
+        Args:
+            files (list[str]): List of file paths to .npz files.
+            x (str): Key for independent variable in .npz files.
+            y (str): Key for dependent variable in .npz files.
+            forward_pipeline (Any, optional): Normalization pipeline.
+                Defaults to None.
+            super_forward_pipeline (Any, optional): Preprocessing pipeline.
+                Defaults to None.
+            variable_input (list[str] | str | None, optional): Keys
+                for variable input parameters.
+                If None, all parameters except x and y are used.
+                Defaults to None.
+        """
+        super().__init__(
+            files,
+            x,
+            y,
+            forward_pipeline=super_forward_pipeline,
+            variable_input=variable_input,
+        )
+        self.normalize_pipeline = forward_pipeline
+
+    def __getitem__(self, idx: int) -> tuple[torch.Tensor, torch.Tensor]:
+        """Get normalized spectrum and input parameters for given index.
+
+        Args:
+            idx (int): Index of the data point.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]: Tuple of (normalized spectrum,
+                input parameters).
+        """
+        y, input = super().__getitem__(idx)
+        if self.normalize_pipeline:
+            return self.normalize_pipeline.forward(y, input)
+        else:
+            return y, input

astroemu-0.1.2/astroemu/network.py

@@ -0,0 +1,88 @@
+"""Neural network implementations for emu package."""
+
+import jax
+import jax.numpy as jnp
+from jax import random
+
+
+def initialise_mlp(
+    in_size: int,
+    out_size: int,
+    hidden_size: int,
+    nlayers: int,
+    key: int,
+    scale: float = 1e-1,
+) -> dict:
+    """Initialize MLP parameters.
+
+    Args:
+        in_size (int): Input size.
+        out_size (int): Output size.
+        hidden_size (int): Hidden layer size.
+        nlayers (int): Number of hidden layers.
+        key (int): JAX random key.
+        scale (float, optional): Scale for weight initialization.
+            Defaults to 1e-1.
+
+    Returns:
+        dict: MLP parameters.
+    """
+    keys = random.split(key, nlayers * 2 + 2 + 2)
+    weights = (
+        [
+            {
+                "weights" + str(0): scale
+                * random.normal(keys[0], (in_size, hidden_size)),
+                "bias" + str(0): scale
+                * random.normal(keys[1], (hidden_size,)),
+            }
+        ]
+        + [
+            {
+                "weights" + str(i + 1): scale
+                * random.normal(keys[i + 2], (hidden_size, hidden_size)),
+                "bias" + str(i + 1): scale
+                * random.normal(keys[i + 3], (hidden_size,)),
+            }
+            for i in range(nlayers)
+        ]
+        + [
+            {
+                "weights" + str(nlayers + 1): scale
+                * random.normal(keys[-2], (hidden_size, out_size)),
+                "bias" + str(nlayers + 1): scale
+                * random.normal(keys[-1], (out_size,)),
+            }
+        ]
+    )
+    return {k: v for d in weights for k, v in d.items()}
+
+
+def mlp(params: dict, input: jnp.ndarray) -> jnp.ndarray:
+    """Multi-layer perceptron with residual connections.
+
+    Args:
+        params (dict): MLP parameters.
+        input (jnp.ndarray): Input array of shape [..., in_size].
+
+    Returns:
+        jnp.ndarray: Output array of shape [..., out_size].
+    """
+    act_fn = getattr(jax.nn, "relu")
+    num_layers = len(params) // 2  # total layers: input + hidden(s) + output
+
+    x = jnp.dot(input, params["weights0"]) + params["bias0"]
+
+    for i in range(1, num_layers - 1):  # exclude final output layer
+        residual = x
+        x = act_fn(x)
+        x = jnp.dot(x, params[f"weights{i}"]) + params[f"bias{i}"]
+        # Residual connection (only if shapes match)
+        x += residual
+
+    # Final layer: linear only, no activation
+    output = (
+        jnp.dot(x, params[f"weights{num_layers - 1}"])
+        + params[f"bias{num_layers - 1}"]
+    )
+    return output

astroemu-0.1.2/astroemu/normalisation.py

@@ -0,0 +1,164 @@
+"""Normalisation pipelines for emu package."""
+
+import torch
+
+
+class NormalisationPipeline:
+    """Base class for normalisation pipelines."""
+
+    def forward(
+        self, y: torch.Tensor, x: torch.Tensor | None = None
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        """Apply forward transformation."""
+        raise NotImplementedError
+
+    def backward(
+        self, y: torch.Tensor, x: torch.Tensor | None = None
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        """Apply backward transformation."""
+        raise NotImplementedError
+
+
+class standardise(NormalisationPipeline):
+    """Standardisation normalisation pipeline."""
+
+    def __init__(
+        self,
+        y_mean: torch.Tensor,
+        y_std: torch.Tensor,
+        x_mean: torch.Tensor,
+        x_std: torch.Tensor,
+    ) -> None:
+        """Standardises the spectrum and input parameters.
+
+        Args:
+            y_mean (float): Mean of the spectrum for standardisation.
+            y_std (float): Standard deviation of the spectrum for
+                standardisation.
+            x_mean (float): Mean of the input parameters for standardisation.
+            x_std (float): Standard deviation of the input parameters
+                for standardisation.
+
+        Returns:
+            tuple: Standardised spectrum and input parameters.
+        """
+        self.y_mean = y_mean
+        self.y_std = y_std
+        self.x_mean = x_mean
+        self.x_std = x_std
+
+    def forward(
+        self, y: torch.Tensor, x: torch.Tensor | None = None
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        """Standardise the spectrum and input parameters.
+
+        Args:
+            y (torch.Tensor): Spectrum tensor.
+            x (torch.Tensor, optional): Input parameters tensor.
+            Defaults to None.
+
+        Returns:
+            tuple: Standardised spectrum and input parameters.
+        """
+        y = (y - self.y_mean) / self.y_std
+        if x is not None:
+            x = (x - self.x_mean) / self.x_std
+        return y, x
+
+    def backward(
+        self, y: torch.Tensor, x: torch.Tensor | None = None
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        """Destandardise the spectrum and input parameters.
+
+        Args:
+            y (torch.Tensor): Standardised spectrum tensor.
+            x (torch.Tensor, optional): Standardised input parameters tensor.
+                Defaults to None.
+
+        Returns:
+            tuple: Destandardised spectrum and input parameters.
+        """
+        y = y * self.y_std + self.y_mean
+        if x is not None:
+            x = x * self.x_std + self.x_mean
+        return y, x
+
+
+class log_base_10(NormalisationPipeline):
+    """Logarithm base 10 transformation for numerical stability."""
+
+    def __init__(
+        self,
+        yselector: list[int] | None = None,
+        xselector: list[int] | None = None,
+        eps: float = 1e-15,
+    ) -> None:
+        """Logarithm base 10 transformation for numerical stability.
+
+        Args:
+            yselector (list[int] | None): columns of the spectrum to
+                apply log transformation.
+                Assumes that the spectra are in the last dimension.
+            xselector (list[int] | None): columns of the input parameters to
+                apply log transformation.
+            eps (float): small value to add to avoid log(0).
+        """
+        self.yselector = yselector
+        self.xselector = xselector
+        self.eps = eps
+
+    def forward(
+        self, y: torch.Tensor, x: torch.Tensor | None = None
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        """Apply log10 transformation to selected columns.
+
+        Args:
+            y (torch.Tensor): Spectrum tensor.
+            x (torch.Tensor, optional): Input parameters tensor.
+                Defaults to None.
+
+        Returns:
+            tuple: Transformed spectrum and input parameters.
+        """
+        if x is not None:
+            if self.xselector is not None:
+                for i in self.xselector:
+                    x[..., i] = torch.log10(x[..., i] + self.eps)
+            else:
+                x = torch.log10(x + self.eps)
+
+        if self.yselector is not None:
+            for i in self.yselector:
+                y[..., i] = torch.log10(y[..., i] + self.eps)
+        else:
+            y = torch.log10(y + self.eps)
+
+        return y, x
+
+    def backward(
+        self, y: torch.Tensor, x: torch.Tensor | None = None
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        """Apply inverse log10 transformation to selected columns.
+
+        Args:
+            y (torch.Tensor): Transformed spectrum tensor.
+            x (torch.Tensor, optional): Transformed input parameters tensor.
+                Defaults to None.
+
+        Returns:
+            tuple: Inverse transformed spectrum and input parameters.
+        """
+        if x is not None:
+            if self.xselector is not None:
+                for i in self.xselector:
+                    x[..., i] = torch.pow(10, x[..., i]) - self.eps
+            else:
+                x = torch.pow(10, x) - self.eps
+
+        if self.yselector is not None:
+            for i in self.yselector:
+                y[..., i] = torch.pow(10, y[..., i]) - self.eps
+        else:
+            y = torch.pow(10, y) - self.eps
+
+        return y, x

astroemu-0.1.2/astroemu/utils.py

@@ -0,0 +1,83 @@
+"""Utility functions for emu package."""
+
+import torch
+
+
+def compute_mean_std(
+    loader: torch.utils.data.DataLoader,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Memory safe mean and std computation.
+
+    Args:
+        loader: DataLoader returning (spec, input) where:
+            - spec: [batch_size, 5000]
+            - input: [batch_size, 5000, N]
+
+    Returns:
+        mean_spec: [5000] - mean across batches
+        std_spec: [5000] - std across batches
+        mean_input: [N] - mean across batches and the 5000 dimension
+        std_input: [N] - std across batches and the 5000 dimension
+    """
+    # Accumulators
+    spec_sum = None
+    spec_sum_sq = None
+    input_sum = None
+    input_sum_sq = None
+    n_spec_samples = 0
+    n_input_samples = 0
+
+    for spec, input_data in loader:
+        batch_size = spec.size(0)
+
+        # === Process spec ===
+        # spec shape: [batch_size, 5000] -> we want stats across batch dim
+        if spec_sum is None:
+            spec_sum = torch.zeros(
+                spec.size(1), dtype=spec.dtype, device=spec.device
+            )
+            spec_sum_sq = torch.zeros(
+                spec.size(1), dtype=spec.dtype, device=spec.device
+            )
+
+        spec_sum += spec.sum(dim=0)  # sum across batch
+        spec_sum_sq += (spec**2).sum(dim=0)  # sum of squares across batch
+        n_spec_samples += batch_size
+
+        # === Process input ===
+        # input shape: [batch_size, 5000, N] -> we want stats across
+        # batch and 5000 dims
+        input_flat = input_data.view(
+            -1, input_data.size(-1)
+        )  # [batch_size * 5000, N]
+
+        if input_sum is None:
+            input_sum = torch.zeros(
+                input_data.size(-1),
+                dtype=input_data.dtype,
+                device=input_data.device,
+            )
+            input_sum_sq = torch.zeros(
+                input_data.size(-1),
+                dtype=input_data.dtype,
+                device=input_data.device,
+            )
+
+        input_sum += input_flat.sum(
+            dim=0
+        )  # sum across flattened batch*5000 dim
+        input_sum_sq += (input_flat**2).sum(dim=0)  # sum of squares
+        n_input_samples += input_flat.size(0)  # batch_size * 5000
+
+    # Compute means and stds
+    mean_spec = spec_sum / n_spec_samples
+    var_spec = (spec_sum_sq / n_spec_samples) - (mean_spec**2)
+    std_spec = torch.where(var_spec <= 1e-3, 1, torch.sqrt(var_spec))
+
+    mean_input = input_sum / n_input_samples
+    var_input = (input_sum_sq / n_input_samples) - (mean_input**2)
+    std_input = torch.sqrt(
+        torch.clamp(var_input, min=1e-8)
+    )  # clamp for numerical stability
+
+    return mean_spec, std_spec, mean_input, std_input

astroemu-0.1.2/astroemu.egg-info/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: astroemu
+Version: 0.1.2
+Summary: Generalised framework for emulating spectral signals.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jax
+Requires-Dist: jaxlib
+Requires-Dist: torch
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Dynamic: license-file
+
+# Next Generation Emulators for Cosmology and Astrophysics
+
+| | |
+|---| ---|
+| Author| Harry Bevins|
+| Version| 0.1.2 |
+| Homepage | https://github.com/htjb/astroemu |
+
+UNDER DEVELOPMENT
+
+`astroemu` implements a generalized framework for emulating 
+spectral signals
+and is inspired by the [`globalemu`](https://github.com/htjb/globalemu) package.
+
+The neural network emulators are implemented in JAX and the dataloaders are
+built on top of PyTorch.
+
+As with `globalemu` the idea is to input the independent variables alongside 
+the physical parameters of your model then predicting a single corresponding 
+spectral value. Full spectra can then be generated via a vectorised call to 
+the network. The training data is tiled in the dataloaders so that the 
+parameters and independent variables are concatenated as inputs and
+stacked up alongside the outputs. For example if we have a signal 
+$y = f(x, \theta)$ and we have N $\theta$ samples and m $x$ and $y$ values then
+our training data looks like
+
+|Input|Output|
+|--|--|
+|[$\theta_{0}$, $x_0$]| $y_0$ |
+|[$\theta_{0}$, $x_1$]| $y_1$ |
+|[$\theta_{0}$, $x_2$]| $y_2$ |
+|[$\theta_{0}$, ...]|...|
+|[$\theta_{0}$, $x_m$]|$y_m$|
+|[..., ...]| ...|
+|[$\theta_N$, $x_m$]|$y_m$|
+
+For more details see the `globalemu` [paper](https://arxiv.org/abs/2104.04336).
+A paper is in preparation demonstrating applications of this package to a broad 
+range of astrophysical signals.
+
+## Contributions
+
+Contributions are welcome! Please open an issue to discuss and have a 
+read of the Contribution guidelines.

astroemu-0.1.2/astroemu.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+astroemu/__init__.py
+astroemu/_version.py
+astroemu/dataloaders.py
+astroemu/network.py
+astroemu/normalisation.py
+astroemu/utils.py
+astroemu.egg-info/PKG-INFO
+astroemu.egg-info/SOURCES.txt
+astroemu.egg-info/dependency_links.txt
+astroemu.egg-info/requires.txt
+astroemu.egg-info/top_level.txt

astroemu-0.1.2/astroemu.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

astroemu-0.1.2/astroemu.egg-info/requires.txt

@@ -0,0 +1,7 @@
+jax
+jaxlib
+torch
+
+[dev]
+ruff
+pre-commit

astroemu-0.1.2/astroemu.egg-info/top_level.txt

@@ -0,0 +1 @@
+astroemu

astroemu-0.1.2/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "astroemu"
+version = "0.1.2"
+description = "Generalised framework for emulating spectral signals."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "jax",
+    "jaxlib",
+    "torch",
+]
+
+[build-system]
+requires = ["setuptools>=77.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["astroemu*"]
+
+[project.optional-dependencies]
+dev = [
+    "ruff",
+    "pre-commit",
+]
+
+[tool.ruff]
+line-length = 79
+
+[tool.ruff.lint]
+select =["E", "F", "W",  # basics
+            "I",            # isort
+            "D",            # docstrings
+            "UP",           # pyupgrade (includes type modernization)
+            "ANN",          # type annotations
+            ]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"

astroemu-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+