Why isn't there a state.get?

[HHongSeungWoo]

I am interested in using state to manage shared variables that are valid only in specific contexts.

The issue I'm encountering here is that due to certain attributes being optionally present, I hope to retrieve them using a form similar to dict.get(key, defaultvalue).

However, as only __getattr__ is exposed, this approach is not feasible.

The alternative is to use getattr or try-except, but this may lead to code becoming unnecessarily messy or encountering performance issues.

Here's my test code:

import typing


class State:
    """
    An object that can be used to store arbitrary state.

    Used for `request.state` and `app.state`.
    """

    _state: dict[str, typing.Any]

    def __init__(self, state: typing.Optional[dict[str, typing.Any]] = None):
        if state is None:
            state = {}
        super().__setattr__("_state", state)

    def __setattr__(self, key: typing.Any, value: typing.Any) -> None:
        self._state[key] = value

    def __getattr__(self, key: typing.Any) -> typing.Any:
        try:
            return self._state[key]
        except KeyError:
            message = "'{}' object has no attribute '{}'"
            raise AttributeError(message.format(self.__class__.__name__, key))

    def get(self, *args) -> typing.Any:
        return self._state.get(*args)

    def __delattr__(self, key: typing.Any) -> None:
        del self._state[key]


a = State()
a.a = 1

print(timeit.timeit(lambda: getattr(a, "a", 1), number=1000000))  # 0.7733922990009887 sec
print(timeit.timeit(lambda: getattr(a, "b", 1), number=1000000))  # 2.1195701920005376 sec
print(timeit.timeit(lambda: a.a, number=1000000))  # 0.7601594750012737 sec
print(timeit.timeit(lambda: a.get("a", 1), number=1000000))  # 0.28440772099929745 sec
print(timeit.timeit(lambda: a.get("b", 1), number=1000000))  # 0.282369396998547 sec

b = {"a": 1}

print(timeit.timeit(lambda: b.get("a", 1), number=1000000))  # 0.044479219999630004 sec
print(timeit.timeit(lambda: b.get("b", 1), number=1000000))  # 0.04605066899966914 sec
print(timeit.timeit(lambda: b["a"], number=1000000))  # 0.038096161999419564 sec
print(timeit.timeit(lambda: getattr(b, "b", 1), number=1000000))  # 0.0552535960014211 sec

What do you think about exposing the get method in the state

[adriangb]

@Kludex do you see any reason not to make state a UserDict or make it implement the full MutableMapping API?

[Kludex]

Oh! That's unfortunate...

[HHongSeungWoo]

If you don't need to maintain a reference to self.scope["state"], how about using SimpleNamespace?
It shows much better performance. Below is the test.

import timeit
import typing
from types import SimpleNamespace


class State:
    """
    An object that can be used to store arbitrary state.

    Used for `request.state` and `app.state`.
    """

    _state: dict[str, typing.Any]

    def __init__(self, state: dict[str, typing.Any] | None = None):
        if state is None:
            state = {}
        super().__setattr__("_state", state)

    def __setattr__(self, key: typing.Any, value: typing.Any) -> None:
        self._state[key] = value

    def __getattr__(self, key: typing.Any) -> typing.Any:
        try:
            return self._state[key]
        except KeyError:
            message = "'{}' object has no attribute '{}'"
            raise AttributeError(message.format(self.__class__.__name__, key))

    def __delattr__(self, key: typing.Any) -> None:
        del self._state[key]


class NewState(SimpleNamespace):
    def __init__(self, state: dict[str, typing.Any] | None = None):
        if state is None:
            state = {}
        super().__init__(**state)


lifespan_state = {"foo": 1}

old = State(lifespan_state)
new = NewState(lifespan_state)

print(old.foo, new.foo)  # 1, 1

lifespan_state["bar"] = 2
print(old.bar)  # 2
# print(new.bar)  # AttributeError
del lifespan_state["bar"]


print(timeit.timeit(lambda: getattr(old, "foo", 1), number=1000000))  # 0.8253514589960105 sec
print(timeit.timeit(lambda: old.foo, number=1000000))  # 0.8048310750018572 sec
print(timeit.timeit(lambda: getattr(old, "bar", 1), number=1000000))  # 2.33300188400608 sec

print(timeit.timeit(lambda: getattr(new, "foo", 1), number=1000000))  # 0.06209340899658855 sec
print(timeit.timeit(lambda: new.foo, number=1000000))  # 0.05458102400007192 sec
print(timeit.timeit(lambda: getattr(new, "bar", 1), number=1000000))  # 0.06926074200600851 sec

[Kludex]

Can you open a PR demonstrating the changes? No tests need to be changed?

[HHongSeungWoo]

Sure, it seems like there are no issues with the tests as well.

[HHongSeungWoo]

Oh no, the test is failing. 😢

[gnat]

Should be done before 1.0 IMHO.

Been a pet peeve of mine for ages.