Dynamically Assigning Attributes to Instance Objects

[adam-grant-hendry]

I know the mypy docs explain:

You can only define an instance variable within a method if you assign to it explicitly using self

and that

This is a bit like each class having an implicitly defined slots attribute

Hence, it makes sense that I can't dynamically add an attribute to an instance variable like so

# instance `a` of `A` doesn't have attribute `b`, so this fails
self.a.b = B()

because that would defeat the purpose (the point of this error is that it's common to accidentally access an attribute that doesn't exist).

But if I explicitly # type: ignore[attr-defined] it, is there a reason why asserting a hasattr doesn't work in another statically typed function?

See: this mypy demo

NB: It's most likely better to make A a MutableSequence (override __getitem__, __setitem__, __delitem__, __len__, and __insert__) and then do something like:

self.a['b'] = B()

but I am curious if the hasattr example is by design for some reason?

[Akuli]

Mypy doesn't special-case hasattr() in any way. As far as it's considered, it's just a function taking in an object and a string, and returning a boolean (as defined in typeshed). When it sees assert hasattr(...), it sees that you are asserting the value of some boolean, and nothing else.

If you want class A to have dynamically assignable attributes, you should first ask yourself whether you really need it. In most cases, making it a dict would not only be easier for type checkers to understand, but also for humans reading the code.

That said, if you really want dynamic attributes, you can tell mypy to always allow setting and getting attributes on instances of A:

from typing import Any, TYPE_CHECKING

class A:
    if TYPE_CHECKING:
        def __getattr__(self, attribute: str) -> Any: ...
        def __setattr__(self, attribute: str, value: object) -> None: ...

If you want to silence only the error from self.a.b = B(), you can use setattr(), which similarly to hasattr() has no special meaning to mypy:

setattr(self.a, 'b', B())

[adam-grant-hendry]

Once you have added type hints to a function, mypy automatically type checks the function body via type inferencing. You can use assert for certain kinds of type guarding, like telling mypy that a value is never None and type narrowing.

Seems odd that hasattr isn't in the list of type narrowing expressions as well...

[Akuli]

I can think of a couple reasons why not:

• All ...attr() functions are named similarly, so people expect them to behave similarly. So if hasattr() has a special meaning but getattr() and setattr() don't, it would be confusing. But adding a special meaning to getattr() and setattr() would basically mean that my setattr(self.a, 'b', B()) trick no longer works as expected.
• It would be complicated to implement. What should the narrowed type be? The type checker would need to make up a new imaginary subclass of B that has an attribute b of type Any when you do if hasattr(self.a, 'b'). In other type narrowing that type checkers do, the narrowed type already exists, such as when str | None is narrowed to str in a None check: we don't have to "invent" a new type just to represent the result of the narrowing because because we can just use str.