Better Result Objects

[AKuederle]

At the moment all attributes with a trailing underscore are considered results.
This works nice in a general case.

It becomes a little annoying when using dataclasses/attrs, as we need to exclude these fields explicitly, when we provided type information for them.

Further, to don't make the API even more confusing, we only allow the run method to write these attributes. The optimize methods have no way to write results (see #46, #45).

Overcomming both issues, we could allow to define nested typed classes to store results in.
With a little bit of magic (see below), we can enforce that each instance automatically gets a fresh instance of the class to write results in.

We could either enforce naiming of the these objects (e.g. r_, R_) for the actual results or we could use the decorator to mark and find them.

With that we could also allow to define specific additional optimization results. Either using a specific name or a seperate decorator.

from typing import Any, Literal, Optional, Type, Generic, TypeVar, Union, overload

T = TypeVar("T")


class _Generic:
    def __setattr__(self, __name: str, __value: Any) -> None:
        super().__setattr__(__name, __value)

    def __getattr__(self, __name: str) -> None:
        return self.__dict__[__name]


class result(Generic[T]):
    name: str
    klass: Type[T]

    def __init__(self, klass: Type[T] = _Generic):
        self.klass = klass

    def __set_name__(self, owner, name):
        self.name = name

    @overload
    def __get__(self, obj: Literal[None], objtype: Any) -> Type[T]:
        pass

    @overload
    def __get__(self, obj: object, objtype: Any) -> T:
        pass

    def __get__(self, obj: Optional[object], objtype: Any = None) -> Union[T, Type[T]]:
        if obj:
            new_instance = self.klass()
            name: str = getattr(self, "name", self.klass.__name__)
            setattr(obj, name, new_instance)
            return new_instance
        return self.klass


class ParentClassWithTypedResults:
    @result
    class R_:
        test: str


class ParentClassUntypedResults:
    r_ = result()


a = ParentClassUntypedResults()
a.something = "bla"

a = ParentClassWithTypedResults()
a.test = "blas"

Unfortunately, Pycharms autocomplete is not happy with the decorator and we don't get typechecking or autocomplete for the TypedResults case. VsCode works