From 554219b2c1e2619259e4bd10240282cade1a70df Mon Sep 17 00:00:00 2001 From: Evan Palmer Date: Wed, 4 Nov 2026 12:10:48 -0800 Subject: [PATCH 1/2] Add product kernel and phase out jax.tree_util usage --- lrax/common/kernels.py | 36 +++++++++++++++++++++++++++++++++++- lrax/common/logger.py | 8 ++++---- lrax/common/networks.py | 21 ++++++++++----------- lrax/common/scores.py | 8 ++++---- lrax/common/trainer.py | 6 +++--- lrax/ppo/ppo.py | 13 ++++++------- lrax/sac/sac.py | 11 +++++------ lrax/shac/shac.py | 13 ++++++------- pyproject.toml | 2 +- 9 files changed, 74 insertions(+), 44 deletions(-) diff --git a/lrax/common/kernels.py b/lrax/common/kernels.py index a4f377c..435d6e9 100644 --- a/lrax/common/kernels.py +++ b/lrax/common/kernels.py @@ -25,7 +25,7 @@ import jax import jax.numpy as jnp from equinox.internal import doc_repr -from jaxtyping import Array, ArrayLike, Float, Scalar, ScalarLike, Shaped +from jaxtyping import Array, ArrayLike, Float, PyTree, Scalar, ScalarLike, Shaped from ..typing import DistanceFn, Kernel, Point @@ -429,3 +429,37 @@ def row(x: Point) -> Float[Array, " m"]: raise ValueError(f"`batch_size` must be positive. Got {batch_size}.") return jax.lax.map(jax.checkpoint(row), xs, batch_size=batch_size) + + +def product(kernels: PyTree[Kernel]) -> Kernel: + r"""Multiply kernels that each act on one part of a sample. + + .. math:: + + k(x, y) = \prod_{i} k_{i}(x_{i}, y_{i}) + + where :math:`k_{i}` is the :math:`i`th kernel and :math:`x_{i}` and :math:`y_{i}` + are the parts of the samples it acts on. This builds a kernel on a product space + from kernels on its factors, such as a position paired with an orientation, and + the product of positive definite kernels is positive definite. + + Parameters + ---------- + - `kernels`: The kernels to multiply, arranged in a tree whose structure is a + prefix of the samples. Each kernel receives the subtree of the samples at its + own position, so a kernel may act on a single array or on a whole branch. + Callables are treated as leaves, so kernels that are themselves pytrees, such + as Equinox modules, are not flattened. + + Returns + ------- + The product kernel, taking two samples and returning a scalar. + """ + if not jax.tree.leaves(kernels, is_leaf=callable): + raise ValueError("`kernels` must hold at least one kernel.") + + def kernel(x: Point, y: Point) -> Scalar: + values = jax.tree.map(lambda k, a, b: k(a, b), kernels, x, y, is_leaf=callable) + return jax.tree.reduce(jnp.multiply, values) + + return kernel diff --git a/lrax/common/logger.py b/lrax/common/logger.py index 089614e..97c9f6b 100644 --- a/lrax/common/logger.py +++ b/lrax/common/logger.py @@ -24,7 +24,7 @@ from pathlib import Path from typing import Any -import jax.tree_util as jtu +import jax import wandb from ..typing import Metrics @@ -149,13 +149,13 @@ def __init__(self, loggers: Sequence[Logger]): self.loggers = list(loggers) def log_hyperparams(self, params: dict[str, Any]) -> None: - jtu.tree_map(lambda logger: logger.log_hyperparams(params), self.loggers) + jax.tree.map(lambda logger: logger.log_hyperparams(params), self.loggers) def log_metrics(self, metrics: Metrics, step: int | None = None) -> None: - jtu.tree_map(lambda logger: logger.log_metrics(metrics, step), self.loggers) + jax.tree.map(lambda logger: logger.log_metrics(metrics, step), self.loggers) def cleanup(self) -> None: - jtu.tree_map(lambda logger: logger.cleanup(), self.loggers) + jax.tree.map(lambda logger: logger.cleanup(), self.loggers) class WandbLogger(Logger): diff --git a/lrax/common/networks.py b/lrax/common/networks.py index 1b2f532..dab5a71 100644 --- a/lrax/common/networks.py +++ b/lrax/common/networks.py @@ -27,7 +27,6 @@ import jax.nn as jnn import jax.numpy as jnp import jax.random as jr -import jax.tree_util as jtu from equinox.internal import doc_repr from jaxtyping import Array, ArrayLike, PRNGKeyArray, PyTree @@ -592,7 +591,7 @@ def __call__(self, *args, **kwargs) -> PyTree[Array]: ``` """ outputs = [model(*args, **kwargs) for model in self.models] # type: ignore - return jtu.tree_map(lambda *out: jnp.stack(out), *outputs) + return jax.tree.map(lambda *out: jnp.stack(out), *outputs) def __len__(self) -> int: return len(self.models) @@ -618,7 +617,7 @@ def mean(outputs: PyTree[Array]) -> PyTree[Array]: ------- A pytree matching a single member's output, each leaf averaged over the members. """ - return jtu.tree_map(lambda out: jnp.mean(out, axis=0), outputs) + return jax.tree.map(lambda out: jnp.mean(out, axis=0), outputs) @staticmethod def std(outputs: PyTree[Array]) -> PyTree[Array]: @@ -635,7 +634,7 @@ def std(outputs: PyTree[Array]) -> PyTree[Array]: ------- A pytree matching a single member's output, each leaf's spread over the members. """ - return jtu.tree_map(lambda out: jnp.std(out, axis=0), outputs) + return jax.tree.map(lambda out: jnp.std(out, axis=0), outputs) @staticmethod def min(outputs: PyTree[Array]) -> PyTree[Array]: @@ -650,7 +649,7 @@ def min(outputs: PyTree[Array]) -> PyTree[Array]: ------- A pytree matching a single member's output, each leaf reduced over the members. """ - return jtu.tree_map(lambda out: jnp.min(out, axis=0), outputs) + return jax.tree.map(lambda out: jnp.min(out, axis=0), outputs) @staticmethod def max(outputs: PyTree[Array]) -> PyTree[Array]: @@ -665,7 +664,7 @@ def max(outputs: PyTree[Array]) -> PyTree[Array]: ------- A pytree matching a single member's output, each leaf reduced over the members. """ - return jtu.tree_map(lambda out: jnp.max(out, axis=0), outputs) + return jax.tree.map(lambda out: jnp.max(out, axis=0), outputs) def select(self, indices: Sequence[int]) -> "WrapEnsemble[M]": return WrapEnsemble([self.models[i] for i in indices]) @@ -696,7 +695,7 @@ def subsample( `num_members`. """ indices = jr.choice(key, len(self.models), (num_members,), replace=replace) - return jtu.tree_map(lambda out: out[indices], outputs) + return jax.tree.map(lambda out: out[indices], outputs) class WrapResidual(eqx.Module): @@ -753,7 +752,7 @@ def __init__( if callable(nominal): self.nominal = nominal else: - self.nominal = jtu.tree_map(jnp.asarray, nominal) + self.nominal = jax.tree.map(jnp.asarray, nominal) self.correction = correction self.freeze_nominal = freeze_nominal @@ -780,10 +779,10 @@ def __call__(self, x: Array) -> PyTree[Array]: nominal = jax.lax.stop_gradient(nominal) correction = self.correction(x) - same_structure = jtu.tree_structure(nominal) == jtu.tree_structure(correction) + same_structure = jax.tree.structure(nominal) == jax.tree.structure(correction) if not same_structure or any( jnp.shape(n) != jnp.shape(c) - for n, c in zip(jtu.tree_leaves(nominal), jtu.tree_leaves(correction)) + for n, c in zip(jax.tree.leaves(nominal), jax.tree.leaves(correction)) ): raise ValueError( "The output of `correction` must have the same pytree structure and " @@ -792,7 +791,7 @@ def __call__(self, x: Array) -> PyTree[Array]: f"`{eqx.tree_pformat(correction)}`." ) - return jtu.tree_map(jnp.add, nominal, correction) + return jax.tree.map(jnp.add, nominal, correction) class WrapSPDResidual(eqx.Module): diff --git a/lrax/common/scores.py b/lrax/common/scores.py index cadf08f..72500ea 100644 --- a/lrax/common/scores.py +++ b/lrax/common/scores.py @@ -24,8 +24,8 @@ import jax import jax.numpy as jnp import jax.scipy.linalg as jsl -import jax.tree_util as jtu from jax.flatten_util import ravel_pytree +from jax.tree_util import KeyPath, keystr from jaxtyping import Array, ArrayLike, Float, Scalar, ScalarLike, Shaped from ..typing import Kernel, Point @@ -33,18 +33,18 @@ def _get_sample_size(samples: Shaped[Point, "samples"]) -> int: - def check(path: jtu.KeyPath, leaf: ArrayLike) -> int: + def check(path: KeyPath, leaf: ArrayLike) -> int: shape = jnp.shape(leaf) if not shape: raise ValueError( "Every leaf must carry a leading sample axis. Got a scalar leaf at " - f"`samples{jtu.keystr(path)}`." + f"`samples{keystr(path)}`." ) return shape[0] - leaves = jtu.tree_leaves_with_path(samples) + leaves = jax.tree.leaves_with_path(samples) if not leaves: raise ValueError("`samples` must have at least one array leaf.") diff --git a/lrax/common/trainer.py b/lrax/common/trainer.py index 204a44d..8470ee9 100644 --- a/lrax/common/trainer.py +++ b/lrax/common/trainer.py @@ -24,9 +24,9 @@ from typing import Any, Literal, assert_never import equinox as eqx +import jax import jax.numpy as jnp import jax.random as jr -import jax.tree_util as jtu import optax from jaxtyping import PRNGKeyArray, PyTree from lightning.pytorch import LightningDataModule @@ -172,7 +172,7 @@ def make_training_step(_model, _opt_state, _batch, _keys): for batch in tqdm(loader, desc=f"Epoch {epoch}", leave=False): # split the key into one key per element of the batch; we need this # when training stochastic models that depend on a key for each rollout - batch_size = jtu.tree_leaves(batch)[0].shape[0] + batch_size = jax.tree.leaves(batch)[0].shape[0] keys = jr.split(jr.fold_in(key, step), batch_size) result = make_training_step(model, opt_state, batch, keys) @@ -281,7 +281,7 @@ def learn( # check whether the optimizer is a single optimizer or multiple optimizers is_optim = lambda x: isinstance(x, optax.GradientTransformation) params = eqx.filter(model, eqx.is_inexact_array) - opt_state = jtu.tree_map(lambda o: o.init(params), optim, is_leaf=is_optim) + opt_state = jax.tree.map(lambda o: o.init(params), optim, is_leaf=is_optim) algorithm_state = algorithm.init(model, env, key=init_key) diff --git a/lrax/ppo/ppo.py b/lrax/ppo/ppo.py index 2245dbe..bb966a8 100644 --- a/lrax/ppo/ppo.py +++ b/lrax/ppo/ppo.py @@ -24,7 +24,6 @@ import jax import jax.numpy as jnp import jax.random as jr -import jax.tree_util as jtu from jax import lax from jaxtyping import Array, ArrayLike, PRNGKeyArray, PyTree, ScalarLike from optax import OptState @@ -312,7 +311,7 @@ def _update( params, static = eqx.partition(model, eqx.is_inexact_array) - batch_size = jtu.tree_leaves(batch)[0].shape[0] + batch_size = jax.tree.leaves(batch)[0].shape[0] minibatch_size = batch_size // self.num_minibatches loss_and_grad = eqx.filter_value_and_grad(self._loss, has_aux=True) @@ -345,8 +344,8 @@ def _epoch_step( ) -> tuple[tuple[PyTree, OptState], Metrics]: params, opt_state = carry perm = jr.permutation(epoch_key, batch_size) - shuffled = jtu.tree_map(lambda x: x[perm], batch) - minibatches = jtu.tree_map( + shuffled = jax.tree.map(lambda x: x[perm], batch) + minibatches = jax.tree.map( lambda x: x.reshape(self.num_minibatches, minibatch_size, *x.shape[1:]), shuffled, ) @@ -359,7 +358,7 @@ def _epoch_step( (params, opt_state), metrics = lax.scan( _epoch_step, (params, opt_state), epoch_keys ) - metrics = jtu.tree_map(jnp.mean, metrics) + metrics = jax.tree.map(jnp.mean, metrics) model = eqx.combine(params, static) return model, opt_state, metrics @@ -418,14 +417,14 @@ def step( advantages=advantages, returns=returns, ) - batch = jtu.tree_map(lambda x: x.reshape(total_size, *x.shape[2:]), batch) + batch = jax.tree.map(lambda x: x.reshape(total_size, *x.shape[2:]), batch) model, opt_state, metrics = self._update( model, opt_state, optim, batch, key=update_key ) # merge the environment metrics with the loss metrics - metrics.update(jtu.tree_map(jnp.mean, rollouts.metrics)) + metrics.update(jax.tree.map(jnp.mean, rollouts.metrics)) metrics["mean_reward"] = jnp.mean(rollouts.rewards) metrics["done_rate"] = jnp.mean(rollouts.dones) diff --git a/lrax/sac/sac.py b/lrax/sac/sac.py index 9eae191..a4a0a3e 100644 --- a/lrax/sac/sac.py +++ b/lrax/sac/sac.py @@ -24,7 +24,6 @@ import jax import jax.numpy as jnp import jax.random as jr -import jax.tree_util as jtu from jax import lax from jaxtyping import Array, PRNGKeyArray, PyTree from optax import OptState @@ -265,7 +264,7 @@ def _grad_step( critic_target, eqx.is_inexact_array ) critic_arrays, _ = eqx.partition(model.critic, eqx.is_inexact_array) - target_arrays = jtu.tree_map( + target_arrays = jax.tree.map( lambda t, c: (1.0 - self.tau) * t + self.tau * c, target_arrays, critic_arrays, @@ -280,7 +279,7 @@ def _grad_step( (model_params, state_params, opt_state), metrics = lax.scan( _grad_step, (model_params, state_params, opt_state), step_keys ) - metrics = jtu.tree_map(jnp.mean, metrics) + metrics = jax.tree.map(jnp.mean, metrics) model = eqx.combine(model_params, model_static) alg_state = eqx.combine(state_params, state_static) return model, alg_state, opt_state, metrics @@ -304,7 +303,7 @@ def step( rollouts, env_state = self._rollout(model, env, env_state, key=rollout_key) total_size = self.num_steps * env.num_envs - flat = jtu.tree_map(lambda x: x.reshape(total_size, *x.shape[2:]), rollouts) + flat = jax.tree.map(lambda x: x.reshape(total_size, *x.shape[2:]), rollouts) critic_target, buffer = alg_state buffer = buffer.add( flat.obs, @@ -361,7 +360,7 @@ def _skip_update( key: PRNGKeyArray, ) -> tuple[PyTree, PyTree, OptState, Metrics]: del key - zeros = jtu.tree_map(lambda s: jnp.zeros(s.shape, s.dtype), metrics_shape) + zeros = jax.tree.map(lambda s: jnp.zeros(s.shape, s.dtype), metrics_shape) return model_params, state_params, opt_state, cast(Metrics, zeros) model_params, state_params, opt_state, metrics = lax.cond( @@ -378,7 +377,7 @@ def _skip_update( # merge the environment metrics with the loss metrics metrics = dict(metrics) - metrics.update(jtu.tree_map(jnp.mean, flat.metrics)) + metrics.update(jax.tree.map(jnp.mean, flat.metrics)) metrics["mean_reward"] = jnp.mean(flat.rewards) metrics["done_rate"] = jnp.mean(flat.dones) metrics["buffer_size"] = buffer.size diff --git a/lrax/shac/shac.py b/lrax/shac/shac.py index bba4bed..fa12869 100644 --- a/lrax/shac/shac.py +++ b/lrax/shac/shac.py @@ -25,7 +25,6 @@ import jax.nn as jnn import jax.numpy as jnp import jax.random as jr -import jax.tree_util as jtu import optax from jax import lax from jaxtyping import Array, PRNGKeyArray, PyTree, ScalarLike @@ -327,7 +326,7 @@ def _step( dones=outputs.done, next_values=outputs.next_value, metrics={ - **jtu.tree_map(jnp.mean, outputs.metrics), + **jax.tree.map(jnp.mean, outputs.metrics), "mean_reward": jnp.mean(outputs.raw_reward), "done_rate": jnp.mean(outputs.raw_done), }, @@ -382,7 +381,7 @@ def _update_critic( """ params, static = eqx.partition(model, eqx.is_inexact_array) - batch_size = jtu.tree_leaves(batch)[0].shape[0] + batch_size = jax.tree.leaves(batch)[0].shape[0] minibatch_size = batch_size // self.num_minibatches loss_and_grad = eqx.filter_value_and_grad(self._critic_loss, has_aux=True) @@ -404,8 +403,8 @@ def _epoch_step( ) -> tuple[tuple[PyTree, OptState], Metrics]: params, opt_state = carry perm = jr.permutation(epoch_key, batch_size) - shuffled = jtu.tree_map(lambda x: x[perm], batch) - minibatches = jtu.tree_map( + shuffled = jax.tree.map(lambda x: x[perm], batch) + minibatches = jax.tree.map( lambda x: x.reshape(self.num_minibatches, minibatch_size, *x.shape[1:]), shuffled, ) @@ -418,7 +417,7 @@ def _epoch_step( (params, opt_state), metrics = lax.scan( _epoch_step, (params, opt_state), epoch_keys ) - metrics = jtu.tree_map(jnp.mean, metrics) + metrics = jax.tree.map(jnp.mean, metrics) model = eqx.combine(params, static) return model, opt_state, metrics @@ -472,7 +471,7 @@ def step( alg_state.critic_target, eqx.is_inexact_array ) critic_arrays, _ = eqx.partition(model.critic, eqx.is_inexact_array) - target_arrays = jtu.tree_map( + target_arrays = jax.tree.map( lambda t, c: self.target_alpha * t + (1.0 - self.target_alpha) * c, target_arrays, critic_arrays, diff --git a/pyproject.toml b/pyproject.toml index 4412ed3..dd7d0f7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi" [project] name = "lrax" -version = "0.3.0" +version = "0.4.0" description = "JAX library for robotics learning research" readme = "README.md" requires-python = ">=3.12" From da2b6c90e9f0b4c02fb773a873a5f39aaf66f3a9 Mon Sep 17 00:00:00 2001 From: Evan Palmer Date: Wed, 4 Nov 2026 12:12:49 -0800 Subject: [PATCH 2/2] Update lockfile --- uv.lock | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/uv.lock b/uv.lock index e0de776..d5d47b3 100644 --- a/uv.lock +++ b/uv.lock @@ -577,11 +577,11 @@ wheels = [ [[package]] name = "filelock" -version = "4.2.7" +version = "4.2.9" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e0/14/73688a22e91cfcfc6837a011ffa572e2ba3c348765f7bd482d8436fa9b6f/filelock-4.2.7.tar.gz", hash = "sha256:31f6f7e3a8b6f0bd89114d30c5d5218ea1cfb63e5c4aa695b7559314a209bc7f", size = 661450, upload-time = "2026-11-02T16:09:15.119Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/1d/d730c664fcb4f1d264a722722a3134cf0881854f73c1fd58abf87572f232/filelock-4.2.9.tar.gz", hash = "sha256:96530b7c538d4ea08493ab067247aab7948c54d8cd622cce711c97cccc5d9896", size = 663116, upload-time = "2026-11-04T18:37:10.014Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1d/1a/1fcf0d3886bad15b92459a0e529dd86a1ec4d9ef30e789df48044fd3698c/filelock-4.2.7-py3-none-any.whl", hash = "sha256:d08972bbca2b8767ee552aff877b091dd111ffb1d22de7de885766ea7d719d5e", size = 164345, upload-time = "2026-11-02T16:09:13.588Z" }, + { url = "https://files.pythonhosted.org/packages/00/05/76184fe08339723d643ab47887a8e4de8f2921ca4e008617ab7490af7857/filelock-4.2.9-py3-none-any.whl", hash = "sha256:a379c50a729e5b68c8519a4d26489f755d9769960a236ecd838190e2a78db2e9", size = 164734, upload-time = "2026-11-04T18:37:08.273Z" }, ] [[package]] @@ -1095,7 +1095,7 @@ wheels = [ [[package]] name = "lrax" -version = "0.3.0" +version = "0.4.0" source = { editable = "." } dependencies = [ { name = "equinox" }, @@ -1682,14 +1682,13 @@ wheels = [ [[package]] name = "nvidia-cudnn-cu12" -version = "9.27.0.42" +version = "9.28.0.42" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "nvidia-cublas-cu12" }, ] wheels = [ - { url = "https://files.pythonhosted.org/packages/e4/4b/26e6309b205085e9aa8074887e81fa3603da24c51fd75e0dcaaaff0b9e0f/nvidia_cudnn_cu12-9.27.0.42-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:5bc22243563107ea06aa60f9116ad800063d5f4617cc75bc6670d5db78d9f336", size = 772694764, upload-time = "2026-09-29T23:39:53.164Z" }, - { url = "https://files.pythonhosted.org/packages/65/e4/c5a205d48ff00ed8b27882bb45d338d8138e976c76385f328a326bbfaeda/nvidia_cudnn_cu12-9.27.0.42-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:0a4aa3a7d2264256506c6857fc41fc0c499982f78d70195b1cfcc9055c1957cd", size = 766178381, upload-time = "2026-09-29T23:42:52.357Z" }, + { url = "https://files.pythonhosted.org/packages/ce/64/56ce3cad192cc75b50da3be44e36741ba963c84d3d2ca10aaa5ec16c49c3/nvidia_cudnn_cu12-9.28.0.42-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:9ff58b7f36dacd0a93e89f8f2957b52466889217963701daa15e577317cfa375", size = 716538495, upload-time = "2026-11-04T20:05:03.56Z" }, ] [[package]] @@ -2106,11 +2105,11 @@ wheels = [ [[package]] name = "platformdirs" -version = "4.14.3" +version = "4.14.5" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9a/6e/886dc7c9d21e2d95aceb696f1e31271742033aeef3661f6e9c8921493592/platformdirs-4.14.3.tar.gz", hash = "sha256:021add1ab113483edbcd4694f5fbb2d688b893ea30d35e1155bb371cf4be0be8", size = 71124, upload-time = "2026-11-01T16:27:32.928Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/9a/8475be631fb33ca1466915e70fd594c42a4e84b512db650eaa14f90fe75d/platformdirs-4.14.5.tar.gz", hash = "sha256:32e9921db7385aa8169bee4fe9501923e5715ba9fb7ea3b9c69b0d8e0639f7a1", size = 71464, upload-time = "2026-11-04T16:54:50.358Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/93/41/f0aa003909ee77a9e7e55f8659abb635ca23ab0d022a449bbb18da87a1ef/platformdirs-4.14.3-py3-none-any.whl", hash = "sha256:cba2d05fe5e18b26b1fa6f376b8e6234c012abe1f8696c486fface7d0054e931", size = 35276, upload-time = "2026-11-01T16:27:31.498Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ae/ecbbbfd0e4343a6a521d49b3c8656fb4643dee2a4f6eaf941cf3280391a8/platformdirs-4.14.5-py3-none-any.whl", hash = "sha256:8e778c6fa421516f4d3369449f8df3b0e1b72c0e0005fe88e3ec772d0a14e750", size = 35402, upload-time = "2026-11-04T16:54:48.875Z" }, ] [[package]] @@ -2660,14 +2659,14 @@ wheels = [ [[package]] name = "typing-inspection" -version = "0.4.4" +version = "0.4.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a3/26/b09b8010994eccc3c09092e6b34058f36a460eea2d4c3e8b910c695975a0/typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47", size = 76928, upload-time = "2026-08-12T12:37:25.997Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ff/50/0195198eb1d75bab716bb0a813abea4cc394bfa17a92a189f021a34859af/typing_inspection-0.4.5.tar.gz", hash = "sha256:7f16c411e7930dc79596d42ab44672a3fe5f60eb34b781a1647e7872363120c7", size = 81194, upload-time = "2026-11-04T14:13:23.774Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/67/81/4add07e5172b7ac40d8ed5ff580409a7801a4fe26d529bdd915401dabfbe/typing_inspection-0.4.4-py3-none-any.whl", hash = "sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147", size = 14750, upload-time = "2026-08-12T12:37:24.648Z" }, + { url = "https://files.pythonhosted.org/packages/de/0c/ea2544850a7c135e15033a5c7a8e7211136184b7ae63e2239d557c2b3019/typing_inspection-0.4.5-py3-none-any.whl", hash = "sha256:bc210535442b39e1bf2805e0c7a17dfd6a4ace760c84c7f7d16245d23a6b1c39", size = 14874, upload-time = "2026-11-04T14:13:22.616Z" }, ] [[package]]