Props and AEP2 #54

pauleveritt · 2022-06-01T14:01:15Z

pauleveritt
Jun 1, 2022

I'm busy converting viewdom to use Antidote instead of my Hopscotch system. First big question: "props".

Frontend components use node attributes as arguments to the component. For example, a React component:

type HelloProps = {
  message: string;
};

const Hello = ({ message }: HelloProps) => <div>{message}</div>;

Then later, some usage:

<div>
  <Hello message={`Hello World`}/>
</div>

Thus, a single usage can provide a unique (but static) argument to the function.

Let's write that as a component in viewdom:

def Hello(message: str) -> VDOM:
    return html(f'<div>{message}</div>')

usage = html('<body><{Hello} message="World" //></body>')
print(render(usage))

You can also have a default value.

def Hello(message: str = 'World') -> VDOM:
    return html(f'<div>{message}</div>')

But you could also use injection, to avoid "prop drilling" (passing a value down a long component tree) plus other reasons.

class Config:
    MESSAGE = const('World')

def Hello(message: str = Config.MESSAGE) -> VDOM:
    return html(f'<div>{message}</div>')

However, we've just lost "props". There's no way to have a specific usage -- from a template -- pass in the value. If a value is passed in, it has higher priority than the injection.

How `viewdom` Does This

In viewdom, when you're in a template, the caller and callee are under its control. A template points at a component which might point to a subcomponent. viewdom needs to construct an instance. It has the injector, but it also has the "props" of the caller.

The injector goes through each parameter in the signature:

Is that parameter name a key in the props? If so, use it.
Is that parameter injectable? Inject it.
Does it have a default value? Use it.

Proposal

Antidote also has control of the caller and callee and handles construction of each parameter. But it has no place (currently) to find "props", which are a viewdom idea, not an Antidote idea.

AEP2 might help. viewdom, as it is rendering, could put the props in some @state value.

But that's not enough. The Antidote injector would have to know to look there first. Of course, Antidote could grow some framework-ness. But that has a smell. Not sure the answer.

Finistere · 2022-06-01T15:23:02Z

Finistere
Jun 1, 2022
Maintainer

However, we've just lost "props". There's no way to have a specific usage -- from a template -- pass in the value. If a value is passed in, it has higher priority than the injection.

If I understand you correctly, what you're missing is a way to override the injection globally, or within a context. I suppose to allow someone to change the default behavior of a component while leaving the possibility of overriding it locally with an explicit argument?

If so, const could support some form of global override, though only until it's used. It still has to behave like a singleton. :) For a context-specific override, intuitively I'd rather have Hello() depend on a context that would be injected. The context could be changed inside a context manager, in the spirit of:

@component
def Hello(message: str = 'World') -> VDOM:
    return html(f'<div>{message}</div>')

# defaults() added by @component, with the same argument as the Hello() function.
# overriding the default values of message.
with Hello.defaults(message="New World"): 
    ... # here the default value is "New World" when creating any Hello component

0 replies

pauleveritt · 2022-06-01T16:24:04Z

pauleveritt
Jun 1, 2022
Author

Yes, on the first paragraph, an explicit argument.

It isn't only with constants, by the way.

2 replies

Finistere Jun 1, 2022
Maintainer

For classes there is already @interface / @implements. For const, while not necessary as one can still provide its own override mechanism, it could be nice to have as their main usage is certainly configuration. Outside of those two, I don't see anything else that should support overrides. Supporting arbitrary overrides, outside of tests, seems like an anti-pattern to me.

Finistere Jun 1, 2022
Maintainer

Well, "anti-pattern" is too strong, but it makes maintainability difficult IMHO. Overriding should be well defined within some boundaries.

Finistere · 2022-06-01T17:20:08Z

Finistere
Jun 1, 2022
Maintainer

To be more explicit, I'd do something like this:

from __future__ import annotations

import inspect
from contextlib import contextmanager
from typing import Any, TypeVar, Generic, Iterator, Callable
from typing_extensions import ParamSpec

T = TypeVar('T')
P = ParamSpec('P')


class Component(Generic[P, T]):
    def __init__(self, func: Callable[P, T]) -> None:
        if any(p.kind != inspect.Parameter.KEYWORD_ONLY
               for p in inspect.signature(func).parameters.values()):
            raise TypeError()
        self.__defaults: dict[str, Any] = dict()
        self.__wrapped__ = func

    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
        assert not args
        kw = self.__defaults.copy()
        kw.update(**kwargs)
        return self.__wrapped__(**kw)

    @contextmanager
    def default(self, *args: P.args, **kwargs: P.kwargs) -> Iterator[None]:
        assert not args
        previous = self.__defaults.copy()
        self.__defaults.update(**kwargs)
        try:
            yield
        except Exception:
            self.__defaults = previous


def component(f: Callable[P, T]) -> Component[P, T]:
    return Component(f)


@component
def Hello(*, message: str = "World") -> str:
    return f"Hello {message}!"


print(Hello())
print(Hello(message="Test"))

with Hello.default(message="New"):
    print(Hello())

2 replies

Finistere Jun 1, 2022
Maintainer

And you could wrap Hello() with @inject or @lazy inside @component depending on your use case.

pauleveritt Jun 1, 2022
Author

Ok, I'll give that a shot. You're right, that kind of context manager usage is just what I need.

Finistere · 2022-06-01T20:12:46Z

Finistere
Jun 1, 2022
Maintainer

Ok, played a bit trying to use @lazy for the component, so it can depend on sub-component and so on. Currently, it's not that simple because Antidote either requires you to specify dependencies or you pass an explicit value. And neither works easily with literal values "World" and @lazy. What one actually needs is the same behavior as default values in a function which are only treated as dependencies if defined as such. This can be easily added to Antidote, it's pretty much there already. I'm just not sure what API should be exposed yet.

4 replies

Finistere Jun 1, 2022
Maintainer

After a quick hack it's becoming like this:

class Component(Generic[P, T]):
    def __init__(self, func: Callable[P, T]) -> None:
        if any(p.kind != inspect.Parameter.KEYWORD_ONLY
               for p in inspect.signature(func).parameters.values()):
            raise TypeError()
        self.__defaults: dict[str, Any] = dict()
        self.__wrapped__ = func
        self.__injected = lazy(func)

    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
        assert not args
        return self.__injected(**kwargs)

    @contextmanager
    def default(self, *args: P.args, **kwargs: P.kwargs) -> Iterator[None]:
        assert not args
        previous = self.__defaults.copy()
        self.__defaults.update(**kwargs)
        self.__injected = lazy(inject(self.__wrapped__, override_defaults=self.__defaults))
        try:
            yield
        except Exception:
            self.__defaults = previous


def component(f: Callable[P, T]) -> Component[P, T]:
    return Component(f)


@component
def Name() -> str:
    return "World"


@component
def Country() -> str:
    return "France"


@component
def Hello(*, name: str = Name()) -> str:
    return f"Hello {name}!"


print(world.get(Hello()))
print(world.get(Hello(name="John")))

with Hello.default(name=Country()):
    print(world.get(Hello()))

Which is nicer, you can now replace lazy components. The weird part is Hello(name="John") where you can't provide any components directly. @lazy should maybe parse arguments like override_defaults.... Not sure.

pauleveritt Jun 2, 2022
Author

PyCharm is unhappy with Hello() typing, and I know override_defaults is science fiction. But in general, the ability to manually interact with antidote.inject in that context manager looks like what I need.

Finistere Jun 2, 2022
Maintainer

I've actually implemented it quickly. It's a bit complex as an API, but since I favor flexibility in the core API, it looks good to me. I should also probably name it kwargs instead of override_defaults.

pauleveritt Jun 2, 2022
Author

Ok, I'll wait until I see a push that looks like it, then proceed.

Finistere · 2022-06-02T16:06:35Z

Finistere
Jun 2, 2022
Maintainer

Thinking again about your issue, it seems to me that @interface and @implements should support functions, in the a similar way @lazy does:

# Either pure contract
@interface
def current_user(short: bool = False) -> str:
    ...


# Or as the default implementation
@interface(as_default=True)
def current_user(short: bool = False) -> str:
    return "Unknown"


@implements(current_user)
def auto_detect(short: bool = False) -> str:
    return "John" if short else "John Doe"


@inject
def greeting(user: str = current_user(short=True)) -> str:
    return f"Hello {user}"

For the context part, it's not obvious if it's really something that should be handled at the framework level. For a global context, you could have a singleton (or eventually state) which you change and inject wherever necessary. For local context, it'd probably be better to just simply propagate it downwards.

2 replies

pauleveritt Jun 2, 2022
Author

It's interesting you mention that, as it was going to be my next discussion question, but I'm afraid that I've asked for too much. 😀 It's for something I have in my injector that I think is worthwhile, especially in the props discussion.

Finistere Jun 2, 2022
Maintainer

I was a bit in advance then. :) I'll probably add it with the as_default parameter. I'm unsure about the API to expose to pass predicate constraints when using it though in current_user(short=True)

pauleveritt · 2022-06-12T14:38:56Z

pauleveritt
Jun 12, 2022
Author

As an update, I have a package antidom which is my ViewDOM package with antidote instead of Hopscotch. I'm writing broken examples for things such as props, with comments in my component thing for where props would go.

4 replies

pauleveritt Jun 12, 2022
Author

I pushed a repo for Antidom which has a WIP with examples in antidom.examples.

Props aren't there
I have context resource working as a stateful provider but it will change to AEP2 later

I'm using protocols quite heavily. Everything works under mypy although I have to # type: ignore some things, plus I took a shortcut and used Any in some places.

Next I will do the science fiction for a larger system with Markdown files in a tree on disk.

Finistere Jun 13, 2022
Maintainer

Wow, awesome! I'm taking a look at it. And an excellent name! :D
On my side, took a break, but working on the props now. :) I'll probably introduce AEP2 with antidote v2 and a rework of the core part, some breaking changes. I will open a discussion on it.

pauleveritt Jun 13, 2022
Author

I thought you'd like the name. 😇 There's a bunch to improve via Antidote (and via techniques from you) but this is a good science-fiction start.

Continue your break, you deserve it. I've been very slow on my side when it comes to keeping up with you.

Finistere Jun 13, 2022
Maintainer

I'm using protocols quite heavily. Everything works under mypy although I have to # type: ignore some things, plus I took a shortcut and used Any in some places.

Nice! It's regularly a pain to have typing that really works, but it improves DX a lot. :)

There's a bunch to improve via Antidote (and via techniques from you) but this is a good science-fiction start.

Yes, definitely!

Continue your break, you deserve it. I've been very slow on my side when it comes to keeping up with you.

Thanks! I don't have the impression to be fast enough though. Question of perspective. :D

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Props and AEP2 #54

{{title}}

Replies: 6 comments 14 replies

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

Select a reply

Props and AEP2 #54

pauleveritt Jun 1, 2022

How viewdom Does This

Proposal

Replies: 6 comments · 14 replies

Finistere Jun 1, 2022 Maintainer

pauleveritt Jun 1, 2022 Author

Finistere Jun 1, 2022 Maintainer

Finistere Jun 1, 2022 Maintainer

Finistere Jun 1, 2022 Maintainer

Finistere Jun 1, 2022 Maintainer

pauleveritt Jun 1, 2022 Author

Finistere Jun 1, 2022 Maintainer

Finistere Jun 1, 2022 Maintainer

pauleveritt Jun 2, 2022 Author

Finistere Jun 2, 2022 Maintainer

pauleveritt Jun 2, 2022 Author

Finistere Jun 2, 2022 Maintainer

pauleveritt Jun 2, 2022 Author

Finistere Jun 2, 2022 Maintainer

pauleveritt Jun 12, 2022 Author

pauleveritt Jun 12, 2022 Author

Finistere Jun 13, 2022 Maintainer

pauleveritt Jun 13, 2022 Author

Finistere Jun 13, 2022 Maintainer

pauleveritt
Jun 1, 2022

How `viewdom` Does This

Replies: 6 comments 14 replies

Finistere
Jun 1, 2022
Maintainer

pauleveritt
Jun 1, 2022
Author

Finistere Jun 1, 2022
Maintainer

Finistere Jun 1, 2022
Maintainer

Finistere
Jun 1, 2022
Maintainer

Finistere Jun 1, 2022
Maintainer

pauleveritt Jun 1, 2022
Author

Finistere
Jun 1, 2022
Maintainer

Finistere Jun 1, 2022
Maintainer

pauleveritt Jun 2, 2022
Author

Finistere Jun 2, 2022
Maintainer

pauleveritt Jun 2, 2022
Author

Finistere
Jun 2, 2022
Maintainer

pauleveritt Jun 2, 2022
Author

Finistere Jun 2, 2022
Maintainer

pauleveritt
Jun 12, 2022
Author

pauleveritt Jun 12, 2022
Author

Finistere Jun 13, 2022
Maintainer

pauleveritt Jun 13, 2022
Author

Finistere Jun 13, 2022
Maintainer