Dynamic default value or factory for function argument

[xbanke]

• typical version: 2.0.1
• Python version: 3.7.4
• Operating System:

Description

Hey, @seandstewart . I have another feature request.
For data model, there is default_factory which can be used to set dynamic default value. For function argument, if set the default value as a instance of typic.Field, it won't be validated as a default value. datetime.now as a default_factory is quite common. Every time I have to handle it like this:

from datetime import datetime
import typic

@typic.al
def foo(dt: datetime = None):
    dt = datetime.now() if dt is None else dt
    ...

Especilly when we have many functions with dynamic default value, it would be a problem. Currently, beacuse the default value would not be validated, I defined a Helper class to solve this.

from typing import Callable, Optional, Any
from functools import wraps
import inspect
from dataclasses import MISSING
import typic

class DefaultArgument:
    def __init__(self, default: Any = MISSING, *, factory: Optional[Callable] = None):
        assert default is not MISSING or callable(factory)
        self.default = default
        self.factory = factory

    def __call__(self, *args, **kwargs):
        if self.default is not MISSING:
            return self.default
        return self.factory(*args, **kwargs)

    def __repr__(self):
        return f"{self.__class__.__name__}(default={self.default}, factory={self.factory!r})"


def validate(func: Optional[Callable] = None, *, coerce: bool = True, strict: bool = False) -> Callable:
    def _validate(_func: Callable):
        @wraps(func)
        def wrapped(*args, **kwargs):
            bind = inspect.signature(_func).bind(*args, **kwargs)
            bind.apply_defaults()  # apply_defaults is not available in typic.bind
            for k, v in bind.arguments.items():
                if isinstance(v, DefaultArgument):
                    bind.arguments[k] = v()
            return typic.bind(_func, *bind.args, partial=False, coerce=coerce, strict=strict, **bind.kwargs).eval()

        return wrapped

    if callable(func):
        return _validate(func)
    else:
        return _validate

Now we can redefine foo like this:

from datetime import datetime

@validate
def foo(dt: datetime = DefaultArgument(factory=datetime.now)):
    ...

By the way, what if the user want to use the key words such as dict, schema, coerce, strict and so on, as the function argument or data attribute?

[seandstewart]

Hey again, @xbanke -

This is a great idea, and again, thank you for the detailed example. I haven’t focused much on this issue in the past because the original focus of the decorator was simply to ensure external inputs are the type you expect, but I do see the value here.

I’m beginning to compile a list of features for the next minor release - I definitely think this is achievable and worth adding to it.

[xbanke]

I'm Looking forward to that. When will you release the next version?