Support non-numpy array backends by ColmTalbot · Pull Request #886 · bilby-dev/bilby

ColmTalbot · 2025-01-07T19:38:30Z

I've been working on this PR on and off for a few months, it isn't ready yet, but I wanted to share it in case other people had early opinions.

The goal is to make it easier to interface with models/samplers implemented in e.g., JAX, that support GPU/TPU acceleration and JIT compilation.

The general guiding principles are:

when possible maintain existing behaviour with numpy/builtin arguments
work introspectively so users don't need to specify the target backend, but use input types
write as little backend specific code as possible, mostly through using the array-api specification and scipy interoperability

The primary changes so far are:

making most priors backend independent, there are a few holdouts where the underlying scipy functionality isn't compatible yet
core likelihoods mostly work with data from any backend
GW likelihoods work with any backend supported by the source function
the GW detector objects don't work via introspection, they need to be manually set
GW geometry (currently in bilby_cython) is handled via multiple-dispatch and added back into bilby

Changed behaviour:

prior sampling/rescale shapes - related to Conserve rescale shape #863
some priors won't return floats on float input

Remaining issues:

Saving/loading nun-numpy arrays in result files may not work
I added some additional parameter conversions that I will remove
the bilby.gw.jaxstuff file should be removed and relevant functionality be moved elsewhere, it's currently just used for testing
the ROQ likelihood hasn't been ported
add more testing with JAX
translate some of the hyperparameter functionality, c.f., GWPopulation

ColmTalbot · 2026-01-23T15:48:31Z

This is now ready for review.
There are some things that won't work with JAX at the moment, e.g., various combinations of likelihood marginalization/acceleration.
I think we should accept this at the moment, for at least a bilby v3 alpha/beta release, and keep chipping away at the various subcases over time.

There are a lot of changes, but most of them are essentially np -> xp.
Some things required refactoring to avoid modifying slices of arrays as JAX doesn't like that.

Bilby can once again be installed without bilby.cython.
This should improve our general portability, but when bilby_cython is installed it will be used.

I've managed to keep test changes minimal:

I updated the joint prior test to make it more stringent (keys more randomly ordered).
I refactored some expensive prior initialization that was dramatically slowing things down.
I improved the logic for figuring out when ROQs are available to help my local testing.
Some mocks of numpy had to be updated.

mj-will

Some initial comments but I'll need to have another look.

mj-will · 2026-01-27T16:01:03Z

        This maps to the inverse CDF. This has been analytically solved for this case.
        """
-        return gammaincinv(self.k, val) * self.theta
+        return xp.asarray(gammaincinv(self.k, val)) * self.theta


Does this mean this is falling back to numpy?

Yeah, I should update/recheck this, but at least jax doesn't have good support for this, but it looks like tensorflow has a version that numpyro uses (jax-ml/jax#5350). cupy does have this function, so this workaround may have just been for jax. I could add a BackendNotImplementedError.

Would this be a candidate for a small patch that uses the TF version for jax until jax supports it natively?

mj-will · 2026-01-27T16:09:37Z

-            self[key].least_recently_sampled = result[key]
-            if isinstance(self[key], JointPrior) and self[key].dist.distname not in joint:
-                joint[self[key].dist.distname] = [key]
-            elif isinstance(self[key], JointPrior):
-                joint[self[key].dist.distname].append(key)
-        for names in joint.values():
-            # this is needed to unpack how joint prior rescaling works
-            # as an example of a joint prior over {a, b, c, d} we might
-            # get the following based on the order within the joint prior
-            # {a: [], b: [], c: [1, 2, 3, 4], d: []}
-            # -> [1, 2, 3, 4]
-            # -> {a: 1, b: 2, c: 3, d: 4}
-            values = list()
-            for key in names:
-                values = np.concatenate([values, result[key]])
-            for key, value in zip(names, values):
-                result[key] = value
-
-        def safe_flatten(value):
-            """
-            this is gross but can be removed whenever we switch to returning
-            arrays, flatten converts 0-d arrays to 1-d so has to be special
-            cased
-            """
-            if isinstance(value, (float, int)):
-                return value


Is removing this intentional?

Yeah, this is in line with one of the other open PRs to update this logic. I'll dig it out in my next pass.

ColmTalbot

Thanks for the initial comments @mj-will I'll take a pass at them ASAP.

ColmTalbot · 2026-01-28T07:02:42Z

-            self[key].least_recently_sampled = result[key]
-            if isinstance(self[key], JointPrior) and self[key].dist.distname not in joint:
-                joint[self[key].dist.distname] = [key]
-            elif isinstance(self[key], JointPrior):
-                joint[self[key].dist.distname].append(key)
-        for names in joint.values():
-            # this is needed to unpack how joint prior rescaling works
-            # as an example of a joint prior over {a, b, c, d} we might
-            # get the following based on the order within the joint prior
-            # {a: [], b: [], c: [1, 2, 3, 4], d: []}
-            # -> [1, 2, 3, 4]
-            # -> {a: 1, b: 2, c: 3, d: 4}
-            values = list()
-            for key in names:
-                values = np.concatenate([values, result[key]])
-            for key, value in zip(names, values):
-                result[key] = value
-
-        def safe_flatten(value):
-            """
-            this is gross but can be removed whenever we switch to returning
-            arrays, flatten converts 0-d arrays to 1-d so has to be special
-            cased
-            """
-            if isinstance(value, (float, int)):
-                return value


Yeah, this is in line with one of the other open PRs to update this logic. I'll dig it out in my next pass.

GregoryAshton

Okay, I got through about 60% of the diff and I'm pausing here so will submit the questions so far.

GregoryAshton · 2026-02-19T14:28:25Z

-            _cdf[val >= self.minimum] = 1. - np.exp(-val[val >= self.minimum] / self.mu)
-        return _cdf
+        with np.errstate(divide="ignore"):
+            return -val / self.mu - xp.log(xp.asarray(self.mu)) + xp.log(val >= self.minimum)


Ah okay - are the bounds being implemented here? But, I don't see the upper bound being implemented.

I think this is carried over from the existing implementation.

ColmTalbot · 2026-05-14T22:13:10Z

Python 3.10 doesn't have support for a vmappable version of logsumexp through scipy leading to this job failing (https://github.com/bilby-dev/bilby/actions/runs/25883935510/job/76070707573?pr=886).

How do people feel about dropping support for Python 3.10 in Bilby 3? Numpy dropped support about a year ago.

…likelihood

This required making some changes to the tests for conditional dicts as I've changed the output types and the backend introspection doesn't work on dict_items for some reason

mj-will · 2026-05-19T15:01:42Z

This looks great @ColmTalbot. i've not a proper look yet but one thought on using orng: I think ArrayRNG may be confusing so I'm considering changing it to something else (see sequince-dev/orng#9). Feel free to comment on the MR if you have thoughts.

Once that's in, I can make a stable release and get in on conda if that would be useful.

ColmTalbot · 2026-05-19T15:33:50Z

i've not a proper look yet but one thought on using orng: I think ArrayRNG may be confusing so I'm considering changing it to something else (see sequince-dev/orng#9). Feel free to comment on the MR if you have thoughts.

No meaningful thoughts, I agree it's probably a positive change and I'm happy to update once it is available.

Once that's in, I can make a stable release and get in on conda if that would be useful.

I think we'll definitely want this once we have a release ready. Although, I think I've refactored things so that orng doesn't need to be a top-level dependency.

Co-authored-by: Michael J. Williams <michaeljw1@googlemail.com>

mj-will

I'm unsure if all the priors are consistent with the previous versions. I've tried to go through them but may have missed some things or equally, got some logic wrong and they're fine.

mj-will · 2026-05-21T11:34:42Z

-
-    def prob(self, val):
+        return (
+            xp.sign(2 * val - 1)


I think the behaviour at val=0.5 has changed. Previously it would return self.minimum where as now it will be zero since np.sign(0) = 0. I'm not sure, but I don't think this is right for a log-uniform.

This hadn't occurred to me, but I actually think the old version is more incorrect. I'm happy to reinstate the old behaviour with xp.where, but it is worth documenting as I think this is non intuitive.

mj-will · 2026-05-21T11:37:45Z

+    @xp_wrap
+    def cdf(self, val, *, xp=None):
+        asymmetric = xp.log(xp.abs(val) / self.minimum) / xp.log(xp.asarray(self.maximum / self.minimum))
+        return xp.clip(0.5 * (1 + xp.sign(val) * asymmetric), 0, 1)


I think this has a similar problem at 0 since sign(0) = 0 and asymmetric=-inf

Yeah, I think we need to modify the definition of asymmetric to the following to make the CDF flat between [-min, min].

asymmetric = xp.log(xp.maximum(xp.abs(val) / self.minimum, 1)) / xp.log(xp.asarray(self.maximum / self.minimum))

mj-will · 2026-05-21T11:43:49Z

+    def cdf(self, val, *, xp=None):
+        with np.errstate(divide="ignore"):
+            return 0.5 + erf(
+                (xp.log(xp.maximum(val, xp.asarray(self.minimum))) - self.mu) / self.sigma / np.sqrt(2)
+            ) / 2


Does it still return 0 for values below the minimum? I don't think it does but I might be missing something.

Yeah, max(val, minimum) is equivalent to a one-sided clip. This seems overly complicated though as minimum is hardcoded to zero, but that's a carry over.

mj-will · 2026-05-21T11:54:32Z

+        ln_prob = xlog1py(xp.asarray(self.beta - 1.0), -val) + xlogy(xp.asarray(self.alpha - 1.0), val)
+        ln_prob -= betaln(xp.asarray(self.alpha), xp.asarray(self.beta))
+        return xp.nan_to_num(ln_prob, nan=-xp.inf, neginf=-xp.inf, posinf=-xp.inf)


I'm sure minimum and maximum are respected here.

Yeah, this seems pretty broken. What about this?

Suggested change

ln_prob = xlog1py(xp.asarray(self.beta - 1.0), -val) + xlogy(xp.asarray(self.alpha - 1.0), val)

ln_prob -= betaln(xp.asarray(self.alpha), xp.asarray(self.beta))

return xp.nan_to_num(ln_prob, nan=-xp.inf, neginf=-xp.inf, posinf=-xp.inf)

normalized = (val - self.minimum) / (self.maximum - self.minimum)

ln_prob = xlog1py(xp.asarray(self.beta - 1.0), -normalized) + xlogy(xp.asarray(self.alpha - 1.0), normalized)

ln_prob -= betaln(xp.asarray(self.alpha), xp.asarray(self.beta))

ln_prob -= xlogy(

xp.asarray(self.alpha + self.beta - 1),

xp.asarray(self.maximum - self.minimum),

)

return xp.where(

xp.abs(normalized - 0.5) <= 0.5,

xp.nan_to_num(ln_prob, nan=-xp.inf, neginf=-xp.inf, posinf=-xp.inf),

-xp.inf,

)

mj-will · 2026-05-21T11:57:06Z

+        with np.errstate(divide="ignore"):
+            val = xp.asarray(val)
+            return self.mu + self.scale * xp.log(xp.maximum(val / (1 - val), xp.asarray(0)))


I don' think the upper boundary is consistent with the old implementation. I think it now gives -inf rather than +inf

I don't think so, log(max(1 / 0, 0)) = log(inf) = inf.

Ah, I was thinking specifically of things above the bound, so:

log(max(negative, 0)) = log(0) = -inf

I agree the bound itself is still the same.

Oh, I don't know that we've been careful about out of bounds behaviour for these rescale methods in general. The behaviour here is the same as the behaviour before this change for scalars, but not arrays.

mj-will · 2026-05-21T12:15:59Z

+    if random_state is None or not BILBY_ARRAY_API:
+        return np
+    elif isinstance(random_state, np.random.Generator):
+        return np
+    elif aac.is_jax_array(random_state) or getattr(random_state, "backend") == "jax":
+        import jax.numpy as jnp
+        return jnp
+    elif aac.is_torch_array(random_state) or getattr(random_state, "backend") == "torch":
+        import torch
+        return torch
+    else:
+        return np


Should this be using the wrapped modules, e.g. array_api_compat.numpy?

From the docs I think this is preferred:

Wrapped array namespaces can also be imported directly. For example, array_namespace(np.array(...)) will return array_api_compat.numpy. This function will also work for any array library not wrapped by array-api-compat if it explicitly defines array_namespace (the wrapped namespace is always preferred if it exists).

I'm not against doing this, but I'm not really sure what the benefit is. I guess it would reduce the number of explicit imports.

I think the main benefit is the APIs are standardized and the code can therefore be more generic.

For example, the methods will support some additional keywords like device:

import array_api_compat.numpy as np device = "cpu" x = [1, 2, 3] np.asarray(x, device=device)

This doesn't do anything for numpy in this case, but doesn't raise an error like it would for standard numpy. This means the exact same code would work for torch with e.g. a CUDA device.

Okay, I'll try to use this where I can, but I think we should avoid using the array_api_compat version of numpy if BILBY_ARRAY_API == False.

FWIW, this specific example has worked with standard numpy since version 2.0.0.

mj-will · 2026-05-21T12:20:21Z

+    white_noise = xpx.at(white_noise, 0).set(0)
+    white_noise = xpx.at(white_noise, -1).set(0)


May be missing something, but it seems the case where the number of samples is odd is no longer handled.

I think the answer is that the old function was broken... and always returned yes in this condition.
We could add it back in, but it does break the specific value tests we have.

mj-will · 2026-05-21T12:21:38Z

        """

+        if xp is None:
+            xp = np


Should this default to aac.numpy?

mj-will · 2026-05-21T12:28:20Z

            raise TypeError("Parameters names must be a list or string")

-        out_array = log_array.copy()
+        out_array = copy(log_array)


I'm not sure a plain copy works for torch:

>>> import torch >>> import copy >>> x = torch.Tensor([1.0]) >>> y = copy.copy(x) >>> y[0] = 0 >>> x tensor([0.]) >>>

I'm not sure what the correct way is to handle this, in other packages I've resorted to helpers but I suspect there's a better way. For example: https://github.com/mj-will/aspire/blob/main/src/aspire/utils.py#L456

ColmTalbot

Thanks for the comments @mj-will I'll try to fold in the changes before next week.

ColmTalbot · 2026-05-21T12:48:03Z

-
-    def prob(self, val):
+        return (
+            xp.sign(2 * val - 1)


This hadn't occurred to me, but I actually think the old version is more incorrect. I'm happy to reinstate the old behaviour with xp.where, but it is worth documenting as I think this is non intuitive.

ColmTalbot · 2026-05-21T12:52:14Z

+    def cdf(self, val, *, xp=None):
+        with np.errstate(divide="ignore"):
+            return 0.5 + erf(
+                (xp.log(xp.maximum(val, xp.asarray(self.minimum))) - self.mu) / self.sigma / np.sqrt(2)
+            ) / 2


Yeah, max(val, minimum) is equivalent to a one-sided clip. This seems overly complicated though as minimum is hardcoded to zero, but that's a carry over.

ColmTalbot · 2026-05-21T12:58:09Z

+        ln_prob = xlog1py(xp.asarray(self.beta - 1.0), -val) + xlogy(xp.asarray(self.alpha - 1.0), val)
+        ln_prob -= betaln(xp.asarray(self.alpha), xp.asarray(self.beta))
+        return xp.nan_to_num(ln_prob, nan=-xp.inf, neginf=-xp.inf, posinf=-xp.inf)


Yeah, this seems pretty broken. What about this?

Suggested change

ln_prob = xlog1py(xp.asarray(self.beta - 1.0), -val) + xlogy(xp.asarray(self.alpha - 1.0), val)

ln_prob -= betaln(xp.asarray(self.alpha), xp.asarray(self.beta))

return xp.nan_to_num(ln_prob, nan=-xp.inf, neginf=-xp.inf, posinf=-xp.inf)

normalized = (val - self.minimum) / (self.maximum - self.minimum)

ln_prob = xlog1py(xp.asarray(self.beta - 1.0), -normalized) + xlogy(xp.asarray(self.alpha - 1.0), normalized)

ln_prob -= betaln(xp.asarray(self.alpha), xp.asarray(self.beta))

ln_prob -= xlogy(

xp.asarray(self.alpha + self.beta - 1),

xp.asarray(self.maximum - self.minimum),

)

return xp.where(

xp.abs(normalized - 0.5) <= 0.5,

xp.nan_to_num(ln_prob, nan=-xp.inf, neginf=-xp.inf, posinf=-xp.inf),

-xp.inf,

)

ColmTalbot · 2026-05-21T12:59:07Z

+        with np.errstate(divide="ignore"):
+            val = xp.asarray(val)
+            return self.mu + self.scale * xp.log(xp.maximum(val / (1 - val), xp.asarray(0)))


I don't think so, log(max(1 / 0, 0)) = log(inf) = inf.

ColmTalbot · 2026-05-21T13:01:53Z

+    @xp_wrap
+    def cdf(self, val, *, xp=None):
+        asymmetric = xp.log(xp.abs(val) / self.minimum) / xp.log(xp.asarray(self.maximum / self.minimum))
+        return xp.clip(0.5 * (1 + xp.sign(val) * asymmetric), 0, 1)


Yeah, I think we need to modify the definition of asymmetric to the following to make the CDF flat between [-min, min].

asymmetric = xp.log(xp.maximum(xp.abs(val) / self.minimum, 1)) / xp.log(xp.asarray(self.maximum / self.minimum))

ColmTalbot · 2026-05-21T13:09:06Z

+    white_noise = xpx.at(white_noise, 0).set(0)
+    white_noise = xpx.at(white_noise, -1).set(0)


I think the answer is that the old function was broken... and always returned yes in this condition.
We could add it back in, but it does break the specific value tests we have.

ColmTalbot · 2026-05-21T13:10:20Z

            raise TypeError("Parameters names must be a list or string")

-        out_array = log_array.copy()
+        out_array = copy(log_array)


ColmTalbot · 2026-05-21T13:11:36Z

+    if random_state is None or not BILBY_ARRAY_API:
+        return np
+    elif isinstance(random_state, np.random.Generator):
+        return np
+    elif aac.is_jax_array(random_state) or getattr(random_state, "backend") == "jax":
+        import jax.numpy as jnp
+        return jnp
+    elif aac.is_torch_array(random_state) or getattr(random_state, "backend") == "torch":
+        import torch
+        return torch
+    else:
+        return np


I'm not against doing this, but I'm not really sure what the benefit is. I guess it would reduce the number of explicit imports.

ColmTalbot added the enhancement New feature or request label Jan 7, 2025

ColmTalbot marked this pull request as draft January 7, 2025 19:38

ColmTalbot force-pushed the bilback branch from b902545 to af6881d Compare October 2, 2025 16:06

ColmTalbot force-pushed the bilback branch from 95020e5 to 0eeeaa5 Compare December 11, 2025 15:45

ColmTalbot force-pushed the bilback branch 2 times, most recently from ea348fa to 771a8a9 Compare January 22, 2026 17:00

ColmTalbot marked this pull request as ready for review January 23, 2026 15:24

ColmTalbot changed the title ~~DRAFT: Support non-numpy array backends~~ Support non-numpy array backends Jan 23, 2026

ColmTalbot added >100 lines refactoring to discuss To be discussed on an upcoming call labels Jan 23, 2026

ColmTalbot force-pushed the bilback branch from 2d28818 to 230f623 Compare January 23, 2026 16:51

mj-will added this to the 3.0.0 milestone Jan 27, 2026

mj-will reviewed Jan 27, 2026

View reviewed changes

ColmTalbot commented Jan 28, 2026

View reviewed changes

ColmTalbot mentioned this pull request Feb 17, 2026

FEAT: Add precessing spin transformation #1044

Draft

GregoryAshton reviewed Feb 19, 2026

View reviewed changes

mj-will removed the to discuss To be discussed on an upcoming call label May 14, 2026

ColmTalbot and others added 10 commits May 14, 2026 22:18

FEAT: enable backend switching for base gravitational-wave transient …

1e3f4af

…likelihood

FEAT: support multiband and relative binning likelihoods

cf5c611

FEAT: make more conversions backend agnostic

2bfc833

FEAT: use more normal conversions

d29b860

FEAT: move backend switching code to bilby

c5eb323

FEAT: make core prior backend agnostic

9bec666

FEAT: make non-numpy arrays serializable

0d9aba6

BUG: fix some array conversion methods

aea0ea8

DEV: some more prior agnosticism

8e61b7f

TEST: make all prior tests run

b658a02

This required making some changes to the tests for conditional dicts as I've changed the output types and the backend introspection doesn't work on dict_items for some reason

FMT: remove extra empty line

4a46bcc

ColmTalbot requested review from a team, GregoryAshton and mj-will May 19, 2026 13:56

BUG: fix failures in tests

01d839a

ColmTalbot added 13 commits May 19, 2026 15:36

MAINT: move orng into jax dependencies

f4c5440

TEST: update waveform generator test

92c8ebc

TEST: improve visibility of prior test failures

06241cb

DOC: update documentation

a41bc0d

TEST: fix broken tests

ab67301

FMT: fix precommits

487a074

CI: split array backend tests into a separate job

89d80d1

TYPO: fix typo in ci

6143c26

BUG: fix up torch tests

b151876

TEST: fix testing with array api support

11b94b6

BUG: fix typos in healpix priors

3ec7c7f

TEST: loosen some numeric tests for torch

6ccaa45

CI: fix basic install workflow

2d15cf9

mj-will reviewed May 21, 2026

View reviewed changes

Comment thread .github/workflows/basic-install.yml Outdated

CI: fix testing executables

6ff0ef7

Co-authored-by: Michael J. Williams <michaeljw1@googlemail.com>

mj-will reviewed May 21, 2026

View reviewed changes

Comment thread bilby/core/grid.py

"""

if xp is None:

xp = np

Copy link
Copy Markdown

Collaborator

mj-will May 21, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Should this default to aac.numpy?

mj-will reviewed May 21, 2026

View reviewed changes

Comment thread bilby/core/grid.py

ColmTalbot commented May 21, 2026

View reviewed changes

ColmTalbot requested a review from a team May 22, 2026 11:54

-        ln_prob = xlog1py(xp.asarray(self.beta - 1.0), -val) + xlogy(xp.asarray(self.alpha - 1.0), val)
-        ln_prob -= betaln(xp.asarray(self.alpha), xp.asarray(self.beta))
-        return xp.nan_to_num(ln_prob, nan=-xp.inf, neginf=-xp.inf, posinf=-xp.inf)
+        normalized = (val - self.minimum) / (self.maximum - self.minimum)
+        ln_prob = xlog1py(xp.asarray(self.beta - 1.0), -normalized) + xlogy(xp.asarray(self.alpha - 1.0), normalized)
+        ln_prob -= betaln(xp.asarray(self.alpha), xp.asarray(self.beta))
+        ln_prob -= xlogy(
+            xp.asarray(self.alpha + self.beta - 1),
+            xp.asarray(self.maximum - self.minimum),
+        )
+        return xp.where(
+            xp.abs(normalized - 0.5) <= 0.5,
+            xp.nan_to_num(ln_prob, nan=-xp.inf, neginf=-xp.inf, posinf=-xp.inf),
+            -xp.inf,
+        )

		white_noise = xpx.at(white_noise, 0).set(0)
		white_noise = xpx.at(white_noise, -1).set(0)

Conversation

ColmTalbot commented Jan 7, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

ColmTalbot commented Jan 23, 2026

Uh oh!

mj-will left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

ColmTalbot left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

GregoryAshton left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

ColmTalbot commented May 14, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

mj-will commented May 19, 2026

Uh oh!

ColmTalbot commented May 19, 2026

Uh oh!

Uh oh!

mj-will left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

ColmTalbot commented Jan 7, 2025 •

edited

Loading

ColmTalbot commented May 14, 2026 •

edited

Loading