jinns 1.4.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

jinns/solver/_solve.py

@@ -14,7 +14,8 @@ import optax
 import jax
 from jax import jit
 import jax.numpy as jnp
-from jaxtyping import Float, Array
+from jaxtyping import Float, Array, PyTree, Key
+import equinox as eqx
 from jinns.solver._rar import init_rar, trigger_rar
 from jinns.utils._utils import _check_nan_in_pytree
 from jinns.solver._utils import _check_batch_size
@@ -29,7 +30,8 @@ from jinns.data._utils import append_param_batch, append_obs_batch
 
 if TYPE_CHECKING:
     from jinns.parameters._params import Params
-    from jinns.utils._types import AnyLoss, AnyBatch
+    from jinns.utils._types import AnyBatch
+    from jinns.loss._abstract_loss import AbstractLoss
     from jinns.validation._validation import AbstractValidationModule
     from jinns.data._DataGeneratorParameter import DataGeneratorParameter
     from jinns.data._DataGeneratorObservations import DataGeneratorObservations
@@ -37,7 +39,7 @@ if TYPE_CHECKING:
 
     main_carry: TypeAlias = tuple[
         int,
-        AnyLoss,
+        AbstractLoss,
         OptimizationContainer,
         OptimizationExtraContainer,
         DataGeneratorContainer,
@@ -45,6 +47,7 @@ if TYPE_CHECKING:
         LossContainer,
         StoredObjectContainer,
         Float[Array, " n_iter"] | None,
+        Key | None,
     ]
 
 
@@ -52,7 +55,7 @@ def solve(
     n_iter: int,
     init_params: Params[Array],
     data: AbstractDataGenerator,
-    loss: AnyLoss,
+    loss: AbstractLoss,
     optimizer: optax.GradientTransformation,
     print_loss_every: int = 1000,
     opt_state: optax.OptState | None = None,
@@ -63,14 +66,16 @@ def solve(
     obs_batch_sharding: jax.sharding.Sharding | None = None,
     verbose: bool = True,
     ahead_of_time: bool = True,
+    key: Key = None,
 ) -> tuple[
     Params[Array],
     Float[Array, " n_iter"],
-    dict[str, Float[Array, " n_iter"]],
+    PyTree,
     AbstractDataGenerator,
-    AnyLoss,
+    AbstractLoss,
     optax.OptState,
     Params[Array | None],
+    PyTree,
     Float[Array, " n_iter"] | None,
     Params[Array],
 ]:
@@ -141,6 +146,9 @@ def solve(
         transformed (see https://jax.readthedocs.io/en/latest/aot.html#aot-compiled-functions-cannot-be-transformed).
         When False, jinns does not provide any timing information (which would
         be nonsense in a JIT transformed `solve()` function).
+    key
+        Default None. A JAX random key that can be used for diverse purpose in
+        the main iteration loop.
 
     Returns
     -------
@@ -150,8 +158,8 @@ def solve(
     total_loss_values
         An array of the total loss term along the gradient steps
     stored_loss_terms
-        A dictionary. At each key an array of the values of a given loss
-        term is stored
+        A PyTree with attributes being arrays of all the values for each loss
+        term
     data
         The input data object
     loss
@@ -161,11 +169,20 @@ def solve(
     stored_params
         A Params objects with the stored values of the desired parameters (as
         signified in tracked_params argument)
+    stored_weights_terms
+        A PyTree with attributes being arrays of all the values for each loss
+        weight. Note that if Loss.update_weight_method is None, we return None,
+        because loss weights are never updated and we can then save some
+        computations
     validation_crit_values
         An array containing the validation criterion values of the training
     best_val_params
         The best parameters according to the validation criterion
     """
+    initialization_time = time.time()
+    if n_iter < 1:
+        raise ValueError("Cannot run jinns.solve for n_iter<1")
+
     if param_data is not None:
         if param_data.param_batch_size is not None:
             # We need to check that batch sizes will all be compliant for
@@ -209,11 +226,6 @@ def solve(
     # get_batch with device_put, the latter is not jittable
     get_batch = _get_get_batch(obs_batch_sharding)
 
-    # initialize the dict for stored parameter values
-    # we need to get a loss_term to init stuff
-    batch_ini, data, param_data, obs_data = get_batch(data, param_data, obs_data)
-    _, loss_terms = loss(init_params, batch_ini)
-
     # initialize parameter tracking
     if tracked_params is None:
         tracked_params = jax.tree.map(lambda p: None, init_params)
@@ -231,11 +243,45 @@ def solve(
         # being a complex data structure
     )
 
-    # initialize the dict for stored loss values
+    # initialize the dict for stored parameter values
+    # we need to get a loss_term to init stuff
+    # NOTE: we use jax.eval_shape to avoid FLOPS since we only need the tree
+    # structure
+    batch_ini, data, param_data, obs_data = get_batch(data, param_data, obs_data)
+    _, loss_terms = jax.eval_shape(loss, init_params, batch_ini)
+
+    # initialize the PyTree for stored loss values
     stored_loss_terms = jax.tree_util.tree_map(
         lambda _: jnp.zeros((n_iter)), loss_terms
     )
 
+    # initialize the PyTree for stored loss weights values
+    if loss.update_weight_method is not None:
+        stored_weights_terms = eqx.tree_at(
+            lambda pt: jax.tree.leaves(
+                pt, is_leaf=lambda x: x is not None and eqx.is_inexact_array(x)
+            ),
+            loss.loss_weights,
+            tuple(
+                jnp.zeros((n_iter))
+                for n in range(
+                    len(
+                        jax.tree.leaves(
+                            loss.loss_weights,
+                            is_leaf=lambda x: x is not None and eqx.is_inexact_array(x),
+                        )
+                    )
+                )
+            ),
+        )
+    else:
+        stored_weights_terms = None
+    if loss.update_weight_method is not None and key is None:
+        raise ValueError(
+            "`key` argument must be passed to jinns.solve when"
+            " `loss.update_weight_method` is not None"
+        )
+
     train_data = DataGeneratorContainer(
         data=data, param_data=param_data, obs_data=obs_data
     )
@@ -252,6 +298,7 @@ def solve(
     )
     loss_container = LossContainer(
         stored_loss_terms=stored_loss_terms,
+        stored_weights_terms=stored_weights_terms,
         train_loss_values=train_loss_values,
     )
     stored_objects = StoredObjectContainer(
@@ -276,6 +323,7 @@ def solve(
         loss_container,
         stored_objects,
         validation_crit_values,
+        key,
     )
 
     def _one_iteration(carry: main_carry) -> main_carry:
@@ -289,24 +337,47 @@ def solve(
             loss_container,
             stored_objects,
             validation_crit_values,
+            key,
         ) = carry
 
         batch, data, param_data, obs_data = get_batch(
             train_data.data, train_data.param_data, train_data.obs_data
         )
 
-        # Gradient step
+        # ---------------------------------------------------------------------
+        # The following part is the equivalent of a
+        # > train_loss_value, grads = jax.values_and_grad(total_loss.evaluate)(params, ...)
+        # but it is decomposed on individual loss terms so that we can use it
+        # if needed for updating loss weights.
+        # Since the total loss is a weighted sum of individual loss terms, so
+        # are its total gradients.
+
+        # Compute individual losses and individual gradients
+        loss_terms, grad_terms = loss.evaluate_by_terms(optimization.params, batch)
+
+        if loss.update_weight_method is not None:
+            key, subkey = jax.random.split(key)  # type: ignore because key can
+            # still be None currently
+            # avoid computations of tree_at if no updates
+            loss = loss.update_weights(
+                i, loss_terms, loss_container.stored_loss_terms, grad_terms, subkey
+            )
+
+        # total grad
+        grads = loss.ponderate_and_sum_gradient(grad_terms)
+
+        # total loss
+        train_loss_value = loss.ponderate_and_sum_loss(loss_terms)
+        # ---------------------------------------------------------------------
+
+        # gradient step
         (
-            loss,
-            train_loss_value,
-            loss_terms,
             params,
             opt_state,
             last_non_nan_params,
         ) = _gradient_step(
-            loss,
+            grads,
             optimizer,
-            batch,
             optimization.params,
             optimization.opt_state,
             optimization.last_non_nan_params,
@@ -374,14 +445,14 @@ def solve(
         )
 
         # save loss value and selected parameters
-        stored_params, stored_loss_terms, train_loss_values = _store_loss_and_params(
+        stored_objects, loss_container = _store_loss_and_params(
             i,
             params,
             stored_objects.stored_params,
-            loss_container.stored_loss_terms,
-            loss_container.train_loss_values,
+            loss_container,
             train_loss_value,
             loss_terms,
+            loss.loss_weights,
             tracked_params,
         )
 
@@ -401,11 +472,15 @@ def solve(
             ),
             DataGeneratorContainer(data, param_data, obs_data),
             validation,
-            LossContainer(stored_loss_terms, train_loss_values),
-            StoredObjectContainer(stored_params),
+            loss_container,
+            stored_objects,
             validation_crit_values,
+            key,
         )
 
+    if verbose:
+        print("Initialization time:", time.time() - initialization_time)
+
     # Main optimization loop. We use the LAX while loop (fully jitted) version
     # if no mixing devices. Otherwise we use the standard while loop. Here devices only
     # concern obs_batch, but it could lead to more complex scheme in the future
@@ -443,6 +518,7 @@ def solve(
         loss_container,
         stored_objects,
         validation_crit_values,
+        key,
     ) = carry
 
     if verbose:
@@ -480,6 +556,7 @@ def solve(
         loss,  # return the Loss if needed (no-inplace modif)
         optimization.opt_state,
         stored_objects.stored_params,
+        loss_container.stored_weights_terms,
         validation_crit_values if validation is not None else None,
         validation_parameters,
     )
@@ -487,16 +564,12 @@ def solve(
 
 @partial(jit, static_argnames=["optimizer"])
 def _gradient_step(
-    loss: AnyLoss,
+    grads: Params[Array],
     optimizer: optax.GradientTransformation,
-    batch: AnyBatch,
     params: Params[Array],
     opt_state: optax.OptState,
     last_non_nan_params: Params[Array],
 ) -> tuple[
-    AnyLoss,
-    float,
-    dict[str, float],
     Params[Array],
     optax.OptState,
     Params[Array],
@@ -504,13 +577,12 @@ def _gradient_step(
     """
     optimizer cannot be jit-ted.
     """
-    value_grad_loss = jax.value_and_grad(loss, has_aux=True)
-    (loss_val, loss_terms), grads = value_grad_loss(params, batch)
+
     updates, opt_state = optimizer.update(
-        grads,
+        grads,  # type: ignore
         opt_state,
         params,  # type: ignore
-    )  # see optimizer.init for explaination
+    )  # see optimizer.init for explaination for the ignore(s) here
     params = optax.apply_updates(params, updates)  # type: ignore
 
     # check if any of the parameters is NaN
@@ -522,9 +594,6 @@ def _gradient_step(
     )
 
     return (
-        loss,
-        loss_val,
-        loss_terms,
         params,
         opt_state,
         last_non_nan_params,
@@ -551,13 +620,13 @@ def _print_fn(i: int, loss_val: Float, print_loss_every: int, prefix: str = ""):
 def _store_loss_and_params(
     i: int,
     params: Params[Array],
-    stored_params: Params[Array],
-    stored_loss_terms: dict[str, Float[Array, " n_iter"]],
-    train_loss_values: Float[Array, " n_iter"],
+    stored_params: Params[Array | None],
+    loss_container: LossContainer,
     train_loss_val: float,
-    loss_terms: dict[str, float],
+    loss_terms: PyTree[Array],
+    weight_terms: PyTree[Array],
     tracked_params: Params,
-) -> tuple[Params, dict[str, Float[Array, " n_iter"]], Float[Array, " n_iter"]]:
+) -> tuple[StoredObjectContainer, LossContainer]:
     stored_params = jax.tree_util.tree_map(
         lambda stored_value, param, tracked_param: (
             None
@@ -576,12 +645,38 @@ def _store_loss_and_params(
     )
     stored_loss_terms = jax.tree_util.tree_map(
         lambda stored_term, loss_term: stored_term.at[i].set(loss_term),
-        stored_loss_terms,
+        loss_container.stored_loss_terms,
         loss_terms,
     )
 
-    train_loss_values = train_loss_values.at[i].set(train_loss_val)
-    return (stored_params, stored_loss_terms, train_loss_values)
+    if loss_container.stored_weights_terms is not None:
+        stored_weights_terms = jax.tree_util.tree_map(
+            lambda stored_term, weight_term: stored_term.at[i].set(weight_term),
+            jax.tree.leaves(
+                loss_container.stored_weights_terms,
+                is_leaf=lambda x: x is not None and eqx.is_inexact_array(x),
+            ),
+            jax.tree.leaves(
+                weight_terms,
+                is_leaf=lambda x: x is not None and eqx.is_inexact_array(x),
+            ),
+        )
+        stored_weights_terms = eqx.tree_at(
+            lambda pt: jax.tree.leaves(
+                pt, is_leaf=lambda x: x is not None and eqx.is_inexact_array(x)
+            ),
+            loss_container.stored_weights_terms,
+            stored_weights_terms,
+        )
+    else:
+        stored_weights_terms = None
+
+    train_loss_values = loss_container.train_loss_values.at[i].set(train_loss_val)
+    loss_container = LossContainer(
+        stored_loss_terms, stored_weights_terms, train_loss_values
+    )
+    stored_objects = StoredObjectContainer(stored_params)
+    return stored_objects, loss_container
 
 
 def _get_break_fun(n_iter: int, verbose: bool) -> Callable[[main_carry], bool]:
@@ -612,7 +707,7 @@ def _get_break_fun(n_iter: int, verbose: bool) -> Callable[[main_carry], bool]:
         def continue_while_loop(_):
             return True
 
-        (i, _, optimization, optimization_extra, _, _, _, _, _) = carry
+        (i, _, optimization, optimization_extra, _, _, _, _, _, _) = carry
 
         # Condition 1
         bool_max_iter = jax.lax.cond(

jinns/utils/_containers.py

@@ -6,7 +6,7 @@ from __future__ import (
     annotations,
 )  # https://docs.python.org/3/library/typing.html#constant
 
-from typing import TYPE_CHECKING, Dict
+from typing import TYPE_CHECKING
 from jaxtyping import PyTree, Array, Float, Bool
 from optax import OptState
 import equinox as eqx
@@ -48,7 +48,10 @@ class OptimizationExtraContainer(eqx.Module):
 
 
 class LossContainer(eqx.Module):
-    stored_loss_terms: Dict[str, Float[Array, " n_iter"]]
+    # PyTree below refers to ODEComponents or PDEStatioComponents or
+    # PDENonStatioComponents
+    stored_loss_terms: PyTree[Float[Array, " n_iter"]]
+    stored_weights_terms: PyTree[Float[Array, " n_iter"]]
     train_loss_values: Float[Array, " n_iter"]
 
 

jinns/utils/_types.py

@@ -9,6 +9,11 @@ if TYPE_CHECKING:
     from jinns.data._Batchs import ODEBatch, PDEStatioBatch, PDENonStatioBatch
     from jinns.loss._LossODE import LossODE
     from jinns.loss._LossPDE import LossPDEStatio, LossPDENonStatio
+    from jinns.loss._loss_components import (
+        ODEComponents,
+        PDEStatioComponents,
+        PDENonStatioComponents,
+    )
 
     # Here we define types available for the whole package
     BoundaryConditionFun: TypeAlias = Callable[
@@ -17,3 +22,10 @@ if TYPE_CHECKING:
 
     AnyBatch: TypeAlias = ODEBatch | PDENonStatioBatch | PDEStatioBatch
     AnyLoss: TypeAlias = LossODE | LossPDEStatio | LossPDENonStatio
+
+    # here we would like a type from 3.12
+    # (https://typing.python.org/en/latest/spec/aliases.html#type-statement) so
+    # that we could have a generic AnyLossComponents
+    AnyLossComponents: TypeAlias = (
+        ODEComponents | PDEStatioComponents | PDENonStatioComponents
+    )

{jinns-1.4.0.dist-info → jinns-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jinns
-Version: 1.4.0
+Version: 1.5.1
 Summary: Physics Informed Neural Network with JAX
 Author-email: Hugo Gangloff <hugo.gangloff@inrae.fr>, Nicolas Jouvin <nicolas.jouvin@inrae.fr>
 Maintainer-email: Hugo Gangloff <hugo.gangloff@inrae.fr>, Nicolas Jouvin <nicolas.jouvin@inrae.fr>
@@ -54,6 +54,9 @@ It can also be used for forward problems and hybrid-modeling.
 
     - [Hyper PINNs](https://arxiv.org/pdf/2111.01008.pdf): useful for meta-modeling
 
+- Other
+    - Adaptative Loss Weights are now implemented. Some SoftAdapt, LRAnnealing and ReLoBRaLo are available and users can implement their own strategy. See the [tutorial](https://mia_jinns.gitlab.io/jinns/Notebooks/Tutorials/implementing_your_own_PDE_problem/)
+
 
 - **Get started**: check out our various notebooks on the [documentation](https://mia_jinns.gitlab.io/jinns/index.html).
 
@@ -113,7 +116,7 @@ pre-commit install
 
 Don't hesitate to contribute and get your name on the list here !
 
-**List of contributors:** Hugo Gangloff, Nicolas Jouvin, Lucia Clarotto, Inass Soukarieh
+**List of contributors:** Hugo Gangloff, Nicolas Jouvin, Lucia Clarotto, Inass Soukarieh, Mohamed Badi
 
 # Cite us
 

{jinns-1.4.0.dist-info → jinns-1.5.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
-jinns/__init__.py,sha256=hyh3QKO2cQGK5cmvFYP0MrXb-tK_DM2T9CwLwO-sEX8,500
+jinns/__init__.py,sha256=Tjp5z0Mnd1nscvJaXnxZb4lEYbI0cpN6OPgCZ-Swo74,453
 jinns/data/_AbstractDataGenerator.py,sha256=O61TBOyeOFKwf1xqKzFD4KwCWRDnm2XgyJ-kKY9fmB4,557
 jinns/data/_Batchs.py,sha256=-DlD6Qag3zs5QbKtKAOvOzV7JOpNOqAm_P8cwo1dIZg,1574
-jinns/data/_CubicMeshPDENonStatio.py,sha256=c_8czJpxSoEvgZ8LDpL2sqtF9dcW4ELNO4juEFMOxog,16400
-jinns/data/_CubicMeshPDEStatio.py,sha256=stZ0Kbb7_VwFmWUSPs0P6a6qRj2Tu67p7sxEfb1Ajks,17865
+jinns/data/_CubicMeshPDENonStatio.py,sha256=4f21SgeNQsGJTz8-uehduU0X9TibRcs28Iq49Kv4nQQ,22250
+jinns/data/_CubicMeshPDEStatio.py,sha256=DVrP4qHVAJMu915EYH2PKyzwoG0nIMixAEKR2fz6C58,22525
 jinns/data/_DataGeneratorODE.py,sha256=5RzUbQFEsooAZsocDw4wRgA_w5lJmDMuY4M6u79K-1c,7260
 jinns/data/_DataGeneratorObservations.py,sha256=jknepLsJatSJHFq5lLMD-fFHkPGj5q286LEjE-vH24k,7738
 jinns/data/_DataGeneratorParameter.py,sha256=IedX3jcOj7ZDW_18IAcRR75KVzQzo85z9SICIKDBJl4,8539
@@ -11,14 +11,16 @@ jinns/data/_utils.py,sha256=XxaLIg_HIgcB7ACBIhTpHbCT1HXKcDaY1NABncAYX1c,5223
 jinns/experimental/__init__.py,sha256=DT9e57zbjfzPeRnXemGUqnGd--MhV77FspChT0z4YrE,410
 jinns/experimental/_diffrax_solver.py,sha256=upMr3kTTNrxEiSUO_oLvCXcjS9lPxSjvbB81h3qlhaU,6813
 jinns/loss/_DynamicLoss.py,sha256=4mb7OCP-cGZ_mG2MQ-AniddDcuBT78p4bQI7rZpwte4,22722
-jinns/loss/_DynamicLossAbstract.py,sha256=HIs6TtE9ouvT5H3cBR52UWSkALTgRWRG_kB3s890b2U,11253
-jinns/loss/_LossODE.py,sha256=aCx5vD3CXmhws36gYre1iu_t29MefpTxW54gUxKej_Q,11856
-jinns/loss/_LossPDE.py,sha256=mANXuWjm02bKwfoIn-RH8vxPY-RG3jVErcSrwwK3HzM,33259
-jinns/loss/__init__.py,sha256=qnNRGjl6Tcga1koztMJnJ3eL8XNP0gRbNsXVgq4CkOI,1162
-jinns/loss/_abstract_loss.py,sha256=hf6ohNoSAqzskFyivCiuE2SCqhsV4UWLv65L4V8H3ys,407
+jinns/loss/_DynamicLossAbstract.py,sha256=QhHRgvtcT-ifHlOxTyXbjDtHk9UfPN2Si8s3v9nEQm4,12672
+jinns/loss/_LossODE.py,sha256=iVYDojaI6Co7S5CrU67_niopD4Bk7UBTuLzDiTHoWMc,16996
+jinns/loss/_LossPDE.py,sha256=VT56oQ_33fLq46lIch0slNsxu4d97eQBOgRAPeFESts,36401
+jinns/loss/__init__.py,sha256=z5xYgBipNFf66__5BqQc6R_8r4F6A3TXL60YjsM8Osk,1287
+jinns/loss/_abstract_loss.py,sha256=DMxn0SQe9PW-pq3p5Oqvb0YK3_ulLDOnoIXzK219GV4,4576
 jinns/loss/_boundary_conditions.py,sha256=9HGw1cGLfmEilP4V4B2T0zl0YP1kNtrtXVLQNiBmWgc,12464
-jinns/loss/_loss_utils.py,sha256=R_jhBHkTwGu41gWnhYRswunxdzetPZ9-Gmkghzorock,11745
-jinns/loss/_loss_weights.py,sha256=5BVZglM7Y3m_8muXcKT898fAC6_RbdLNQ7WWx3lOE9k,1077
+jinns/loss/_loss_components.py,sha256=MMzaGlaRqESPjRzT0j0WU9HAqWQSbIXpGAqM1xQCZHw,1106
+jinns/loss/_loss_utils.py,sha256=eJ4JcBm396LHx7Tti88ZQrLcKqVL1oSfFGT23VNkytQ,11949
+jinns/loss/_loss_weight_updates.py,sha256=9Bwouh7shLyc_wrdzN6CYL0ZuQH81uEs-L6wCeiYFx8,6817
+jinns/loss/_loss_weights.py,sha256=kII5WddORgeommFTudT3CSvhICpo6nSe47LclUgu_78,2429
 jinns/loss/_operators.py,sha256=Ds5yRH7hu-jaGRp7PYbt821BgYuEvgWHufWhYgdMjw0,22909
 jinns/nn/__init__.py,sha256=gwE48oqB_FsSIE-hUvCLz0jPaqX350LBxzH6ueFWYk4,456
 jinns/nn/_abstract_pinn.py,sha256=JUFjlV_nyheZw-max_tAUgFh6SspIbD5we_4bn70V6k,671
@@ -32,22 +34,22 @@ jinns/nn/_spinn_mlp.py,sha256=uCL454sF0Tfj7KT-fdXPnvKJYRQOuq60N0r2b2VAB8Q,7606
 jinns/nn/_utils.py,sha256=9UXz73iHKHVQYPBPIEitrHYJzJ14dspRwPfLA8avx0c,1120
 jinns/parameters/__init__.py,sha256=O0n7y6R1LRmFzzugCxMFCMS2pgsuWSh-XHjfFViN_eg,265
 jinns/parameters/_derivative_keys.py,sha256=YlLDX49PfYhr2Tj--t3praiD8JOUTZU6PTmjbNZsbMc,19173
-jinns/parameters/_params.py,sha256=qn4IGMJhD9lDBqOWmGEMy4gXt5a6KHfirkYZwHO7Vwk,2633
+jinns/parameters/_params.py,sha256=nv0WScbgUdmuC0bSF15VbnKypJ58pl6wynZAcYfuF6M,3081
 jinns/plot/__init__.py,sha256=KPHX0Um4FbciZO1yD8kjZbkaT8tT964Y6SE2xCQ4eDU,135
 jinns/plot/_plot.py,sha256=-A5auNeElaz2_8UzVQJQE4143ZFg0zgMjStU7kwttEY,11565
 jinns/solver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jinns/solver/_rar.py,sha256=vSVTnCGCusI1vTZCvIkP2_G8we44G_42yZHx2sOK9DE,10291
-jinns/solver/_solve.py,sha256=uPJsN4Pv_QEHYMlMdo29hlJXmWyCtf2aFZlj2M8Fl2U,24886
+jinns/solver/_solve.py,sha256=IsrmG2m48KkkYgvXYomlSbZ3hd1FySCj3rwlkovs-lI,28616
 jinns/solver/_utils.py,sha256=sM2UbVzYyjw24l4QSIR3IlynJTPGD_S08r8v0lXMxA8,5876
 jinns/utils/__init__.py,sha256=OEYWLCw8pKE7xoQREbd6SHvCjuw2QZHuVA6YwDcsBE8,53
-jinns/utils/_containers.py,sha256=XANkmGiXvFb7Qh8MtGuhcZQl4Fpw4woJcn17-y1-VHs,1690
-jinns/utils/_types.py,sha256=PEPVEZ4XGT-7gCIasUHDYpIrMP_Ke1KTXGloXJPlK_k,746
+jinns/utils/_containers.py,sha256=YShcrPKfj5_I9mn3NMAS4Ea9MhhyL7fjv0e3MRbITHg,1837
+jinns/utils/_types.py,sha256=jl_91HtcrtE6UHbdTrRI8iUmr2kBUL0oP0UNIKhAXYw,1170
 jinns/utils/_utils.py,sha256=M7NXX9ok-BkH5o_xo74PB1_Cc8XiDipSl51rq82dTH4,2821
 jinns/validation/__init__.py,sha256=FTyUO-v1b8Tv-FDSQsntrH7zl9E0ENexqKMT_dFRkYo,124
 jinns/validation/_validation.py,sha256=8p6sMKiBAvA6JNm65hjkMj0997LJ0BkyCREEh0AnPVE,4803
-jinns-1.4.0.dist-info/licenses/AUTHORS,sha256=7NwCj9nU-HNG1asvy4qhQ2w7oZHrn-Lk5_wK_Ve7a3M,80
-jinns-1.4.0.dist-info/licenses/LICENSE,sha256=BIAkGtXB59Q_BG8f6_OqtQ1BHPv60ggE9mpXJYz2dRM,11337
-jinns-1.4.0.dist-info/METADATA,sha256=MkB5xNjrdFcJHmlwhk_RRwNNuCdkHLYpAxB-7TYhykg,5031
-jinns-1.4.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-jinns-1.4.0.dist-info/top_level.txt,sha256=RXbkr2hzy8WBE8aiRyrJYFqn3JeMJIhMdybLjjLTB9c,6
-jinns-1.4.0.dist-info/RECORD,,
+jinns-1.5.1.dist-info/licenses/AUTHORS,sha256=7NwCj9nU-HNG1asvy4qhQ2w7oZHrn-Lk5_wK_Ve7a3M,80
+jinns-1.5.1.dist-info/licenses/LICENSE,sha256=BIAkGtXB59Q_BG8f6_OqtQ1BHPv60ggE9mpXJYz2dRM,11337
+jinns-1.5.1.dist-info/METADATA,sha256=K7Aii5ivFcczIwLlQtCPqzMJEfW86D1yW1q7qMtvWPE,5314
+jinns-1.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jinns-1.5.1.dist-info/top_level.txt,sha256=RXbkr2hzy8WBE8aiRyrJYFqn3JeMJIhMdybLjjLTB9c,6
+jinns-1.5.1.dist-info/RECORD,,

{jinns-1.4.0.dist-info → jinns-1.5.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any