musica 0.10.1__cp38-cp38-macosx_11_0_arm64.whl → 0.11.1.0__cp38-cp38-macosx_11_0_arm64.whl

musica/tools/prepare_build_environment_linux.sh

@@ -0,0 +1,41 @@
+#! /bin/bash
+
+set -e
+set -x
+
+# Update the mirror list to use vault.centos.org
+sed -i s/mirror.centos.org/vault.centos.org/g /etc/yum.repos.d/*.repo
+sed -i s/^#.*baseurl=http/baseurl=http/g /etc/yum.repos.d/*.repo
+sed -i s/^mirrorlist=http/#mirrorlist=http/g /etc/yum.repos.d/*.repo
+
+sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
+sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
+
+yum install -y zip tree
+
+# Use CIBW_ARCHS or CIBW_ARCH if set, else fallback to uname -m
+if [ -n "$CIBW_ARCHS" ]; then
+  target_arch="$CIBW_ARCHS"
+elif [ -n "$CIBW_ARCH" ]; then
+  target_arch="$CIBW_ARCH"
+else
+  target_arch="$(uname -m)"
+fi
+
+echo "Detected target_arch: $target_arch"
+
+if [ "$target_arch" = "x86_64" ]; then
+  # Install CUDA 12.2 for x86_64:
+  yum-config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo
+  # error mirrorlist.centos.org doesn't exists anymore.
+  sed -i s/mirror.centos.org/vault.centos.org/g /etc/yum.repos.d/*.repo
+  sed -i s/^#.*baseurl=http/baseurl=http/g /etc/yum.repos.d/*.repo
+  sed -i s/^mirrorlist=http/#mirrorlist=http/g /etc/yum.repos.d/*.repo
+  yum install --setopt=obsoletes=0 -y \
+      cuda-nvcc-12-2-12.2.140-1 \
+      cuda-cudart-devel-12-2-12.2.140-1 \
+      libcurand-devel-12-2-10.3.3.141-1 \
+      libcublas-devel-12-2-12.2.5.6-1 \
+      libnccl-devel-2.19.3-1+cuda12.2
+  ln -s cuda-12.2 /usr/local/cuda
+fi

musica/tools/prepare_build_environment_windows.sh

@@ -0,0 +1,22 @@
+#! /bin/bash
+
+set -e
+set -x
+
+CUDA_ROOT="C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v12.8"
+# curl --netrc-optional -L -nv -o cuda.exe https://developer.download.nvidia.com/compute/cuda/12.2.2/local_installers/cuda_12.2.2_537.13_windows.exe
+curl --netrc-optional -L -nv -o cuda.exe https://developer.download.nvidia.com/compute/cuda/12.8.1/local_installers/cuda_12.8.1_572.61_windows.exe
+./cuda.exe -s nvcc_12.8 cudart_12.8 cublas_dev_12.8 curand_dev_12.8 
+rm cuda.exe
+
+export CUDA_PATH="/c/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v12.8"
+export PATH="$CUDA_PATH/bin:$PATH"
+
+ls "c/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v12.8/extras/visual_studio_integration/MSBuildExtensions"
+ls "c/Program Files (x86)/Microsoft Visual Studio/"
+
+# choco install cuda 
+
+ls "$CUDA_PATH"
+ls "$CUDA_PATH/bin"
+which nvcc.exe

musica/tools/repair_wheel_gpu.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -e
+
+auditwheel repair --exclude libcublas --exclude libcublasLt --exclude libcudart -w "$2" "$1"
+
+for whl in "$2"/*.whl; do
+  tmpdir=$(mktemp -d)
+  unzip -q "$whl" -d "$tmpdir"
+  tree "$tmpdir"
+  echo "Before patchelf:"
+  readelf -d "$tmpdir"/_musica*.so
+  patchelf --remove-rpath "$tmpdir"/_musica*.so
+  patchelf --set-rpath "\$ORIGIN:\$ORIGIN/../../nvidia/cublas/lib:\$ORIGIN/../../nvidia/cuda_runtime/lib" --force-rpath "$tmpdir"/_musica*.so
+  # Remove bundled CUDA libraries
+  rm -f "$tmpdir"/musica.libs/libcudart-*.so*
+  rm -f "$tmpdir"/musica.libs/libcublas-*.so*
+  rm -f "$tmpdir"/musica.libs/libcublasLt-*.so*
+  echo "After patchelf:"
+  readelf -d "$tmpdir"/_musica*.so
+  # Repack the wheel with correct structure
+  (cd "$tmpdir" && zip -qr "${whl%.whl}.patched.whl" .)
+  rm -rf "$tmpdir"
+  # Replace the original wheel with the patched one
+  mv "${whl%.whl}.patched.whl" "$whl"
+done

musica/types.py

@@ -0,0 +1,362 @@
+# Copyright (C) 2023-2025 University Corporation for Atmospheric Research
+# SPDX-License-Identifier: Apache-2.0
+#
+# This file is part of the musica Python package.
+# For more information, see the LICENSE file in the top-level directory of this distribution.
+from typing import Optional, Any, Dict, List, Union, Tuple
+from os import PathLike
+import math
+from _musica._core import (
+    _Conditions,
+    _SolverType,
+    _Solver,
+    _State,
+    _create_solver,
+    _create_solver_from_mechanism,
+    _create_state,
+    _micm_solve,
+    _vector_size,
+    _species_ordering,
+    _user_defined_rate_parameters_ordering,
+)
+import musica.mechanism_configuration as mc
+
+AVOGADRO = 6.02214076e23  # mol^-1
+BOLTZMANN = 1.380649e-23  # J K^-1
+GAS_CONSTANT = AVOGADRO * BOLTZMANN  # J K^-1 mol^-1
+
+FilePath = Union[str, "PathLike[str]"]
+
+
+def _get_vector_matrix_indices(row_index: int, column_index: int, vector_size: int) -> Tuple[int, int]:
+    """
+    Get the row and column indices for a matrix given the row and column indices for a vector.
+
+    Parameters
+    ----------
+    row_index : int
+        Row index of the vector.
+    column_index : int
+        Column index of the vector.
+    vector_size : int
+        Size of the vector.
+
+    Returns
+    -------
+    tuple[int, int]
+        Index for which state matrix to use and the index in that matrix'x underlying data vector.
+    """
+    return (row_index // vector_size, column_index * (vector_size - 1) + row_index % vector_size)
+
+
+class Conditions(_Conditions):
+    """
+    Conditions class for the MICM solver. If air density is not provided,
+    it will be calculated from the Ideal Gas Law using the provided temperature and pressure.
+
+    Parameters
+    ----------
+    temperature : float
+        Temperature in Kelvin.
+    pressure : float
+        Pressure in Pascals.
+    air_density : float
+        Air density in mol m-3
+    """
+
+    def __init__(
+        self,
+        temperature: Optional[Union[float, int]] = None,
+        pressure: Optional[Union[float, int]] = None,
+        air_density: Optional[Union[float, int]] = None,
+    ):
+        super().__init__()
+        if temperature is not None:
+            self.temperature = temperature
+        if pressure is not None:
+            self.pressure = pressure
+        if air_density is not None:
+            self.air_density = air_density
+        elif temperature is not None and pressure is not None:
+            self.air_density = 1.0 / (GAS_CONSTANT * temperature / pressure)
+
+
+class SolverType(_SolverType):
+    """
+    Enum class for the type of solver to use.
+    """
+
+
+class State():
+    """
+    State class for the MICM solver. It contains the initial conditions and species concentrations.
+    """
+
+    def __init__(self, solver: _Solver, number_of_grid_cells: int, vector_size: int = 0):
+        if number_of_grid_cells < 1:
+            raise ValueError("number_of_grid_cells must be greater than 0.")
+        super().__init__()
+        self.__states = [
+            _create_state(solver, min(vector_size, number_of_grid_cells - i * vector_size))
+            for i in range(math.ceil(number_of_grid_cells / vector_size))
+        ] if vector_size > 0 else [_create_state(solver, number_of_grid_cells)]
+        self.__species_ordering = _species_ordering(self.__states[0])
+        self.__user_defined_rate_parameters_ordering = _user_defined_rate_parameters_ordering(self.__states[0])
+        self.__number_of_grid_cells = number_of_grid_cells
+        self.__vector_size = vector_size
+
+    def get_internal_states(self) -> List[_State]:
+        """
+        Get the internal states of the MICM solver.
+
+        Returns
+        -------
+        List[_State]
+            List of internal states.
+        """
+        return self.__states
+
+    def set_concentrations(self, concentrations: Dict[str, Union[Union[float, int], List[Union[float, int]]]]):
+        """
+        Set the concentrations of the species in the state. Any species not in the
+        dictionary will be set to zero. The concentrations can be a single value when solving
+        for a single grid cell, or a list of values when solving for multiple grid cells.
+
+        Parameters
+        ----------
+        concentrations : Dict[str, Union[Union[float, int], List[Union[float, int]]]]
+            Dictionary of species names and their concentrations.
+        """
+        for name, value in concentrations.items():
+            if name not in self.__species_ordering:
+                raise ValueError(f"Species {name} not found in the mechanism.")
+            i_species = self.__species_ordering[name]
+            if isinstance(value, float) or isinstance(value, int):
+                value = [value]
+            if len(value) != self.__number_of_grid_cells:
+                raise ValueError(f"Concentration list for {name} must have length {self.__number_of_grid_cells}.")
+            # Counter 'k' is used to map grid cell indices across multiple state segments.
+            k = 0
+            for state in self.__states:
+                cell_stride, species_stride = state.concentration_strides()
+                for i_cell in range(state.number_of_grid_cells()):
+                    state.concentrations[i_species * species_stride + i_cell * cell_stride] = value[k]
+                    k += 1
+
+    def set_user_defined_rate_parameters(
+            self, user_defined_rate_parameters: Dict[str, Union[Union[float, int], List[Union[float, int]]]]):
+        """
+        Set the user-defined rate parameters in the state. Any parameter not in the
+        dictionary will be set to zero. The parameters can be a single value when solving
+        for a single grid cell, or a list of values when solving for multiple grid cells.
+
+        Parameters
+        ----------
+        user_defined_rate_parameters : Dict[str, Union[Union[float, int], List[Union[float, int]]]]
+            Dictionary of user-defined rate parameter names and their values.
+        """
+        for name, value in user_defined_rate_parameters.items():
+            if name not in self.__user_defined_rate_parameters_ordering:
+                raise ValueError(f"User-defined rate parameter {name} not found in the mechanism.")
+            i_param = self.__user_defined_rate_parameters_ordering[name]
+            if isinstance(value, float) or isinstance(value, int):
+                value = [value]
+            if len(value) != self.__number_of_grid_cells:
+                raise ValueError(
+                    f"User-defined rate parameter list for {name} must have length {self.__number_of_grid_cells}.")
+            # Initialize `k` to index the grid cells when assigning user-defined rate parameters.
+            k = 0
+            for state in self.__states:
+                cell_stride, param_stride = state.user_defined_rate_parameter_strides()
+                for i_cell in range(state.number_of_grid_cells()):
+                    state.user_defined_rate_parameters[i_param * param_stride + i_cell * cell_stride] = value[k]
+                    k += 1
+
+    def set_conditions(self,
+                       temperatures: Union[Union[float, int], List[Union[float, int]]],
+                       pressures: Union[Union[float, int], List[Union[float, int]]],
+                       air_densities: Optional[Union[Union[float, int], List[Union[float, int]]]] = None):
+        """
+        Set the conditions for the state. The individual conditions can be a single value
+        when solving for a single grid cell, or a list of values when solving for multiple grid cells.
+        If air density is not provided, it will be calculated from the Ideal Gas Law using the provided
+        temperature and pressure.
+
+        Parameters
+        ----------
+        temperatures : Union[float, List[float]]
+            Temperature in Kelvin.
+        pressures : Union[float, List[float]]
+            Pressure in Pascals.
+        air_densities : Optional[Union[float, List[float]]]
+            Air density in mol m-3. If not provided, it will be calculated from the Ideal Gas Law.
+        """
+        if isinstance(temperatures, float) or isinstance(temperatures, int):
+            if self.__number_of_grid_cells > 1:
+                raise ValueError(f"temperatures must be a list of length {self.__number_of_grid_cells}.")
+            temperatures = [temperatures]
+        if isinstance(pressures, float) or isinstance(pressures, int):
+            if self.__number_of_grid_cells > 1:
+                raise ValueError(f"pressures must be a list of length {self.__number_of_grid_cells}.")
+            pressures = [pressures]
+        if air_densities is not None and (isinstance(air_densities, float) or isinstance(air_densities, int)):
+            if self.__number_of_grid_cells > 1:
+                raise ValueError(f"air_densities must be a list of length {self.__number_of_grid_cells}.")
+            air_densities = [air_densities]
+        if len(temperatures) != self.__number_of_grid_cells:
+            raise ValueError(f"temperatures must be a list of length {self.__number_of_grid_cells}.")
+        if len(pressures) != self.__number_of_grid_cells:
+            raise ValueError(f"pressures must be a list of length {self.__number_of_grid_cells}.")
+        if air_densities is not None and len(air_densities) != self.__number_of_grid_cells:
+            raise ValueError(f"air_densities must be a list of length {self.__number_of_grid_cells}.")
+        k = 0
+        for state in self.__states:
+            for condition in state.conditions:
+                condition.temperature = temperatures[k]
+                condition.pressure = pressures[k]
+                condition.air_density = air_densities[k] if air_densities is not None else pressures[k] / (
+                    GAS_CONSTANT * temperatures[k])
+                k += 1
+
+    def get_concentrations(self) -> Dict[str, List[float]]:
+        """
+        Get the concentrations of the species in the state.
+
+        Returns
+        -------
+        Dict[str, List[float]]
+            Dictionary of species names and their concentrations.
+        """
+        concentrations = {}
+        for species, i_species in self.__species_ordering.items():
+            concentrations[species] = []
+            for state in self.__states:
+                cell_stride, species_stride = state.concentration_strides()
+                for i_cell in range(state.number_of_grid_cells()):
+                    concentrations[species].append(
+                        state.concentrations[i_species * species_stride + i_cell * cell_stride])
+        return concentrations
+
+    def get_user_defined_rate_parameters(self) -> Dict[str, List[float]]:
+        """
+        Get the user-defined rate parameters in the state.
+
+        Returns
+        -------
+        Dict[str, List[float]]
+            Dictionary of user-defined rate parameter names and their values.
+        """
+        user_defined_rate_parameters = {}
+        for param, i_param in self.__user_defined_rate_parameters_ordering.items():
+            user_defined_rate_parameters[param] = []
+            for state in self.__states:
+                cell_stride, param_stride = state.user_defined_rate_parameter_strides()
+                for i_cell in range(state.number_of_grid_cells()):
+                    user_defined_rate_parameters[param].append(
+                        state.user_defined_rate_parameters[i_param * param_stride + i_cell * cell_stride])
+        return user_defined_rate_parameters
+
+    def get_conditions(self) -> Dict[str, List[float]]:
+        """
+        Get the conditions for the state.
+
+        Returns
+        -------
+        Dict[str, List[float]]
+            Dictionary of conditions names and their values.
+        """
+        conditions = {}
+        conditions["temperature"] = []
+        conditions["pressure"] = []
+        conditions["air_density"] = []
+        for state in self.__states:
+            for i_cell in range(state.number_of_grid_cells()):
+                conditions["temperature"].append(state.conditions[i_cell].temperature)
+                conditions["pressure"].append(state.conditions[i_cell].pressure)
+                conditions["air_density"].append(state.conditions[i_cell].air_density)
+        return conditions
+
+
+class MICM():
+    """
+    The MICM class is a wrapper around the C++ MICM solver. It provides methods to create a solver,
+    create a state, and solve the system of equations.
+
+    Parameters
+    ----------
+    config_path : FilePath
+        Path to the configuration file.
+    mechanism : mechanism_configuration.Mechanism
+        Mechanism object which specifies the chemical mechanism to use.
+    solver_type : SolverType
+        Type of solver to use.
+    number_of_grid_cells : int
+        Number of grid cells to use. The default is 1.
+    """
+
+    def __init__(
+        self,
+        config_path: FilePath = None,
+        mechanism: mc.Mechanism = None,
+        solver_type: _SolverType = None,
+    ):
+        self.__solver_type = solver_type
+        self.__vector_size = _vector_size(solver_type)
+        if config_path is None and mechanism is None:
+            raise ValueError("Either config_path or mechanism must be provided.")
+        if config_path is not None and mechanism is not None:
+            raise ValueError("Only one of config_path or mechanism must be provided.")
+        if config_path is not None:
+            self.__solver = _create_solver(config_path, solver_type)
+        elif mechanism is not None:
+            self.__solver = _create_solver_from_mechanism(mechanism, solver_type)
+
+    def solver_type(self) -> SolverType:
+        """
+        Get the type of solver used.
+
+        Returns
+        -------
+        SolverType
+            The type of solver used.
+        """
+        return self.__solver_type
+
+    def create_state(self, number_of_grid_cells: int = 1) -> State:
+        """
+        Create a new state object.
+
+        Returns
+        -------
+        State
+            A new state object.
+        """
+        return State(self.__solver, number_of_grid_cells, self.__vector_size)
+
+    def solve(
+            self,
+            state: State,
+            time_step: float,
+    ):
+        """
+        Solve the system of equations for the given state and time step.
+
+        Parameters
+        ----------
+        state : State
+            State object containing the initial conditions.
+        time_step : float
+            Time step in seconds.
+
+        Returns
+        -------
+        State
+            Updated state object after solving the system of equations.
+        """
+        if not isinstance(state, State):
+            raise TypeError("state must be an instance of State.")
+        if not isinstance(time_step, (int, float)):
+            raise TypeError("time_step must be an int or float.")
+        states = state.get_internal_states()
+        for _, _state in enumerate(states):
+            _micm_solve(self.__solver, _state, time_step)

{musica-0.10.1.dist-info → musica-0.11.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: musica
-Version: 0.10.1
+Version: 0.11.1.0
 Summary: MUSICA is a Python library for performing computational simulations in atmospheric chemistry.
 Author-Email: Matthew Dawsom <mattdawson@ucar.edu>, Jiwon Gim <jiwongim@ucar.edu>, David Fillmore <fillmore@ucar.edu>, Kyle Shores <kshores@ucar.edu>, Montek Thind <mthind@ucar.edu>
 Maintainer-Email: ACOM MUSICA Developers <musica-support@ucar.edu>
@@ -209,6 +209,10 @@ License:                                  Apache License
 Project-URL: homepage, https://wiki.ucar.edu/display/MUSICA/MUSICA+Home
 Provides-Extra: test
 Requires-Dist: numpy; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: gpu
+Requires-Dist: nvidia-cublas-cu12; extra == "gpu"
+Requires-Dist: nvidia-cuda-runtime-cu12; extra == "gpu"
 Description-Content-Type: text/markdown
 
 # MUSICA
@@ -222,6 +226,7 @@ Description-Content-Type: text/markdown
 [![DOI](https://zenodo.org/badge/550370528.svg)](https://zenodo.org/doi/10.5281/zenodo.7458559)
 [![PyPI version](https://badge.fury.io/py/musica.svg)](https://pypi.org/p/musica)
 [![FAIR checklist badge](https://fairsoftwarechecklist.net/badge.svg)](https://fairsoftwarechecklist.net/v0.2?f=31&a=32113&i=22322&r=123)
+[![codecov](https://codecov.io/gh/NCAR/musica/branch/main/graph/badge.svg)](https://codecov.io/gh/NCAR/musica)
 
 Multi-Scale Infrastructure for Chemistry and Aerosols
 
@@ -274,6 +279,22 @@ Specifying a specific version of `tuv-x` by has, but using the official reposito
         -DTUVX_GIT_TAG=a6b2c4d8745
 
 
+### Python build
+Musica has python bindings. If you want to install the python package, you may `pip install musica`.
+
+To build the package locally,
+
+```
+pip install -e .
+```
+
+If you have an NVIDIA GPU and cuda installed, you can enable a build of musica with GPU support by setting the environment 
+variable `BUILD_GPU`.
+
+```
+BUILD_GPU=1 pip install -e .
+```
+
 ## Citing MUSICA
 
 MUSICA can be cited in at least two ways. The first is to cite [the paper](https://doi.org/10.1175/BAMS-D-19-0331.1) that defines the vision

musica-0.11.1.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+_musica.cpython-38-darwin.so,sha256=eGG4qDwVwcI1fMrAvvhxANXOL0ocXNobl7ZyuBsAB6o,1693200
+musica-0.11.1.0.dist-info/RECORD,,
+musica-0.11.1.0.dist-info/WHEEL,sha256=lkMk8TmLjB7Q3RmWWjXHvovliuXltvdURemb10hs9ig,112
+musica-0.11.1.0.dist-info/METADATA,sha256=TBJI5PEajWEcPSut2_1k4J6NL2tA9EH-iPLwgCRecHo,20814
+musica-0.11.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lib/libyaml-cpp.a,sha256=92HOQacR9IxfClvaT0_ohp86czur70fKtMTJqUfpKhA,795856
+lib/libmusica.a,sha256=qB7XASy-w1m3aCssUQJUCvFKglS1Lv_guXTT1WO3Xc8,1355336
+musica/CMakeLists.txt,sha256=FJkD0MaB1qUNDpyCsjELAW4wpuSslfzyo-YCJwLkIp4,1128
+musica/mechanism_configuration.py,sha256=pma248L_jjQecsxL9zIn-S4KxXNlSL1NL4LB4fN5jV0,58011
+musica/binding.cpp,sha256=zDD_TQ7icS_lNG7iUAp23VG7_odbptGJbtRdYjalsdc,656
+musica/_version.py,sha256=suv06oJaea_7HQaaHK99o4t0k3p-d4OKHaDzvMpoHOU,21
+musica/__init__.py,sha256=CW7SVuK4kO8bYg8wB56YGun-NBRmBqWQO379qP21Yvo,82
+musica/types.py,sha256=WQYTDT3aZQVvCyXmaEGuBYqtdx3IZk1Ao5bcmPUGzXM,14895
+musica/mechanism_configuration.cpp,sha256=E7GGeftgQGL303nsk2C7pwYpPiMAQcuxdbadohHb1QM,27100
+musica/musica.cpp,sha256=BBRtL9_Q62ia_vhmpTqpnHHGimPBpCR5YVth8x0i0h4,8399
+musica/tools/prepare_build_environment_windows.sh,sha256=zMY_RIerqfMC1VlfpZ2KjjDWfBUOvvx8oRNk_jJhmII,826
+musica/tools/prepare_build_environment_linux.sh,sha256=9rkT0bTVmu9QQqhS6eGRX1HXMQZLfkUGakkC3i5VKec,1466
+musica/tools/repair_wheel_gpu.sh,sha256=PHWls1cS9QOElQDIgSMOh7TkHB8UNylZbls9zSjSus0,917
+musica/test/test_parser.py,sha256=VhOPNrcDnFGgk2v_iMoLNq5JBP22VbkHTHLk3N09d3s,24292
+musica/test/test_chapman.py,sha256=Wm0wLy6E1Zm8p6cLaICQO9tSy_szMkYn9E7MPCtobno,3070
+musica/test/tuvx.py,sha256=rWvBcG6cgLJylqkf8M0MFMKT2AkyoaZlGdaKjVSbCR8,116
+musica/test/test_analytical.py,sha256=5rIlpy5bzpTfZNv8wAND8O5KA8Wvh3Bm64pTRRlSHgc,13775
+musica/test/examples/v1/full_configuration.yaml,sha256=s9Go7AQv9OFQ7zVb1k4wmDj2vpHYzVCTRqi8JZTHlUM,5235
+musica/test/examples/v1/full_configuration.json,sha256=7AqPhTHodSjtV8LOPoUsA9MtCu_Xc28RVOlhNGPI9GQ,8807
+musica/test/examples/v0/species.json,sha256=xKTcwh9QV9sRjLPK9GvGEnatBrRPbP857NmPG0bCXqU,565
+musica/test/examples/v0/species.yaml,sha256=vUYTs7bp2AYVWHDgXBFxnCkmqdO6ysJ_ulOQTAoKa1M,283
+musica/test/examples/v0/config.json,sha256=7s6g5jxH2GiEiRcZmO13IJ5k4walg1C9t-dQr9o45U4,79
+musica/test/examples/v0/config.yaml,sha256=GgA18mP8ZCzOdY-AlAePK48M05PJFPeWCk-IfrPN_VE,44
+musica/test/examples/v0/reactions.json,sha256=7WJhItBPtGu89vLcPMK6izW8BvwUAIjfzqwjtDmfPPg,4188
+musica/test/examples/v0/reactions.yaml,sha256=uEuQOz5i7vGyn0G7KsmdWv23V2Gn0QUmexrK030CFlo,2266

{musica-0.10.1.dist-info → musica-0.11.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: scikit-build-core 0.11.1
+Generator: scikit-build-core 0.11.3
 Root-Is-Purelib: false
 Tag: cp38-cp38-macosx_11_0_arm64
 

musica-0.10.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-musica.cpython-38-darwin.so,sha256=-fTbByuC4gAtSxeFZrfxatLTvmbf5br6LV0vqJ5_lGw,1241288
-musica-0.10.1.dist-info/RECORD,,
-musica-0.10.1.dist-info/WHEEL,sha256=e866hv7yNJ_T12xjD8b55JO_Epn_ySKlJm4M2IOihtU,112
-musica-0.10.1.dist-info/METADATA,sha256=5j_JfxNTlmq43d2Ws6rDP35rXNJkeq95JOh6QQ1-lR4,20175
-musica-0.10.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lib/libyaml-cpp.a,sha256=WdFFkdiWcbfizpmPlB52Cgose79IXd81sD6HpunZqdM,785784
-lib/libmechanism_configuration.a,sha256=i_j-v_qbdDD2hNxJ3r8Sqc0YKdNZAChK7nnI1Bbe2lQ,3132280
-lib/libmusica.a,sha256=zG3MISDgwx7ccIWqHtfBEraFGDWuMa98Mct5PEy8_PA,1178800
-musica/_version.py,sha256=TS3rWSOiZ_xuWK-IU2nr-GbcS7ljUU8ZbQnp_IRge9A,19