reactive always_update with default from __init__

[davetapley]

I need to make this reactive always_update:

class SummaryWidget(Widget):
    sensor_id: reactive[Id] 

    def __init__(self, api_url: str, sensor_id: Id):
        super().__init__()
        self.api_url = api_url

However ⬇️ isn't valid because Argument missing for parameter "default"

    sensor_id: reactive[Id](always_update=True)

Neither is ⬇️ because Argument of type "None" cannot be assigned to parameter "default"

    sensor_id: reactive[Id](None, always_update=True)

And I can't change in __init__ ⬇️ because Cannot assign member "sensor_id" ... "reactive[Id]" is incompatible with "Id"

        self.sensor_id = reactive(sensor_id, always_update=True)

---

Luckily my Id is just a wrapper for str, so I can use this default as a placeholder:

    sensor_id: reactive[Id] = reactive(Id(''), always_update=True)

But I can imagine something which had no default.

[davep]

sensor_id: reactive[Id](None, always_update=True)

This would be the common idiom, just with the type declaration done to allow for None; you'll see it around Textual a fair bit.

[davep]

I wonder if I might be missing some aspect of this question, so let me ask as a way to better understand: when it comes to the need to check or assert in respect to None, while also wanting a variable that starts out with no value, what do you see it being until it has been assigned a value? Ignoring, for a moment, anything to do with reactives; if this were a normal Python variable or attribute how would you see this working?

I'm struggling to see how to have a variable with no value for some period of time, other than some sort of "this has no value" value, which would normally be None or, as an alternative, some sentinel value.

Or put another way: the Id(``) default approach above would still need those if statements or asserts in most cases, right? You'd want to handle the case where there is an empty ID?

Or put yet another way: if you could do the following:

sensor_id: reactive[Id] = reactive(always_update=True)

what value would you expect to find in self.sensor_id before assigning something to it?

As an aside, I noticed this: self._reactive_current = initial
is this some internal API I'm not supposed to see? 😁

Well, it's not that you're not supposed to see it -- this is FOSS code after all -- but the underscore prefix does alert to the fact that it can't be considered to be part of the public interface. However, that code isn't really doing what I think you're after anyway (if I've understood this question). That code is assigning a value to the reactive in a way to ensure that the the watch method doesn't get called.

[davep]

PS: I did forget to note last night: many of the example bits of code mentioned above aren't actually valid anyway, I've taken them to be typos, such that when you write:

sensor_id: reactive[Id](None, always_update=True)

you mean you have:

sensor_id: reactive[Id] = reactive(None, always_update=True)

etc.

[davetapley]

Ah, I think I see the confusion, thanks for bearing with me 🙏🏻

I definitely don't want this:

while also wanting a variable that starts out with no value

because yes, that makes no sense 🤪

I definitely do always have a sensor_id: Id to pass to the SummaryWidget constructor.

---

if this were a normal Python variable or attribute how would you see this working?

Consider this:

class Foo:
    n: str

    def __init__(self, n: str) -> None:
        self.n = n

foo = Foo('bar')
foo.n

Type checker is happy that foo.n is str ✅

But now I want to make n: str reactive with always_update.
That means I need to use the reactive constructor outside the __init__ definition (where the initial n is in scope).
So I'm stuck, I think:

    n: str = reactive[str]( # need to put a default value here

    def __init__(self, n: str) -> None: # but I only have n in scope here

---

Finally, this SO answer made me think maybe I could move the call to the reactive constructor, like this:

class Foo:
    n: reactive[str]

    def __init__(self, n: str) -> None:
        self.n = reactive[str](n, always_update=True)

but that fails to type check because:

 "reactive[str]" is incompatible with "str"

So maybe that SO answer isn't entirely correct.

[davep]

That makes more sense, thanks. To conclude then, no, I don't believe there's a (public, and I qualify that way because I don't know if there's an internal approach, and if there is it would likely be a bad idea to rely on it long-term) way to achieve what you're after here.

[willmcgugan]

reactive can also take a callable as the default value. Which can be useful if your default isn't a simple constant.