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 and pass them to the Settings.

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.

metadata_field = rg.TermsMetadataProperty(
    name="color",
    options=["red", "blue", "green"],
    title="Color",
)

float_metadata_field = rg.FloatMetadataProperty(
    name="price",
    min=0.0,
    max=100.0,
    title="Price",
)

int_metadata_field = rg.IntegerMetadataProperty(
    name="quantity",
    min=0,
    max=100,
    title="Quantity",
)

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

dataset = rg.Dataset(
    name="my_dataset",
    settings=settings,
)

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

FloatMetadataProperty

Bases: MetadataPropertyBase

Source code in src/argilla/settings/_metadata.py 
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
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
class FloatMetadataProperty(MetadataPropertyBase):
    def __init__(
        self,
        name: str,
        min: Optional[float] = None,
        max: Optional[float] = None,
        title: Optional[str] = None,
        visible_for_annotators: Optional[bool] = True,
        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 valid value. If none is provided, it will be computed from the values provided in the records.
            max (Optional[float]): The maximum valid value. If none is provided, it will be computed from the values provided in the records.
            title (Optional[str]): The title of the metadata to be shown in the UI
            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 = 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,
            visible_for_annotators=visible_for_annotators,
        )

    @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, visible_for_annotators=True, 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 valid value. If none is provided, it will be computed from the values provided in the records.

 None
max Optional[float]

The maximum valid value. If none is provided, it will be computed from the values provided in the records.

 None
title Optional[str]

The title of the metadata to be shown in the UI

 None
visible_for_annotators Optional[bool]

Whether the metadata field is visible for annotators.

 True

Raises:

Type Description
MetadataError

If an error occurs while defining metadata settings.
Source code in src/argilla/settings/_metadata.py 
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
def __init__(
    self,
    name: str,
    min: Optional[float] = None,
    max: Optional[float] = None,
    title: Optional[str] = None,
    visible_for_annotators: Optional[bool] = True,
    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 valid value. If none is provided, it will be computed from the values provided in the records.
        max (Optional[float]): The maximum valid value. If none is provided, it will be computed from the values provided in the records.
        title (Optional[str]): The title of the metadata to be shown in the UI
        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 = 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,
        visible_for_annotators=visible_for_annotators,
    )

IntegerMetadataProperty

Bases: MetadataPropertyBase

Source code in src/argilla/settings/_metadata.py 
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
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
class IntegerMetadataProperty(MetadataPropertyBase):
    def __init__(
        self,
        name: str,
        min: Optional[int] = None,
        max: Optional[int] = None,
        title: Optional[str] = None,
        visible_for_annotators: Optional[bool] = True,
        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 valid value. If none is provided, it will be computed from the values provided in the records.
            max (Optional[int]): The maximum  valid value. If none is provided, it will be computed from the values provided in the records.
            title (Optional[str]): The title of the metadata to be shown in the UI
            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 = 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,
            visible_for_annotators=visible_for_annotators,
        )

    @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, visible_for_annotators=True, 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 valid value. If none is provided, it will be computed from the values provided in the records.

 None
max Optional[int]

The maximum valid value. If none is provided, it will be computed from the values provided in the records.

 None
title Optional[str]

The title of the metadata to be shown in the UI

 None
visible_for_annotators Optional[bool]

Whether the metadata field is visible for annotators.

 True

Raises:

Type Description
MetadataError

If an error occurs while defining metadata settings.
Source code in src/argilla/settings/_metadata.py 
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
def __init__(
    self,
    name: str,
    min: Optional[int] = None,
    max: Optional[int] = None,
    title: Optional[str] = None,
    visible_for_annotators: Optional[bool] = True,
    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 valid value. If none is provided, it will be computed from the values provided in the records.
        max (Optional[int]): The maximum  valid value. If none is provided, it will be computed from the values provided in the records.
        title (Optional[str]): The title of the metadata to be shown in the UI
        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 = 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,
        visible_for_annotators=visible_for_annotators,
    )

TermsMetadataProperty

Bases: MetadataPropertyBase

Source code in src/argilla/settings/_metadata.py 
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
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 to be shown in the UI
            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 to be shown in the UI

 None
visible_for_annotators Optional[bool]

Whether the metadata field is visible for annotators.

 True

Raises:

Type Description
MetadataError

If an error occurs while defining metadata settings
Source code in src/argilla/settings/_metadata.py 
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
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 to be shown in the UI
        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,
    )