Skip to content

Metadata Properties

Metadata properties are used to define metadata fields in a dataset. Metadata fields are used to store additional information about the records in the dataset. For example, the category of a record, the price of a product, or any other information that is relevant to the record.

Usage Examples

Defining Metadata Property for a dataset

We define metadata properties via type specific classes. The following example demonstrates how to define metadata properties as either a float, integer, or terms metadata property:

TermsMetadataProperty is used to define a metadata field with a list of options. For example, a color field with options red, blue, and green. FloatMetadataProperty and IntegerMetadataProperty is used to define a metadata field with a float value. For example, a price field with a minimum value of 0.0 and a maximum value of 100.0.

import argilla_sdk as rg

# Define metadata properties as terms
metadata_field = rg.TermsMetadataProperty(
    name="color",
    options=["red", "blue", "green"],
    title="Color",
)

# Define metadata properties as float
float_ metadata_field = rg.FloatMetadataProperty(
    name="price",
    min=0.0,
    max=100.0,
    title="Price",
)

# Define metadata properties as integer
int_metadata_field = rg.IntegerMetadataProperty(
    name="quantity",
    min=0,
    max=100,
    title="Quantity",
)

Metadata properties can be added to a dataset settings object:

dataset = rg.Dataset(
    name="my_dataset",
    settings=rg.Settings(
        fields=[
            rg.TextField(name="text"),
        ],
        metadata=[
            metadata_field,
            float_metadata_field,
            int_metadata_field,
        ],
    ),
)

To add records with metadata, refer to the rg.Metadata class documentation.

Class References

rg.FloatMetadataProperty

Bases: MetadataPropertyBase

Source code in src/argilla_sdk/settings/_metadata.py 
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
class FloatMetadataProperty(MetadataPropertyBase):
    def __init__(
        self,
        name: str,
        min: Optional[float] = None,
        max: Optional[float] = None,
        title: Optional[str] = None,
        client: Optional[Argilla] = None,
    ) -> None:
        """Create a metadata field with float settings.

        Parameters:
            name (str): The name of the metadata field
            min (Optional[float]): The minimum value
            max (Optional[float]): The maximum value
            title (Optional[str]): The title of the metadata field
            client (Optional[Argilla]): The client to use for API requests
        Raises:
            MetadataError: If an error occurs while defining metadata settings

        """

        super().__init__(client=client)

        try:
            settings = FloatMetadataPropertySettings(min=min, max=max, type=MetadataPropertyType.float)
        except ValueError as e:
            raise MetadataError(f"Error defining metadata settings for {name}") from e

        self._model = MetadataFieldModel(
            name=name,
            type=MetadataPropertyType.float,
            title=title,
            settings=settings,
        )

    @property
    def min(self) -> Optional[int]:
        return self._model.settings.min

    @min.setter
    def min(self, value: Optional[int]) -> None:
        self._model.settings.min = value

    @property
    def max(self) -> Optional[int]:
        return self._model.settings.max

    @max.setter
    def max(self, value: Optional[int]) -> None:
        self._model.settings.max = value

    @classmethod
    def from_model(cls, model: MetadataFieldModel) -> "FloatMetadataProperty":
        instance = FloatMetadataProperty(name=model.name)
        instance._model = model

        return instance

__init__(name, min=None, max=None, title=None, client=None)

Create a metadata field with float settings.

Parameters:

Name Type Description Default
name str

The name of the metadata field

 required
min Optional[float]

The minimum value

 None
max Optional[float]

The maximum value

 None
title Optional[str]

The title of the metadata field

 None
client Optional[Argilla]

The client to use for API requests

 None

Raises: MetadataError: If an error occurs while defining metadata settings

Source code in src/argilla_sdk/settings/_metadata.py 
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
def __init__(
    self,
    name: str,
    min: Optional[float] = None,
    max: Optional[float] = None,
    title: Optional[str] = None,
    client: Optional[Argilla] = None,
) -> None:
    """Create a metadata field with float settings.

    Parameters:
        name (str): The name of the metadata field
        min (Optional[float]): The minimum value
        max (Optional[float]): The maximum value
        title (Optional[str]): The title of the metadata field
        client (Optional[Argilla]): The client to use for API requests
    Raises:
        MetadataError: If an error occurs while defining metadata settings

    """

    super().__init__(client=client)

    try:
        settings = FloatMetadataPropertySettings(min=min, max=max, type=MetadataPropertyType.float)
    except ValueError as e:
        raise MetadataError(f"Error defining metadata settings for {name}") from e

    self._model = MetadataFieldModel(
        name=name,
        type=MetadataPropertyType.float,
        title=title,
        settings=settings,
    )

rg.IntegerMetadataProperty

Bases: MetadataPropertyBase

Source code in src/argilla_sdk/settings/_metadata.py 
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
class IntegerMetadataProperty(MetadataPropertyBase):
    def __init__(
        self,
        name: str,
        min: Optional[int] = None,
        max: Optional[int] = None,
        title: Optional[str] = None,
        client: Optional[Argilla] = None,
    ) -> None:
        """Create a metadata field with integer settings.

        Parameters:
            name (str): The name of the metadata field
            min (Optional[int]): The minimum value
            max (Optional[int]): The maximum value
            title (Optional[str]): The title of the metadata field
        Raises:
            MetadataError: If an error occurs while defining metadata settings
        """
        super().__init__(client=client)

        try:
            settings = IntegerMetadataPropertySettings(min=min, max=max, type=MetadataPropertyType.integer)
        except ValueError as e:
            raise MetadataError(f"Error defining metadata settings for {name}") from e

        self._model = MetadataFieldModel(
            name=name,
            type=MetadataPropertyType.integer,
            title=title,
            settings=settings,
        )

    @property
    def min(self) -> Optional[int]:
        return self._model.settings.min

    @min.setter
    def min(self, value: Optional[int]) -> None:
        self._model.settings.min = value

    @property
    def max(self) -> Optional[int]:
        return self._model.settings.max

    @max.setter
    def max(self, value: Optional[int]) -> None:
        self._model.settings.max = value

    @classmethod
    def from_model(cls, model: MetadataFieldModel) -> "IntegerMetadataProperty":
        instance = IntegerMetadataProperty(name=model.name)
        instance._model = model

        return instance

__init__(name, min=None, max=None, title=None, client=None)

Create a metadata field with integer settings.

Parameters:

Name Type Description Default
name str

The name of the metadata field

 required
min Optional[int]

The minimum value

 None
max Optional[int]

The maximum value

 None
title Optional[str]

The title of the metadata field

 None

Raises: MetadataError: If an error occurs while defining metadata settings

Source code in src/argilla_sdk/settings/_metadata.py 
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
def __init__(
    self,
    name: str,
    min: Optional[int] = None,
    max: Optional[int] = None,
    title: Optional[str] = None,
    client: Optional[Argilla] = None,
) -> None:
    """Create a metadata field with integer settings.

    Parameters:
        name (str): The name of the metadata field
        min (Optional[int]): The minimum value
        max (Optional[int]): The maximum value
        title (Optional[str]): The title of the metadata field
    Raises:
        MetadataError: If an error occurs while defining metadata settings
    """
    super().__init__(client=client)

    try:
        settings = IntegerMetadataPropertySettings(min=min, max=max, type=MetadataPropertyType.integer)
    except ValueError as e:
        raise MetadataError(f"Error defining metadata settings for {name}") from e

    self._model = MetadataFieldModel(
        name=name,
        type=MetadataPropertyType.integer,
        title=title,
        settings=settings,
    )

rg.TermsMetadataProperty

Bases: MetadataPropertyBase

Source code in src/argilla_sdk/settings/_metadata.py 
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
class TermsMetadataProperty(MetadataPropertyBase):
    def __init__(
        self,
        name: str,
        options: Optional[List[str]] = None,
        title: Optional[str] = None,
        visible_for_annotators: Optional[bool] = True,
        client: Optional[Argilla] = None,
    ) -> None:
        """Create a metadata field with terms settings.

        Parameters:
            name (str): The name of the metadata field
            options (Optional[List[str]]): The list of options
            title (Optional[str]): The title of the metadata field
            visible_for_annotators (Optional[bool]): Whether the metadata field is visible for annotators
        Raises:
            MetadataError: If an error occurs while defining metadata settings
        """
        super().__init__(client=client)

        try:
            settings = TermsMetadataPropertySettings(values=options, type=MetadataPropertyType.terms)
        except ValueError as e:
            raise MetadataError(f"Error defining metadata settings for {name}") from e

        self._model = MetadataFieldModel(
            name=name,
            type=MetadataPropertyType.terms,
            title=title,
            settings=settings,
            visible_for_annotators=visible_for_annotators,
        )

    @property
    def options(self) -> Optional[List[str]]:
        return self._model.settings.values

    @options.setter
    def options(self, value: list[str]) -> None:
        self._model.settings.values = value

    @classmethod
    def from_model(cls, model: MetadataFieldModel) -> "TermsMetadataProperty":
        instance = TermsMetadataProperty(name=model.name)
        instance._model = model

        return instance

__init__(name, options=None, title=None, visible_for_annotators=True, client=None)

Create a metadata field with terms settings.

Parameters:

Name Type Description Default
name str

The name of the metadata field

 required
options Optional[List[str]]

The list of options

 None
title Optional[str]

The title of the metadata field

 None
visible_for_annotators Optional[bool]

Whether the metadata field is visible for annotators

 True

Raises: MetadataError: If an error occurs while defining metadata settings

Source code in src/argilla_sdk/settings/_metadata.py 
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
def __init__(
    self,
    name: str,
    options: Optional[List[str]] = None,
    title: Optional[str] = None,
    visible_for_annotators: Optional[bool] = True,
    client: Optional[Argilla] = None,
) -> None:
    """Create a metadata field with terms settings.

    Parameters:
        name (str): The name of the metadata field
        options (Optional[List[str]]): The list of options
        title (Optional[str]): The title of the metadata field
        visible_for_annotators (Optional[bool]): Whether the metadata field is visible for annotators
    Raises:
        MetadataError: If an error occurs while defining metadata settings
    """
    super().__init__(client=client)

    try:
        settings = TermsMetadataPropertySettings(values=options, type=MetadataPropertyType.terms)
    except ValueError as e:
        raise MetadataError(f"Error defining metadata settings for {name}") from e

    self._model = MetadataFieldModel(
        name=name,
        type=MetadataPropertyType.terms,
        title=title,
        settings=settings,
        visible_for_annotators=visible_for_annotators,
    )