datamint 1.9.3__py3-none-any.whl → 2.0.1__py3-none-any.whl

datamint/dataset/base_dataset.py

@@ -13,14 +13,16 @@ from datamint import configs
 from torch.utils.data import DataLoader
 import torch
 from torch import Tensor
-from datamint.apihandler.base_api_handler import DatamintException
+from datamint.exceptions import DatamintException
 from medimgkit.dicom_utils import is_dicom
 from medimgkit.readers import read_array_normalized
-from medimgkit.format_detection import guess_extension
+from medimgkit.format_detection import guess_extension, guess_typez
+from medimgkit.nifti_utils import NIFTI_MIMES, get_nifti_shape
 from datetime import datetime
 from pathlib import Path
-from datamint.dataset.annotation import Annotation
+from datamint.entities import Annotation, DatasetInfo
 import cv2
+from datamint.entities import Resource
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -174,23 +176,12 @@ class DatamintBaseDataset:
 
     def _setup_api_handler(self, server_url: Optional[str], api_key: Optional[str], auto_update: bool) -> None:
         """Setup API handler and validate connection."""
-        from datamint.apihandler.api_handler import APIHandler
-
-        self.api_handler = APIHandler(
-            root_url=server_url,
+        from datamint import Api
+        self.api = Api(
+            server_url=server_url,
             api_key=api_key,
-            check_connection=auto_update
+            check_connection=self.auto_update
         )
-        self.server_url = self.api_handler.root_url
-        self.api_key = self.api_handler.api_key
-
-        if self.api_key is None:
-            _LOGGER.warning(
-                "API key not provided. If you want to download data, please provide an API key, "
-                f"either by passing it as an argument, "
-                f"setting environment variable {configs.ENV_VARS[configs.APIKEY_KEY]} or "
-                "using datamint-config command line tool."
-            )
 
     def _setup_directories(self, root: str | None) -> None:
         """Setup root and dataset directories."""
@@ -234,26 +225,34 @@ class DatamintBaseDataset:
         else:
             self._check_version()
 
+    def _init_metainfo(self) -> None:
+        # get the server info
+        self.project_info = self.get_info()
+        self.metainfo = self._get_datasetinfo().asdict().copy()
+        self.metainfo['updated_at'] = None
+        self.metainfo['resources'] = []
+        self.metainfo['all_annotations'] = self.all_annotations
+        self.images_metainfo = self.metainfo['resources']
+
     def _load_metadata(self) -> bool:
         """Load and process dataset metadata."""
         if hasattr(self, 'metainfo'):
             _LOGGER.warning("Metadata already loaded.")
         metadata_path = os.path.join(self.dataset_dir, 'dataset.json')
         if not os.path.isfile(metadata_path):
-            # get the server info
-            self.project_info = self.get_info()
-            self.metainfo = self._get_datasetinfo().copy()
-            self.metainfo['updated_at'] = None
-            self.metainfo['resources'] = []
-            self.metainfo['all_annotations'] = self.all_annotations
-            self.images_metainfo = self.metainfo['resources']
+            self._init_metainfo()
             return False
         else:
             with open(metadata_path, 'r') as file:
                 self.metainfo = json.load(file)
         self.images_metainfo = self.metainfo['resources']
         # Convert annotations from dict to Annotation objects
-        self._convert_metainfo_to_clsobj()
+        try:
+            self._convert_metainfo_to_clsobj()
+        except Exception as e:
+            _LOGGER.warning(f"Failed to convert annotations. Redownloading dataset. {type(e)}")
+            self._init_metainfo()
+            return False
         return True
 
     def _convert_metainfo_to_clsobj(self):
@@ -412,19 +411,33 @@ class DatamintBaseDataset:
     @staticmethod
     def read_number_of_frames(filepath: str) -> int:
         """Read the number of frames in a file."""
-        if is_dicom(filepath):
+
+        mimetypes, ext = guess_typez(filepath)
+        mimetype = mimetypes[0]
+        if mimetype is None:
+            raise ValueError(f"Could not determine MIME type for file: {filepath}")
+
+        if mimetype == 'application/dicom':
             ds = pydicom.dcmread(filepath)
             return getattr(ds, 'NumberOfFrames', 1)
-        elif filepath.lower().endswith(('.mp4', '.avi')):
+        elif mimetype.startswith('video/'):
             cap = cv2.VideoCapture(filepath)
             try:
                 return int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
             finally:
                 cap.release()
-        elif filepath.lower().endswith(('.png', '.jpg', '.jpeg')):
+        elif mimetype in ('image/png', 'image/jpeg', 'image/jpg', 'image/bmp', 'image/tiff'):
             return 1
+        elif mimetype in NIFTI_MIMES:
+            shape = get_nifti_shape(filepath)
+            if len(shape) == 3:
+                return shape[-1]
+            elif len(shape) > 3:
+                return shape[3]
+            else:
+                return 1
         else:
-            raise ValueError(f"Unsupported file type: {filepath}")
+            raise ValueError(f"Unsupported file type '{mimetype}' for file {filepath}")
 
     def get_resources_ids(self) -> list[str]:
         """Get list of resource IDs."""
@@ -526,18 +539,18 @@ class DatamintBaseDataset:
         if missing_files:
             raise DatamintDatasetException(f"Image files not found: {missing_files}")
 
-    def _get_datasetinfo(self) -> dict:
+    def _get_datasetinfo(self) -> DatasetInfo:
         """Get dataset information from API."""
         if self._server_dataset_info is not None:
             return self._server_dataset_info
-        all_datasets = self.api_handler.get_datasets()
+        all_datasets = self.api._datasetsinfo.get_all()
 
         for dataset in all_datasets:
-            if dataset['id'] == self.dataset_id:
+            if dataset.id == self.dataset_id:
                 self._server_dataset_info = dataset
                 return dataset
 
-        available_datasets = [(d['name'], d['id']) for d in all_datasets]
+        available_datasets = [(d.name, d.id) for d in all_datasets]
         raise DatamintDatasetException(
             f"Dataset with id '{self.dataset_id}' not found. "
             f"Available datasets: {available_datasets}"
@@ -547,13 +560,12 @@ class DatamintBaseDataset:
         """Get project information from API."""
         if hasattr(self, 'project_info') and self.project_info is not None:
             return self.project_info
-        project = self.api_handler.get_project_by_name(self.project_name)
-        if 'error' in project:
-            available_projects = project['all_projects']
+        project = self.api.projects.get_by_name(self.project_name)
+        if project is None:
             raise DatamintDatasetException(
-                f"Project with name '{self.project_name}' not found. "
-                f"Available projects: {available_projects}"
+                f"Project with name '{self.project_name}' not found."
             )
+        project = project.asdict()
         self.project_info = project
         self.dataset_id = project['dataset_id']
         return project
@@ -592,31 +604,10 @@ class DatamintBaseDataset:
         lines = [head] + [" " * 4 + line for line in body]
         return "\n".join(lines)
 
-    def download_project(self) -> None:
-        """Download project data from API."""
-
-        dataset_info = self._get_datasetinfo()
-        self.dataset_id = dataset_info['id']
-        self.last_updaded_at = dataset_info['updated_at']
-
-        self.api_handler.download_project(
-            self.project_info['id'],
-            self.dataset_zippath,
-            all_annotations=self.all_annotations,
-            include_unannotated=self.include_unannotated
-        )
-
-        _LOGGER.debug("Downloaded dataset")
-
-        if os.path.getsize(self.dataset_zippath) == 0:
-            raise DatamintDatasetException("Download failed.")
-
-        self._extract_and_update_metadata()
-
     def _get_dataset_id(self) -> str:
         if self.dataset_id is None:
             dataset_info = self._get_datasetinfo()
-            self.dataset_id = dataset_info['id']
+            self.dataset_id = dataset_info.id
         return self.dataset_id
 
     def _extract_and_update_metadata(self) -> None:
@@ -638,7 +629,7 @@ class DatamintBaseDataset:
 
         # Save updated metadata
         with open(datasetjson_path, 'w') as file:
-            json.dump(self.metainfo, file, default=lambda o: o.to_dict() if hasattr(o, 'to_dict') else o)
+            json.dump(self.metainfo, file, default=lambda o: o.asdict() if hasattr(o, 'asdict') else o)
 
         self.images_metainfo = self.metainfo['resources']
         # self._convert_metainfo_to_clsobj()
@@ -646,19 +637,19 @@ class DatamintBaseDataset:
     def _update_metadata_timestamps(self) -> None:
         """Update metadata with correct timestamps."""
         if 'updated_at' not in self.metainfo:
-            self.metainfo['updated_at'] = self.last_updaded_at
+            self.metainfo['updated_at'] = self.last_updated_at
         else:
             try:
                 local_time = datetime.fromisoformat(self.metainfo['updated_at'])
-                server_time = datetime.fromisoformat(self.last_updaded_at)
+                server_time = datetime.fromisoformat(self.last_updated_at)
 
                 if local_time < server_time:
                     _LOGGER.warning(
                         f"Inconsistent updated_at dates detected "
-                        f"({self.metainfo['updated_at']} < {self.last_updaded_at}). "
-                        f"Fixing it to {self.last_updaded_at}"
+                        f"({self.metainfo['updated_at']} < {self.last_updated_at}). "
+                        f"Fixing it to {self.last_updated_at}"
                     )
-                    self.metainfo['updated_at'] = self.last_updaded_at
+                    self.metainfo['updated_at'] = self.last_updated_at
             except Exception as e:
                 _LOGGER.warning(f"Failed to parse updated_at date: {e}")
 
@@ -690,6 +681,9 @@ class DatamintBaseDataset:
             img = (img - min_val) / (img.max() - min_val) * 255
             img = img.astype(np.uint8)
 
+        if not img.flags.writeable:
+            img = img.copy()
+
         img_tensor = torch.from_numpy(img).contiguous()
 
         if isinstance(img_tensor, torch.ByteTensor):
@@ -829,7 +823,7 @@ class DatamintBaseDataset:
 
         try:
             external_metadata_info = self._get_datasetinfo()
-            server_updated_at = external_metadata_info['updated_at']
+            server_updated_at = external_metadata_info.updated_at
         except Exception as e:
             _LOGGER.warning(f"Failed to check for updates in {self.project_name}: {e}")
             return
@@ -856,20 +850,21 @@ class DatamintBaseDataset:
             _LOGGER.info('Local version is up to date with the latest version.')
 
     def _fetch_new_resources(self,
-                             all_uptodate_resources: list[dict]) -> list[dict]:
+                             all_uptodate_resources: list[Resource]) -> list[dict]:
         local_resources = self.images_metainfo
         local_resources_ids = [res['id'] for res in local_resources]
         new_resources = []
         for resource in all_uptodate_resources:
+            resource = resource.asdict()
             if resource['id'] not in local_resources_ids:
                 resource['file'] = str(self._get_resource_file_path(resource))
                 resource['annotations'] = []
                 new_resources.append(resource)
         return new_resources
 
-    def _fetch_deleted_resources(self, all_uptodate_resources: list[dict]) -> list[dict]:
+    def _fetch_deleted_resources(self, all_uptodate_resources: list[Resource]) -> list[dict]:
         local_resources = self.images_metainfo
-        all_uptodate_resources_ids = [res['id'] for res in all_uptodate_resources]
+        all_uptodate_resources_ids = [res.id for res in all_uptodate_resources]
         deleted_resources = []
         for resource in local_resources:
             try:
@@ -888,7 +883,7 @@ class DatamintBaseDataset:
         # server_updated_at = external_metadata_info['updated_at']
 
         ### RESOURCES ###
-        all_uptodate_resources = self.api_handler.get_project_resources(self.get_info()['id'])
+        all_uptodate_resources = self.api.projects.get_project_resources(self.get_info()['id'])
         new_resources = self._fetch_new_resources(all_uptodate_resources)
         deleted_resources = self._fetch_deleted_resources(all_uptodate_resources)
 
@@ -898,9 +893,9 @@ class DatamintBaseDataset:
             new_resources_path = [Path(self.dataset_dir) / r['file'] for r in new_resources]
             new_resources_ids = [r['id'] for r in new_resources]
             _LOGGER.info(f"Downloading {len(new_resources)} new resources...")
-            new_res_paths = self.api_handler.download_multiple_resources(new_resources_ids,
-                                                                         save_path=new_resources_path,
-                                                                         add_extension=True)
+            new_res_paths = self.api.resources.download_multiple_resources(new_resources_ids,
+                                                                           save_path=new_resources_path,
+                                                                           add_extension=True)
             for new_rpath, r in zip(new_res_paths, new_resources):
                 r['file'] = str(Path(new_rpath).relative_to(self.dataset_dir))
             _LOGGER.info(f"Downloaded {len(new_resources)} new resources.")
@@ -910,16 +905,17 @@ class DatamintBaseDataset:
         ################
 
         ### ANNOTATIONS ###
-        all_annotations = self.api_handler.get_annotations(worklist_id=self.project_info['worklist_id'],
-                                                           status='published' if self.all_annotations else None)
+        all_annotations = self.api.annotations.get_list(worklist_id=None if self.all_annotations else self.project_info['worklist_id'],
+                                                        status=None if self.all_annotations else 'published')
+
         # group annotations by resource ID
-        annotations_by_resource = {}
+        annotations_by_resource: dict[str, list[Annotation]] = {}
         for ann in all_annotations:
             # add the local filepath
             filepath = self._get_annotation_file_path(ann)
             if filepath is not None:
-                ann['file'] = str(filepath)
-            resource_id = ann['resource_id']
+                ann.file = str(filepath)
+            resource_id = ann.resource_id
             if resource_id not in annotations_by_resource:
                 annotations_by_resource[resource_id] = []
             annotations_by_resource[resource_id].append(ann)
@@ -937,11 +933,11 @@ class DatamintBaseDataset:
             # check if segmentation annotations need to be downloaded
             # Also check if annotations need to be deleted
             old_ann_ids = set([ann.id for ann in old_resource_annotations if hasattr(ann, 'id')])
-            new_ann_ids = set([ann['id'] for ann in new_resource_annotations])
+            new_ann_ids = set([ann.id for ann in new_resource_annotations])
 
             # Find annotations to add, update, or remove
             annotations_to_add = [ann for ann in new_resource_annotations
-                                  if ann['id'] not in old_ann_ids]
+                                  if ann.id not in old_ann_ids]
             annotations_to_remove = [ann for ann in old_resource_annotations
                                      if getattr(ann, 'id', 'NA') not in new_ann_ids]
 
@@ -970,22 +966,23 @@ class DatamintBaseDataset:
                     _LOGGER.error(f"Error deleting annotation file {filepath}: {e}")
 
             # Update resource annotations list - convert to Annotation objects
-            resource['annotations'] = [Annotation.from_dict(ann) for ann in new_resource_annotations]
+            # resource['annotations'] = [Annotation.from_dict(ann) for ann in new_resource_annotations]
+            resource['annotations'] = new_resource_annotations
 
         # Batch download all segmentation files
         if segmentations_to_download:
             _LOGGER.info(f"Downloading {len(segmentations_to_download)} segmentation files...")
-            self.api_handler.download_multiple_segmentations(segmentations_to_download, segmentation_paths)
+            self.api.annotations.download_multiple_files(segmentations_to_download, segmentation_paths)
             _LOGGER.info(f"Downloaded {len(segmentations_to_download)} segmentation files.")
 
         ###################
         # update metadata
-        self.metainfo['updated_at'] = self._get_datasetinfo()['updated_at']
+        self.metainfo['updated_at'] = self._get_datasetinfo().updated_at
         self.metainfo['all_annotations'] = self.all_annotations
         # save updated metadata
         datasetjson_path = os.path.join(self.dataset_dir, 'dataset.json')
         with open(datasetjson_path, 'w') as file:
-            json.dump(self.metainfo, file, default=lambda o: o.to_dict() if hasattr(o, 'to_dict') else o)
+            json.dump(self.metainfo, file, default=lambda o: o.asdict() if hasattr(o, 'asdict') else o)
 
     def _get_resource_file_path(self, resource: dict) -> Path:
         """Get the local file path for a resource."""

datamint/dataset/dataset.py

@@ -7,7 +7,7 @@ import numpy as np
 import logging
 from PIL import Image
 import albumentations
-from datamint.dataset.annotation import Annotation
+from datamint.entities.annotation import Annotation
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -155,7 +155,7 @@ class DatamintDataset(DatamintBaseDataset):
             # FIXME: avoid enforcing resizing the mask
             seg = (Image.open(segfilepath)
                    .convert('L')
-                   .resize((w, h), Image.NEAREST)
+                   .resize((w, h), Image.Resampling.NEAREST)
                    )
             seg = np.array(seg)
 

datamint/entities/__init__.py

@@ -0,0 +1,20 @@
+"""DataMint entities package."""
+
+from .annotation import Annotation
+from .base_entity import BaseEntity
+from .channel import Channel, ChannelResourceData
+from .project import Project
+from .resource import Resource
+from .user import User  # new export
+from .datasetinfo import DatasetInfo
+
+__all__ = [
+    'Annotation',
+    'BaseEntity',
+    'Channel',
+    'ChannelResourceData',
+    'Project',
+    'Resource',
+    "User",
+    'DatasetInfo',
+]

datamint/entities/annotation.py

@@ -0,0 +1,178 @@
+# filepath: datamint/entities/annotation.py
+"""Annotation entity module for DataMint API.
+
+This module defines the Annotation model used to represent annotation
+records returned by the DataMint API.
+"""
+
+from typing import Any
+import logging
+from .base_entity import BaseEntity, MISSING_FIELD
+from pydantic import Field
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+# Map API field names to class attributes
+_FIELD_MAPPING = {
+    'type': 'annotation_type',
+    'name': 'identifier',
+    'added_by': 'created_by',
+    'index': 'frame_index',
+}
+
+
+class Annotation(BaseEntity):
+    """Pydantic Model representing a DataMint annotation.
+
+    Attributes:
+        id: Unique identifier for the annotation.
+        identifier: User-friendly identifier or label for the annotation.
+        scope: Scope of the annotation (e.g., "frame", "image").
+        frame_index: Index of the frame if scope is frame-based.
+        annotation_type: Type of annotation (e.g., "segmentation", "bbox", "label").
+        text_value: Optional text value associated with the annotation.
+        numeric_value: Optional numeric value associated with the annotation.
+        units: Optional units for numeric_value.
+        geometry: Optional geometry payload (e.g., polygons, masks) as a list.
+        created_at: ISO timestamp for when the annotation was created.
+        created_by: Email or identifier of the creating user.
+        annotation_worklist_id: Optional worklist ID associated with the annotation.
+        status: Lifecycle status of the annotation (e.g., "new", "approved").
+        approved_at: Optional ISO timestamp for approval time.
+        approved_by: Optional identifier of the approver.
+        resource_id: ID of the resource this annotation belongs to.
+        associated_file: Path or identifier of any associated file artifact.
+        deleted: Whether the annotation is marked as deleted.
+        deleted_at: Optional ISO timestamp for deletion time.
+        deleted_by: Optional identifier of the user who deleted the annotation.
+        created_by_model: Optional identifier of the model that created this annotation.
+        old_geometry: Optional previous geometry payload for change tracking.
+        set_name: Optional set name this annotation belongs to.
+        resource_filename: Optional filename of the resource.
+        resource_modality: Optional modality of the resource (e.g., CT, MR).
+        annotation_worklist_name: Optional worklist name associated with the annotation.
+        user_info: Optional user information with keys like firstname and lastname.
+        values: Optional extra values payload for flexible schemas.
+    """
+
+    id: str
+    identifier: str
+    scope: str
+    frame_index: int | None
+    annotation_type: str
+    text_value: str | None
+    numeric_value: float | int | None
+    units: str | None
+    geometry: list | dict | None
+    created_at: str  # ISO timestamp string
+    created_by: str
+    annotation_worklist_id: str | None
+    status: str
+    approved_at: str | None  # ISO timestamp string
+    approved_by: str | None
+    resource_id: str
+    associated_file: str | None
+    deleted: bool
+    deleted_at: str | None  # ISO timestamp string
+    deleted_by: str | None
+    created_by_model: str | None
+    set_name: str | None
+    resource_filename: str | None
+    resource_modality: str | None
+    annotation_worklist_name: str | None
+    user_info: dict | None
+    values: list | None = MISSING_FIELD
+    file: str | None = None  # Add file field for segmentations
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'Annotation':
+        """Create an Annotation instance from a dictionary.
+
+        Args:
+            data: Dictionary containing annotation data from API
+
+        Returns:
+            Annotation instance
+        """
+        # Convert field names and filter valid fields
+        converted_data = {}
+        for key, value in data.items():
+            # Map field names if needed
+            mapped_key = _FIELD_MAPPING.get(key, key)
+            converted_data[mapped_key] = value
+
+        if 'scope' not in converted_data:
+            converted_data['scope'] = 'image' if converted_data.get('frame_index') is None else 'frame'
+
+        if converted_data['annotation_type'] in ['segmentation']:
+            if converted_data.get('file') is None:
+                raise ValueError(f"Segmentation annotations must have an associated file. {data}")
+
+        # Create instance with only valid fields
+        valid_fields = {f for f in cls.model_fields.keys()}
+        filtered_data = {k: v for k, v in converted_data.items() if k in valid_fields}
+
+        return cls(**filtered_data)
+
+    @property
+    def type(self) -> str:
+        """Alias for :attr:`annotation_type`."""
+        return self.annotation_type
+
+    @property
+    def name(self) -> str:
+        """Get the annotation name (alias for identifier)."""
+        return self.identifier
+
+    @property
+    def index(self) -> int | None:
+        """Get the frame index (alias for frame_index)."""
+        return self.frame_index
+
+    @property
+    def value(self) -> str | None:
+        """Get the annotation value (for category annotations)."""
+        return self.text_value
+
+    @property
+    def added_by(self) -> str:
+        """Get the creator email (alias for created_by)."""
+        return self.created_by
+
+    def is_segmentation(self) -> bool:
+        """Check if this is a segmentation annotation."""
+        return self.annotation_type == 'segmentation'
+
+    def is_label(self) -> bool:
+        """Check if this is a label annotation."""
+        return self.annotation_type == 'label'
+
+    def is_category(self) -> bool:
+        """Check if this is a category annotation."""
+        return self.annotation_type == 'category'
+
+    def is_frame_scoped(self) -> bool:
+        """Check if this annotation is frame-scoped."""
+        return self.scope == 'frame'
+
+    def is_image_scoped(self) -> bool:
+        """Check if this annotation is image-scoped."""
+        return self.scope == 'image'
+
+    def get_created_datetime(self) -> datetime | None:
+        """
+        Get the creation datetime as a datetime object.
+
+        Returns:
+            datetime object or None if created_at is not set
+        """
+        if isinstance(self.created_at, datetime):
+            return self.created_at
+
+        if self.created_at:
+            try:
+                return datetime.fromisoformat(self.created_at.replace('Z', '+00:00'))
+            except ValueError:
+                logger.warning(f"Could not parse created_at datetime: {self.created_at}")
+        return None

datamint/entities/base_entity.py

@@ -0,0 +1,51 @@
+import logging
+import sys
+from typing import Any
+from pydantic import ConfigDict, BaseModel
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+_LOGGER = logging.getLogger(__name__)
+
+MISSING_FIELD = 'MISSING_FIELD'  # Used when a field is sometimes missing for one endpoint but not on another endpoint
+
+# Track logged warnings to avoid duplicates
+_LOGGED_WARNINGS: set[tuple[str, str]] = set()
+
+
+class BaseEntity(BaseModel):
+    """
+    Base class for all entities in the Datamint system.
+
+    This class provides common functionality for all entities, such as
+    serialization and deserialization from dictionaries, as well as
+    handling unknown fields gracefully.
+    """
+
+    model_config = ConfigDict(extra='allow')  # Allow extra fields not defined in the model
+
+    def asdict(self) -> dict[str, Any]:
+        """Convert the entity to a dictionary, including unknown fields."""
+        return self.model_dump(warnings='none')
+
+    def asjson(self) -> str:
+        """Convert the entity to a JSON string, including unknown fields."""
+        return self.model_dump_json(warnings='none')
+
+    def model_post_init(self, __context: Any) -> None:
+        """Handle unknown fields by logging a warning once per class/field combination in debug mode."""
+        if self.__pydantic_extra__ and _LOGGER.isEnabledFor(logging.DEBUG):
+            class_name = self.__class__.__name__
+            
+            have_to_log = False
+            for key in self.__pydantic_extra__.keys():
+                warning_key = (class_name, key)
+                
+                if warning_key not in _LOGGED_WARNINGS:
+                    _LOGGED_WARNINGS.add(warning_key)
+                    have_to_log = True
+            
+            if have_to_log:
+                _LOGGER.warning(f"Unknown fields {list(self.__pydantic_extra__.keys())} found in {class_name}")