[OM] Simplify the Python instantiate API to just return Objects. #5400
Conversation
This API previously accepted a Python dataclass as input, and used it as a template to guide the logic to pull fields out of the instantiated Object and build an instance of the requested dataclass. This allowed the API to be strongly typed, by accepting a dataclass type as input and returning an instance of that dataclass as output. However, this requires the user to specify a-priori what fields should be present in the resulting Object, and this may not always be known. By simply returning an Object, and adding the appropriate Python conversions to Object's __getattr__, we can generically return Objects that behave just like the previous dataclasses, without specifying the fields up front. This also avoids rewrapping the Objects in dataclasses. In the future, we can add back a similar form of type safety when this would be useful, potentially using Protocols similarly to how dataclasses were used as a template before.
There was a problem hiding this comment.
Hmm, that's unfortunate that we lose static typing but it totally makes sense to me. Maybe we can make instantiate to give static type only when dataclass type is given, something like instantiate(self, cls: Union[str, type["DataclassInstance"]], *args: Any) -> Union[Object, "DataclassInstance"]. Not sure mypy is smart enough to perform this kind of flow sensitive typing, but anyway the current implementation looks simple and great to me!
|
Thanks, yeah I think we can do something interesting here. I think for now, I'd prefer to do something simple that works, and figure out the static typing story once we're happy with the actual functionality. |
|
Thanks for the reviews. I think what we can probably do is add a method that takes a protocol and verifies that an object implements the protocol. That's basically a simple type checker. We should be able to compose the API I just merged with that new API, and have something like |
This API previously accepted a Python dataclass as input, and used it as a template to guide the logic to pull fields out of the instantiated Object and build an instance of the requested dataclass.
This allowed the API to be strongly typed, by accepting a dataclass type as input and returning an instance of that dataclass as output. However, this requires the user to specify a-priori what fields should be present in the resulting Object, and this may not always be known.
By simply returning an Object, and adding the appropriate Python conversions to Object's getattr, we can generically return Objects that behave just like the previous dataclasses, without specifying the fields up front. This also avoids rewrapping the Objects in dataclasses.
In the future, we can add back a similar form of type safety when this would be useful, potentially using Protocols similarly to how dataclasses were used as a template before.