Skip to content

value_schema

Classes

ValueSchema

Bases: KiaraModel

The schema of a value.

The schema contains the [ValueTypeOrm][kiara.data.values.ValueTypeOrm] of a value, as well as an optional default that will be used if no user input was given (yet) for a value.

For more complex container data_types like array, tables, unions etc, data_types can also be configured with values from the type_config field.

Source code in src/kiara/models/values/value_schema.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
class ValueSchema(KiaraModel):
    """
    The schema of a value.

    The schema contains the [ValueTypeOrm][kiara.data.values.ValueTypeOrm] of a value, as well as an optional default that
    will be used if no user input was given (yet) for a value.

    For more complex container data_types like array, tables, unions etc, data_types can also be configured with values from the ``type_config`` field.
    """

    _kiara_model_id: ClassVar = "instance.value_schema"
    model_config = ConfigDict(use_enum_values=True)

    type: str = Field(description="The type of the value.")
    type_config: Dict[str, Any] = Field(
        description="Configuration for the type, in case it's complex.",
        default_factory=dict,
    )
    default: Any = Field(description="A default value.", default=SpecialValue.NOT_SET)

    optional: bool = Field(
        description="Whether this value is required (True), or whether 'None' value is allowed (False).",
        default=False,
    )
    is_constant: bool = Field(
        description="Whether the value is a constant.", default=False
    )

    doc: DocumentationMetadataModel = Field(
        default_factory=DocumentationMetadataModel,
        description="A description for the value of this input field.",
    )

    @field_serializer("default")
    def serialize_default(self, value):
        if value in [SpecialValue.NOT_SET, SpecialValue.NO_VALUE]:
            return None
        elif callable(value):
            return value()
        else:
            return value

    @field_validator("doc", mode="before")
    @classmethod
    def validate_doc(cls, value):
        doc = DocumentationMetadataModel.create(value)
        return doc

    def _retrieve_data_to_hash(self) -> Any:
        return {"type": self.type, "type_config": self.type_config}

    def is_required(self):
        if self.optional:
            return False
        else:
            if self.default in [None, SpecialValue.NOT_SET, SpecialValue.NO_VALUE]:
                return True
            else:
                return False

    # def validate_types(self, kiara: "Kiara"):
    #
    #     if self.type not in kiara.value_type_names:
    #         raise ValueError(
    #             f"Invalid value type '{self.type}', available data_types: {kiara.value_type_names}"
    #         )

    def __eq__(self, other):
        if not isinstance(other, ValueSchema):
            return False

        return (self.type, self.default) == (other.type, other.default)

    def __hash__(self):
        return hash((self.type, self.default))

    def __repr__(self):
        return f"ValueSchema(type={self.type}, default={self.default}, optional={self.optional})"

    def __str__(self):
        return self.__repr__()

Attributes

model_config = ConfigDict(use_enum_values=True) class-attribute instance-attribute
type: str = Field(description='The type of the value.') class-attribute instance-attribute
type_config: Dict[str, Any] = Field(description="Configuration for the type, in case it's complex.", default_factory=dict) class-attribute instance-attribute
default: Any = Field(description='A default value.', default=(SpecialValue.NOT_SET)) class-attribute instance-attribute
optional: bool = Field(description="Whether this value is required (True), or whether 'None' value is allowed (False).", default=False) class-attribute instance-attribute
is_constant: bool = Field(description='Whether the value is a constant.', default=False) class-attribute instance-attribute
doc: DocumentationMetadataModel = Field(default_factory=DocumentationMetadataModel, description='A description for the value of this input field.') class-attribute instance-attribute

Functions

serialize_default(value)
Source code in src/kiara/models/values/value_schema.py 
50
51
52
53
54
55
56
57
@field_serializer("default")
def serialize_default(self, value):
    if value in [SpecialValue.NOT_SET, SpecialValue.NO_VALUE]:
        return None
    elif callable(value):
        return value()
    else:
        return value
validate_doc(value) classmethod
Source code in src/kiara/models/values/value_schema.py 
59
60
61
62
63
@field_validator("doc", mode="before")
@classmethod
def validate_doc(cls, value):
    doc = DocumentationMetadataModel.create(value)
    return doc
is_required()
Source code in src/kiara/models/values/value_schema.py 
68
69
70
71
72
73
74
75
def is_required(self):
    if self.optional:
        return False
    else:
        if self.default in [None, SpecialValue.NOT_SET, SpecialValue.NO_VALUE]:
            return True
        else:
            return False