Fix docs building and rename AttributeInfo attribute (#1950)

This PR fixes the failing documentation builds and renames
AttributeInfo.annotation to AttributeInfo.field and bumps the version to
2.0.0

<!-- Contributing guide:
https://github.com/open-edge-platform/datumaro/blob/develop/contributing.md
-->

<!--
Please add a summary of changes. You may use Copilot to auto-generate
the PR description but please consider including any other relevant
facts which Copilot may be unaware of (such as design choices and
testing procedure).

Add references to the relevant issues and pull requests if any like so:

Resolves #111 and #222.
Depends on #1000 (for series of dependent commits).
-->

### Checklist
<!-- Put an 'x' in all the boxes that apply -->
- [ ] I have added tests to cover my changes or documented any manual
tests.
- [ ] I have updated the
[documentation](https://github.com/open-edge-platform/datumaro/tree/develop/docs)
accordingly

---------

Signed-off-by: Albert van Houten <[email protected]>

Author: AlbertvanHouten

.github/workflows/docs_latest.yml

@@ -33,7 +33,7 @@ jobs:
           sudo apt-get install pandoc graphviz
       - name: Build-Docs
         run: |
-          uv pip install -r docs/requirements.txt
+          uv pip install -r docs/requirements.txt --system
           cd docs
           make clean
           make html

.github/workflows/docs_stable.yml

@@ -32,7 +32,7 @@ jobs:
           sudo apt-get install pandoc graphviz
       - name: Build-Docs
         run: |
-          uv pip install -r docs/requirements.txt
+          uv pip install -r docs/requirements.txt --system
           cd docs
           make clean
           make html

src/datumaro/components/annotation.py

@@ -486,7 +486,7 @@ class ExtractedMask(Mask):
         and 1 for foreground.
 
         >>> import numpy as np
-        >>> from datumaro.components.annotation import ExtractedMask
+        >>> from datumaro.components.field import ExtractedMask
         >>>
         >>> index_mask = np.random.randint(low=0, high=2, size=(10, 10), dtype=np.uint8)
         >>> mask1 = ExtractedMask(index_mask=index_mask, index=0, label=0)  # 0 for background

src/datumaro/experimental/converter_registry.py

@@ -616,11 +616,11 @@ def _group_fields_by_semantic(schema: Schema) -> dict[Semantic, _SchemaState]:
     groups: dict[Semantic, dict[Type[Field], AttributeSpec[Field]]] = defaultdict(dict)
 
     for attr_name, attr_info in schema.attributes.items():
-        semantic = attr_info.annotation.semantic
+        semantic = attr_info.field.semantic
 
-        field_type = type(attr_info.annotation)
+        field_type = type(attr_info.field)
         attr_spec = AttributeSpec(
-            name=attr_name, field=attr_info.annotation, categories=attr_info.categories
+            name=attr_name, field=attr_info.field, categories=attr_info.categories
         )
         groups[semantic][field_type] = attr_spec
 
@@ -915,8 +915,8 @@ def find_conversion_path(
     # We do not want to include those attributes into the inferred_categories.
     inferred_categories: dict[str, Categories] = {}
     for attr_name, attr_info in to_schema.attributes.items():
-        semantic = attr_info.annotation.semantic
-        attr_spec = target_groups[semantic].field_to_attr_spec[type(attr_info.annotation)]
+        semantic = attr_info.field.semantic
+        attr_spec = target_groups[semantic].field_to_attr_spec[type(attr_info.field)]
         if attr_spec.categories is not None:
             inferred_categories[attr_name] = attr_spec.categories
 

src/datumaro/experimental/dataset.py

@@ -110,15 +110,15 @@ def infer_schema(cls) -> Schema:
                 final_type = annotation
             else:
                 final_type = type_origin if type_origin is not None else annotation
-            attributes[name] = AttributeInfo(type=final_type, annotation=field_annotation)
+            attributes[name] = AttributeInfo(type=final_type, field=field_annotation)
         return Schema(attributes=attributes)
 
     def evaluate_lazy_field(self, name: str) -> Any:
         row_df = self._transforms.apply([name])
 
         # Now extract the value from the converted dataframe
         attr_info = self._transforms.schema.attributes[name]
-        value = attr_info.annotation.from_polars(name, 0, row_df, attr_info.type)
+        value = attr_info.field.from_polars(name, 0, row_df, attr_info.type)
 
         return value
 
@@ -144,7 +144,7 @@ def __get__(self, instance, _):
 
         # Now extract the value from the converted dataframe
         attr_info = self._transforms.schema.attributes[self._attr_name]
-        value = attr_info.annotation.from_polars(self._attr_name, 0, row_df, attr_info.type)
+        value = attr_info.field.from_polars(self._attr_name, 0, row_df, attr_info.type)
 
         # Cache the value and set it as a real attribute
         setattr(instance, self._attr_name, value)
@@ -236,7 +236,7 @@ def _generate_polars_schema(self) -> pl.Schema:
         """Generate a Polars schema from the dataset's field definitions."""
         schema: dict[str, pl.DataType] = {}
         for key, attr_info in self._schema.attributes.items():
-            schema.update(attr_info.annotation.to_polars_schema(key))
+            schema.update(attr_info.field.to_polars_schema(key))
         return pl.Schema(schema)
 
     def append(self, sample: DType):
@@ -251,7 +251,7 @@ def append(self, sample: DType):
 
         series_data: dict[str, pl.Series] = {}
         for key, attr_info in self._schema.attributes.items():
-            series_data.update(attr_info.annotation.to_polars(key, getattr(sample, key)))
+            series_data.update(attr_info.field.to_polars(key, getattr(sample, key)))
 
         new_row = pl.DataFrame(series_data).cast(dict(self.df.schema))  # type: ignore
 
@@ -311,9 +311,7 @@ def __getitem__(self, row_idx: int) -> DType:
         for key, attr_info in self._schema.attributes.items():
             if key not in lazy_attributes:
                 # This attribute is directly available
-                direct_attributes[key] = attr_info.annotation.from_polars(
-                    key, 0, row_df, attr_info.type
-                )
+                direct_attributes[key] = attr_info.field.from_polars(key, 0, row_df, attr_info.type)
 
         # If there are lazy converters, create a dynamic class with descriptors
         dtype = self._dtype
@@ -390,7 +388,7 @@ def __setitem__(self, row_idx: int, sample: DType):
 
         series_data: dict[str, pl.Series] = {}
         for key, attr_info in self._schema.attributes.items():
-            series_data.update(attr_info.annotation.to_polars(key, getattr(sample, key)))
+            series_data.update(attr_info.field.to_polars(key, getattr(sample, key)))
 
         updated_row = pl.DataFrame(series_data).cast(dict(self.df.schema))  # type: ignore
 
@@ -482,7 +480,7 @@ def filter_by_subset(self, subset: Subset) -> Dataset[DType]:
             A new Dataset with items of the given subset.
         """
         for subset_column_name, attribute_info in self.schema.attributes.items():
-            if isinstance(attribute_info.annotation, SubsetField):
+            if isinstance(attribute_info.field, SubsetField):
                 break
         else:
             raise RuntimeError(

src/datumaro/experimental/export_import.py

@@ -71,16 +71,16 @@ def _export_images_from_dataset(
     image_fields = []
     for name, attr_info in dataset.schema.attributes.items():
         if isinstance(
-            attr_info.annotation,
+            attr_info.field,
             (ImageCallableField, ImagePathField, InstanceMaskCallableField, MaskCallableField),
         ):
-            image_fields.append((name, attr_info.annotation))
+            image_fields.append((name, attr_info.field))
 
     if not image_fields:
         return image_paths
 
     # Export images for each field
-    for field_name, field_annotation in image_fields:
+    for field_name, field in image_fields:
         image_paths[field_name] = {}
 
         for idx in range(len(dataset)):
@@ -98,7 +98,7 @@ def _export_images_from_dataset(
                 continue
 
             # Handle different field types
-            if isinstance(field_annotation, ImagePathField):
+            if isinstance(field, ImagePathField):
                 # For ImagePathField: Copy image directly from filesystem
                 try:
                     source_path = Path(value)
@@ -118,7 +118,7 @@ def _export_images_from_dataset(
                     print(f"Warning: Failed to copy image from {value}: {e}")
                     continue
 
-            elif isinstance(field_annotation, ImageCallableField):
+            elif isinstance(field, ImageCallableField):
                 # Call the callable to get the image data
                 if not callable(value):
                     continue
@@ -163,7 +163,7 @@ def _export_images_from_dataset(
                         )
                         continue
 
-            elif isinstance(field_annotation, (InstanceMaskCallableField, MaskCallableField)):
+            elif isinstance(field, (InstanceMaskCallableField, MaskCallableField)):
                 # Call the callable to get the mask data
                 if not callable(value):
                     continue
@@ -371,13 +371,13 @@ def _import_dataset_from_dir(
     if images_base_dir.exists():
         # Identify image-related fields from schema
         for field_name, attr_info in schema.attributes.items():
-            annotation = getattr(attr_info, "annotation", None)
-            if annotation is None:
+            field = getattr(attr_info, "field", None)
+            if field is None:
                 continue
 
-            is_path_field = isinstance(annotation, ImagePathField)
+            is_path_field = isinstance(field, ImagePathField)
             is_callable_field = isinstance(
-                annotation, (ImageCallableField, InstanceMaskCallableField, MaskCallableField)
+                field, (ImageCallableField, InstanceMaskCallableField, MaskCallableField)
             )
 
             if not (is_path_field or is_callable_field):

src/datumaro/experimental/filtering/filter_registry.py

@@ -146,9 +146,9 @@ def create_filtering_plan(schema: Schema) -> FilteringPlan:
     attributes: List[str] = []
 
     for field_name, field_info in schema.attributes.items():
-        filter_cls = FilterRegistry.get_filter(type(field_info.annotation))
+        filter_cls = FilterRegistry.get_filter(type(field_info.field))
         if filter_cls is not None:
-            filter_instance = filter_cls(AttributeSpec(field_name, field_info.annotation))
+            filter_instance = filter_cls(AttributeSpec(field_name, field_info.field))
             filters.append(FilterEntry(field_name, filter_instance))
             attributes.append(field_name)