Skip to content

omnipy.data.param

CLASS DESCRIPTION
ParamsBase
FUNCTION DESCRIPTION
bind_adjust_dataset_func
bind_adjust_model_func
params_dataclass

ParamsBase

Bases: pyd.BaseModel

CLASS DESCRIPTION
Config
METHOD DESCRIPTION
copy_and_adjust
Source code in src/omnipy/data/param.py 
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
class ParamsBase(pyd.BaseModel, metaclass=_ParamsMeta):
    class Config:
        arbitrary_types_allowed = True
        smart_union = True

    def __new__(cls, *args: object, **kwargs: object) -> None:  # type: ignore[misc]
        raise RuntimeError(f'{cls.__name__} cannot be instantiated')

    @classmethod
    def copy_and_adjust(cls, model_name: str, **kwargs: object) -> type['ParamsBase']:
        all_field_infos = {
            field_name: deepcopy(field.field_info) for field_name, field in cls.__fields__.items()
        }

        for key, value in kwargs.items():
            all_field_infos[key].default = value

        field_definitions: dict[str, Any] = {
            field_name: (cls.__fields__[field_name].outer_type_, field_info)
            for field_name, field_info in all_field_infos.items()
        }
        return pyd.create_model(  # type: ignore[call-overload]
            model_name, __base__=ParamsBase, **field_definitions)

Config

ATTRIBUTE DESCRIPTION
arbitrary_types_allowed

smart_union

Source code in src/omnipy/data/param.py 
62
63
64
class Config:
    arbitrary_types_allowed = True
    smart_union = True

arbitrary_types_allowed class-attribute instance-attribute 

arbitrary_types_allowed = True

smart_union class-attribute instance-attribute 

smart_union = True

copy_and_adjust classmethod 

copy_and_adjust(model_name: str, **kwargs: object) -> type[ParamsBase]
Source code in src/omnipy/data/param.py 
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
@classmethod
def copy_and_adjust(cls, model_name: str, **kwargs: object) -> type['ParamsBase']:
    all_field_infos = {
        field_name: deepcopy(field.field_info) for field_name, field in cls.__fields__.items()
    }

    for key, value in kwargs.items():
        all_field_infos[key].default = value

    field_definitions: dict[str, Any] = {
        field_name: (cls.__fields__[field_name].outer_type_, field_info)
        for field_name, field_info in all_field_infos.items()
    }
    return pyd.create_model(  # type: ignore[call-overload]
        model_name, __base__=ParamsBase, **field_definitions)

bind_adjust_dataset_func 

bind_adjust_dataset_func(
    clone_dataset_func: Callable[..., type[_DatasetT]],
    model_cls: type[_ModelT],
    params_cls: Callable[_ParamsP, Any],
) -> Callable[Concatenate[str, str, _ParamsP], type[_DatasetT]]
Source code in src/omnipy/data/param.py 
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
def bind_adjust_dataset_func(
    clone_dataset_func: Callable[..., type[_DatasetT]],
    model_cls: type[_ModelT],
    params_cls: Callable[_ParamsP, Any],
) -> Callable[Concatenate[str, str, _ParamsP], type[_DatasetT]]:
    def _func(dataset_name: str, model_name: str, *args: _ParamsP.args,
              **kwargs: _ParamsP.kwargs) -> type[_DatasetT]:
        if len(args) > 0:
            raise AttributeError(f'Positional arguments are not supported for '
                                 f'{params_cls.__module__}.{params_cls.__name__}')
        new_model_cls: type[_ModelT] = cast(
            type[_ModelT],
            model_cls.adjust(model_name, **kwargs),  # type: ignore[attr-defined]
        )

        new_dataset_cls = clone_dataset_func(dataset_name, new_model_cls)
        new_model_cls.Params = params_cls.copy_and_adjust(  # type: ignore[attr-defined]
            'Params',
            **kwargs,
        )
        return new_dataset_cls

    return _func

bind_adjust_model_func 

bind_adjust_model_func(
    clone_model_func: Callable[..., type[_ModelT]], params_cls: Callable[_ParamsP, Any]
) -> Callable[Concatenate[str, _ParamsP], type[_ModelT]]
Source code in src/omnipy/data/param.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
def bind_adjust_model_func(
    clone_model_func: Callable[..., type[_ModelT]],
    params_cls: Callable[_ParamsP, Any],
) -> Callable[Concatenate[str, _ParamsP], type[_ModelT]]:
    def _func(model_name: str, *args: _ParamsP.args, **kwargs: _ParamsP.kwargs) -> type[_ModelT]:
        if len(args) > 0:
            raise AttributeError(f'Positional arguments are not supported for '
                                 f'{params_cls.__module__}.{params_cls.__name__}')
        new_model_cls = clone_model_func(model_name)
        new_model_cls.Params = params_cls.copy_and_adjust(  # type: ignore[attr-defined]
            'Params',
            **kwargs,
        )
        return new_model_cls

    return _func

params_dataclass 

params_dataclass(cls: type[_ParamsT]) -> type[_ParamsT]
Source code in src/omnipy/data/param.py 
129
130
131
132
133
134
@dataclass_transform(kw_only_default=True)
def params_dataclass(cls: type[_ParamsT]) -> type[_ParamsT]:
    def wrap(cls):
        return dataclass(cls, kw_only=True)

    return wrap(cls)