FEAT (alt3) allow setting auto routed strategy on objects #31413

adrinjalali · 2025-05-22T11:31:24Z

This alternative allows the case for DefaultRoutingClassifier4 in the following script. I think I prefer this alternative to the other ones.

import pytest
import numpy as np
import sklearn
from sklearn.base import BaseEstimator, ClassifierMixin
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_classification

sklearn.set_config(enable_metadata_routing=True, metadata_request_policy="auto")


class BaseMyClassifier(ClassifierMixin, BaseEstimator):
    __metadata_request__fit = {"sample_weight": True}

    def fit(self, X, y, sample_weight=None):
        self.classes_ = np.array([0, 1])
        print(sample_weight)
        return self

    def predict(self, X, groups=None):
        print(groups)
        return np.ones(len(X))


class DefaultRoutingClassifier1(BaseMyClassifier):
    def get_metadata_routing(self, **auto_requests):
        # Each instance can configure metadata which should be requested by default if
        # `set_config(metadata_request_policy="auto")` is set. These request values are
        # passed to the parent's `get_metadata_routing` method.
        return super().get_metadata_routing(predict="groups")


class DefaultRoutingClassifier2(BaseMyClassifier):
    def get_metadata_routing(self):
        return super().get_metadata_routing_with_auto_requests(predict="groups")


class DefaultRoutingClassifier3(BaseMyClassifier):
    def __sklearn_get_auto_requests__(self):
        return {"predict": ["groups"]}


class DefaultRoutingClassifier4(BaseMyClassifier):
    def get_metadata_routing(self):
        requests = super().get_metadata_routing()
        requests.predict.add_auto_request("groups")
        return requests


X, y = make_classification()

print("case 1")
pipeline = Pipeline(
    [
        (
            "scaler",
            StandardScaler()
            .set_fit_request(sample_weight=False)
            .set_partial_fit_request(sample_weight=True),
        ),
        (
            "classifier",
            DefaultRoutingClassifier4().set_predict_request(groups="my_groups"),
        ),
    ]
)
pipeline.fit(X, y, sample_weight=np.ones(len(X)))
pipeline.predict(X, my_groups=np.ones(len(X)) + 1)

print("case 2")
pipeline = Pipeline(
    [
        ("scaler", StandardScaler().set_fit_request(sample_weight=False)),
        ("classifier", DefaultRoutingClassifier4()),
    ]
)
pipeline.fit(X, y, sample_weight=np.ones(len(X)))
pipeline.predict(X, groups=np.ones(len(X)) + 1)

print("case 3")
pipeline = Pipeline(
    [
        ("scaler", StandardScaler().set_fit_request(sample_weight=False)),
        ("classifier", DefaultRoutingClassifier4().set_predict_request(groups=False)),
    ]
)
pipeline.fit(X, y, sample_weight=np.ones(len(X)))
with pytest.raises(TypeError, match="Pipeline.predict got unexpected argument"):
    pipeline.predict(X, groups=np.ones(len(X)) + 1)

cc @StefanieSenger @ogrisel @antoinebaker

github-actions · 2025-05-22T11:32:21Z

✔️ Linting Passed

All linting checks passed. Your pull request is in excellent shape! ☀️

_{Generated for commit: a27cee9. Link to the linter CI: here}

StefanieSenger

I have looked through this PR and commented a bit, some questions, some suggestions for improvement.

As I think I have missed this: What is the difference in usage for the users between this PR, and the previous version of defining an auto request strategy (#31401)? Edit from 5 days later: I of cause meant the difference between this PR and what #31401 was supposed to become, not what it is.

sklearn/_config.py

StefanieSenger · 2025-05-22T12:47:12Z

sklearn/utils/_metadata_requests.py

+    def actualize_auto_requests(self):
+        for method in SIMPLE_METHODS:
+            getattr(self, method).actualize_auto_requests()
+        return self


For simplicity, could this be a private method instead?

I don't think many people would really want to use such a low-level method.

I believe making it possible to use get_metadata_routing().{method_name}.add_auto_request() in combination with get_routing_for_object(obj) gives enough room for any fine tuning and inspection and exposing this intermediate step could be confusing and requires too much explaining of when it's useful.

I don't think it matters. We have documented in the example file how people should be using it anyways.

I might be misunderstanding, but I don’t see actualize_auto_requests documented in the example file.

My thought was that when third party developers call add_auto_request() and also use get_routing_for_object() (which internally calls actualize_auto_requests()) there’s no clear external use case for calling this method directly.

StefanieSenger · 2025-05-22T15:10:56Z

sklearn/utils/_metadata_requests.py

+    def add_auto_request(self, *params):
+        self._auto_requests.update(params)
+        return self
+
+    def actualize_auto_requests(self):
+        for param in self._auto_requests:
+            self.add_request(param=param, alias=True)
+        return self


Would it be more convenient to add the auto-requests directly to the MetadataRequest object itself (as a **kwarg)? This way, a user can (and has to) define all the auto-set metadata in the same place, which may be easier to read with line breaks and black-formatted.

those objects are not created by the user. They're created in our functions here. The user only modifies them.

I meant developers who define a custom meta-estimator, not end-users.

I would then look something like this

requests = super().get_metadata_routing() requests.add_auto_request(fit="prop", predict="prop")

rather than like this, how it is now:

requests = super().get_metadata_routing() requests.fit.add_auto_request("prop") requests.predict.add_auto_request("prop")

And add_auto_request() would be a method on MetadataRequest instead of on MethodMetadataRequest, which I think spares a few iterations?

StefanieSenger · 2025-05-22T15:27:30Z

sklearn/utils/_metadata_requests.py

+        elif isinstance(obj, MetadataRouter):
+            self._self_request = deepcopy(obj._self_request)


Could you please explain this part, @adrinjalali:

elif isinstance(obj, MetadataRouter): self._self_request = deepcopy(obj._self_request)

If a MetadataRouter object is passed to another MetadataRouter object' add_self_request method, the latter overtakes the former's _self_request attribute? In which case would this happen?

it really shouldn't happen. This only happens in our tests and here it covers the edge case if it happens; but I don't think it would.

StefanieSenger · 2025-05-23T10:37:29Z

examples/miscellaneous/plot_metadata_routing.py

+# 1. Class-level defaults using `__metadata_request__method` class attributes,
+#    which set default request values for all instances of a class, and can even
+#    remove a metadata from the metadata routing machinery if necessary.
+# 2. Instance-level defaults via the `add_auto_request` method, which would only
+#    request the metadata if ``set_config(metadata_request_policy="auto")`` is
+#    set.


Let's also document right here that the instance level requests will overwrite the class level requests and can be overwritten by user-set requests.

StefanieSenger · 2025-05-23T10:43:29Z

examples/miscellaneous/plot_metadata_routing.py

+# 2. Instance-level defaults via the `add_auto_request` method, which would only
+#    request the metadata if ``set_config(metadata_request_policy="auto")`` is
+#    set.


Maybe it is fine to only communicate the class level auto default setting possibility and not burden third party developer's with the instance level option.

Here in our case, the instance level auto default setting seem to only depend on the way set_config() is configured and - while being on instance level technically - doesn't really come with the flexibility of instance level adjustments it seems to me. (Maybe I am lacking the fantasy what else people could do with that, though.)

Since it's a feature, I rather document it properly instead of skipping it.

What I had meant was that the instance-level default setting doesn't need to be a feature to begin with.

Not sure if I get this right, but what I am thinking is:
Third party developers could only make use of it if they also have a set_config in their library that also checks if auto requests are enabled. The same for developers who customise a scikit-learn compatible estimator for their corporate project.

And then the functionality of setting instance level requests would be very limited. It's very similar to setting defaults at class level, only it adds a extra little condition of having auto requests enabled in the configs, no? 🤷‍♀️

StefanieSenger · 2025-05-23T10:50:02Z

sklearn/utils/_metadata_requests.py

+             (e.g. set_fit_request) that allow runtime configuration of metadata
+             routing.
+
+        2. Before the user sets any specific routing, via `_get_default_requests`, it


add_auto_request is meant, right?

Also, the term "user" means too many different things here, can we express this in a more precise way?

Suggested change

2. Before the user sets any specific routing, via `_get_default_requests`, it

2. Before the developer of an estimator sets any specific routing,

via `add_auto_request`, it

examples/miscellaneous/plot_metadata_routing.py

StefanieSenger · 2025-05-23T13:52:13Z

examples/miscellaneous/plot_metadata_routing.py

+# %%
+# And now with default routing enabled:
+with config_context(enable_metadata_routing="default_routing"):
+    print_routing(clf)


print_routing(), using the corrected config like this:

with config_context(metadata_request_policy="auto"): print_routing(clf)

actually prints:

{'fit': {'sample_weight': True}, 'predict': {'groups': None}, 'score': {'sample_weight': None}}

I think it should print 'predict': {'groups': True} and it seems that print_routing is using estimator without calling actualize_auto_requests on its MetadataRequest?

print(get_routing_for_object(clf)) works as expected.

examples/miscellaneous/plot_metadata_routing.py

StefanieSenger · 2025-05-25T08:07:16Z

examples/miscellaneous/plot_metadata_routing.py

+        return np.ones(len(X))
+
+
+# Let's see the default routing configuration


I would not use the word "default" here. The default global configuration is "empty", as we have already established in config_context and in set_config.

Here, the default has been changed by adding a class level attribute that defines that sample_weight is getting routed to fit().

StefanieSenger · 2025-05-25T08:19:22Z

examples/miscellaneous/plot_metadata_routing.py

+# %%
+# .. _metadata_routing_auto_request:
+#
+# Auto-Requesting Metadata


I was thinking about the term "auto request".

I don't think it makes a difference to the third party developers, that this is accomplished setting requests via the instance. Also, auto-requests is only the second of two points mentioned here. The result of both is an automated routing for the users.

In the docs (specifically here) we could talk about different ways to define an automated routing (instead of request).

And to distinguish set_predict_request(groups=True) and requests.predict.add_auto_request("groups"), I think the latter could instead be called add_auto_routing.

we're not adding routing here per-say, we're adding a default request on the consumer. Routing is set on routers, while here we change default values for consumers.

For third party developers the difference between the two ways is that one is always there, the other is only there if the user sets a global flag.

Yes thanks, I can see that now.

Co-authored-by: Stefanie Senger <91849487+StefanieSenger@users.noreply.github.com>

adrinjalali

As I think I have missed this: What is the difference in usage for the users between this PR, and the previous version of defining an auto request strategy (#31401)?

There's no difference for users. The difference is only on how it's implemented.

adrinjalali · 2025-06-03T07:34:52Z

examples/miscellaneous/plot_metadata_routing.py

+# %%
+# .. _metadata_routing_auto_request:
+#
+# Auto-Requesting Metadata


we're not adding routing here per-say, we're adding a default request on the consumer. Routing is set on routers, while here we change default values for consumers.

For third party developers the difference between the two ways is that one is always there, the other is only there if the user sets a global flag.

adrinjalali · 2025-06-03T07:36:07Z

examples/miscellaneous/plot_metadata_routing.py

+# 2. Instance-level defaults via the `add_auto_request` method, which would only
+#    request the metadata if ``set_config(metadata_request_policy="auto")`` is
+#    set.


Since it's a feature, I rather document it properly instead of skipping it.

adrinjalali · 2025-06-03T07:38:49Z

sklearn/utils/_metadata_requests.py

+    def add_auto_request(self, *params):
+        self._auto_requests.update(params)
+        return self
+
+    def actualize_auto_requests(self):
+        for param in self._auto_requests:
+            self.add_request(param=param, alias=True)
+        return self


those objects are not created by the user. They're created in our functions here. The user only modifies them.

adrinjalali · 2025-06-03T07:39:46Z

sklearn/utils/_metadata_requests.py

+    def actualize_auto_requests(self):
+        for method in SIMPLE_METHODS:
+            getattr(self, method).actualize_auto_requests()
+        return self


I don't think it matters. We have documented in the example file how people should be using it anyways.

adrinjalali · 2025-06-03T07:43:30Z

sklearn/utils/_metadata_requests.py

+        elif isinstance(obj, MetadataRouter):
+            self._self_request = deepcopy(obj._self_request)


it really shouldn't happen. This only happens in our tests and here it covers the edge case if it happens; but I don't think it would.

antoinebaker · 2025-06-04T14:48:54Z

Hello @adrinjalali and @StefanieSenger ! Sorry I think I'm a bit lost ;)

How does this new mechanism allow to solve the original intent of #30887, ie to have a config where scorers and estimators always request sample_weight (if they can) ?

For example, how could we implement a Mixin so that for all sklearn estimators, if the fit method has sample_weight in its signature, and the metadata_request_policy="auto" config is enabled, then it will automatically add sample_weight to the fit request ?

adrinjalali · 2025-06-04T15:02:07Z

For example, how could we implement a Mixin so that for all sklearn estimators, if the fit method has sample_weight in its signature, and the metadata_request_policy="auto" config is enabled, then it will automatically add sample_weight to the fit request ?

The idea is not to have something that automatically requests sample_weight if it's present in the signature. The idea is to have a Mixin which adds an auto request on sample_weight and we'd use that mixin only in places where we want to have it.

antoinebaker · 2025-06-04T14:57:07Z

sklearn/utils/_metadata_requests.py

+def _auto_routing_enabled():
+    """Return whether auto-requested metadata routing is enabled.


Maybe it should be called _auto_requests_enabled ?

antoinebaker · 2025-06-04T15:03:36Z

sklearn/utils/_metadata_requests.py

+    def actualize_auto_requests(self):
+        for param in self._auto_requests:
+            self.add_request(param=param, alias=True)
+        return self


Should we prevent adding auto requests when metadata_request_policy!="auto" ?

Suggested change

def actualize_auto_requests(self):

for param in self._auto_requests:

self.add_request(param=param, alias=True)

return self

def actualize_auto_requests(self):

if _auto_routing_enabled():

for param in self._auto_requests:

self.add_request(param=param, alias=True)

return self

antoinebaker · 2025-06-04T16:05:05Z

sklearn/utils/_metadata_requests.py

+        if _auto_routing_enabled():
+            if hasattr(requests, "actualize_auto_requests"):
+                requests.actualize_auto_requests()
+            if getattr(requests, "_self_request", None):
+                requests._self_request.actualize_auto_requests()


I guess here is where all the magic happens :)

The auto requests, defined at the instance level inside obj.get_metadata_routing(), are taken into consideration only when the auto request policy is enabled, and then added to the "default" requests, possibly overriding the class requests. The user can still specify requests afterwards. Did I get this right ?

I believe so. This is at least how I also understood it.

StefanieSenger

Thanks for your clarifications, @adrinjalali.

For example, how could we implement a Mixin so that for all sklearn estimators, if the fit method has sample_weight in its signature, and the metadata_request_policy="auto" config is enabled, then it will automatically add sample_weight to the fit request ?

I was thinking maybe something like combining available_if(_estimator_has("fit")) with inspect.signature(func) to set the class requests in a mixin could work? And maybe use the instance-level requests for a transition period until auto routing would be the default?

@antoinebaker I might be missing some context, but it seems you where asking whether setting class requests via mixins would be possible while auto metadata routing is not the default yet. Is such a roadmap existing, @adrinjalali?

StefanieSenger · 2025-06-05T11:54:51Z

examples/miscellaneous/plot_metadata_routing.py

+# %%
+# .. _metadata_routing_auto_request:
+#
+# Auto-Requesting Metadata


Yes thanks, I can see that now.

StefanieSenger · 2025-06-05T11:59:41Z

examples/miscellaneous/plot_metadata_routing.py

+# 2. Instance-level defaults via the `add_auto_request` method, which would only
+#    request the metadata if ``set_config(metadata_request_policy="auto")`` is
+#    set.


What I had meant was that the instance-level default setting doesn't need to be a feature to begin with.

Not sure if I get this right, but what I am thinking is:
Third party developers could only make use of it if they also have a set_config in their library that also checks if auto requests are enabled. The same for developers who customise a scikit-learn compatible estimator for their corporate project.

And then the functionality of setting instance level requests would be very limited. It's very similar to setting defaults at class level, only it adds a extra little condition of having auto requests enabled in the configs, no? 🤷‍♀️

StefanieSenger · 2025-06-05T12:18:13Z

sklearn/utils/_metadata_requests.py

+    def add_auto_request(self, *params):
+        self._auto_requests.update(params)
+        return self
+
+    def actualize_auto_requests(self):
+        for param in self._auto_requests:
+            self.add_request(param=param, alias=True)
+        return self


I meant developers who define a custom meta-estimator, not end-users.

I would then look something like this

requests = super().get_metadata_routing() requests.add_auto_request(fit="prop", predict="prop")

rather than like this, how it is now:

requests = super().get_metadata_routing() requests.fit.add_auto_request("prop") requests.predict.add_auto_request("prop")

And add_auto_request() would be a method on MetadataRequest instead of on MethodMetadataRequest, which I think spares a few iterations?

StefanieSenger · 2025-06-05T12:32:22Z

sklearn/utils/_metadata_requests.py

+    def actualize_auto_requests(self):
+        for method in SIMPLE_METHODS:
+            getattr(self, method).actualize_auto_requests()
+        return self


I might be misunderstanding, but I don’t see actualize_auto_requests documented in the example file.

My thought was that when third party developers call add_auto_request() and also use get_routing_for_object() (which internally calls actualize_auto_requests()) there’s no clear external use case for calling this method directly.

StefanieSenger · 2025-06-05T12:34:34Z

sklearn/utils/_metadata_requests.py

+        if _auto_routing_enabled():
+            if hasattr(requests, "actualize_auto_requests"):
+                requests.actualize_auto_requests()
+            if getattr(requests, "_self_request", None):
+                requests._self_request.actualize_auto_requests()


I believe so. This is at least how I also understood it.

adrinjalali · 2025-06-05T14:59:59Z

I was thinking maybe something like combining available_if(_estimator_has("fit")) with inspect.signature(func) to set the class requests in a mixin could work? And maybe use the instance-level requests for a transition period until auto routing would be the default?

It's certainly possible to inspect during runtime and do the magic, but I'd be opposed to the idea. I rather have the mixin be included only when we want to add the request, instead of checking the signature. If we want to check the signature and request metadata, then we can have a very different approach where metadata is always requested, no matter which metadata. I'm not opposed to that option, but that's a very different approach. I just don't want to special case sample_weight as a metadata in this approach. And as far as I remember from our meeting, we decided not to go down that path.

antoinebaker · 2025-06-06T10:45:39Z

Thanks for the clarification @adrinjalali and @StefanieSenger, I was confused about the goal of the auto request policy.

The idea is not to have something that automatically requests sample_weight if it's present in the signature. The idea is to have a Mixin which adds an auto request on sample_weight and we'd use that mixin only in places where we want to have it.

If I understand correctly, would you suggest the following plan to tackle #30887 ?

Have a mixin that add the auto request for sample_weight in fit

class AutoRequestSampleWeightFit():
    def get_metadata_routing(self):
        requests = super().get_metadata_routing()
        requests.fit.add_auto_request("sample_weight")
        return requests

Add this mixin to the sklearn estimators that need it (currenlty we think all of them that support sample_weight in fit).
Add a common estimator check that inspect the fit signature and the auto request of sample_weight to make sure that we did not forget anyone.
Do the same for scorers.
From the user perspective in ENH default routing policy for sample weight #30887, having to explicitly request the sample_weight for all consumers or not is a matter of config.

# current policy: need the verbose requests
sklearn.set_config(enable_metadata_routing=True, metadata_request_policy="empty")
scaler.set_fit_request(sample_weight=True)
spline.set_fit_request(sample_weight=True)
logistic.set_fit_request(sample_weight=True)
logistic.set_score_request(sample_weight=True)
pipe.set_score_request(sample_weight=True)
# new policy: no need for requests, `sample_weight` in meta-estimator works out of the box
sklearn.set_config(enable_metadata_routing=True, metadata_request_policy="auto")

adrinjalali · 2025-06-06T11:30:40Z

Yep, that's how I see it @antoinebaker .

adrinjalali added 11 commits February 27, 2025 16:22

FEAT enable default routing strategy machinery

4e9c8a7

cleanups

d4bd852

add example

2c38534

Merge remote-tracking branch 'upstream/main' into default_routing

53152e8

cleanup

d14200e

add changelog

fcbc431

Merge remote-tracking branch 'upstream/main' into default_routing

f24eecb

FEAT allow configuring automatically requested metadata

a35bf40

FEAT (alt3) allowing objects to define auto requests

58830aa

Merge remote-tracking branch 'upstream/main' into default_routing3

74c517c

fix tests

7279e40

github-actions bot added the module:utils label May 22, 2025

adrinjalali added 3 commits May 22, 2025 13:57

changelog

ce64d76

Merge remote-tracking branch 'upstream/main' into default_routing3

7b444a1

simplify

93fa28e

StefanieSenger reviewed May 23, 2025

View reviewed changes

StefanieSenger reviewed May 25, 2025

View reviewed changes

examples/miscellaneous/plot_metadata_routing.py Outdated Show resolved Hide resolved

StefanieSenger reviewed May 25, 2025

View reviewed changes

Apply suggestions from code review

a27cee9

Co-authored-by: Stefanie Senger <91849487+StefanieSenger@users.noreply.github.com>

adrinjalali commented Jun 3, 2025

View reviewed changes

antoinebaker reviewed Jun 4, 2025

View reviewed changes

StefanieSenger reviewed Jun 5, 2025

View reviewed changes

		elif isinstance(obj, MetadataRouter):
		self._self_request = deepcopy(obj._self_request)

	2. Before the user sets any specific routing, via `_get_default_requests`, it
	2. Before the developer of an estimator sets any specific routing,
	via `add_auto_request`, it

		return np.ones(len(X))


		# Let's see the default routing configuration

		def _auto_routing_enabled():
		"""Return whether auto-requested metadata routing is enabled.

Uh oh!

FEAT (alt3) allow setting auto routed strategy on objects #31413

Are you sure you want to change the base?

FEAT (alt3) allow setting auto routed strategy on objects #31413

Uh oh!

Conversation

adrinjalali commented May 22, 2025

Uh oh!

github-actions bot commented May 22, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

✔️ Linting Passed

Uh oh!

StefanieSenger left a comment • edited Loading Uh oh! There was an error while loading. Please reload this page.

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!

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!

StefanieSenger Jun 5, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

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!

StefanieSenger May 23, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

StefanieSenger May 23, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

StefanieSenger Jun 5, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

StefanieSenger May 23, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

StefanieSenger May 25, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

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!

adrinjalali 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

github-actions bot commented May 22, 2025 •

edited

Loading

StefanieSenger left a comment •

edited

Loading

StefanieSenger Jun 5, 2025 •

edited

Loading

StefanieSenger May 23, 2025 •

edited

Loading

StefanieSenger May 23, 2025 •

edited

Loading

StefanieSenger Jun 5, 2025 •

edited

Loading

StefanieSenger May 23, 2025 •

edited

Loading

StefanieSenger May 25, 2025 •

edited

Loading

StefanieSenger left a comment •

edited

Loading

StefanieSenger Jun 5, 2025 •

edited

Loading

StefanieSenger Jun 5, 2025 •

edited

Loading