labelbox 3.78.2__tar.gz → 4.0.0__tar.gz

{labelbox-3.78.2 → labelbox-4.0.0}/CHANGELOG.md

@@ -1,8 +1,10 @@
 # Changelog
-# Version 3.78.2 (2025-01-15)
+# Version 4.0.0 (2024-09-10)
+## Added
+* BREAKING CHANGE for pydantic V1 users: Converted SDK to use pydantic V2([#1738](https://github.com/Labelbox/labelbox-python/pull/1738))
+* Automation test support for multiple sdk versions([#1792](https://github.com/Labelbox/labelbox-python/pull/1792))
 ## Fixed
-* Exporter encoding
-  * NOTE: backported from v.5.2.1
+* Flaky tests([#1793](https://github.com/Labelbox/labelbox-python/pull/1793))
 
 # Version 3.78.1 (2024-09-10)
 ## Fixed

{labelbox-3.78.2 → labelbox-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: labelbox
-Version: 3.78.2
+Version: 4.0.0
 Summary: Labelbox Python API
 Project-URL: Homepage, https://labelbox.com/
 Project-URL: Documentation, https://labelbox-python.readthedocs.io/en/latest/
@@ -26,7 +26,7 @@ Requires-Python: >=3.8
 Requires-Dist: geojson>=3.1.0
 Requires-Dist: google-api-core>=1.22.1
 Requires-Dist: mypy==1.10.1
-Requires-Dist: pydantic>=1.8
+Requires-Dist: pydantic>=2.0
 Requires-Dist: python-dateutil<2.10.0,>=2.8.2
 Requires-Dist: requests>=2.22.0
 Requires-Dist: strenum>=0.4.15

{labelbox-3.78.2 → labelbox-4.0.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "labelbox"
-version = "3.78.2"
+version = "4.0.0"
 description = "Labelbox Python API"
 authors = [{ name = "Labelbox", email = "engineering@labelbox.com" }]
 dependencies = [
     "google-api-core>=1.22.1",
-    "pydantic>=1.8",
+    "pydantic>=2.0",
     "python-dateutil>=2.8.2, <2.10.0",
     "requests>=2.22.0",
     "strenum>=0.4.15",

{labelbox-3.78.2 → labelbox-4.0.0}/src/labelbox/__init__.py

@@ -1,73 +1,48 @@
 name = "labelbox"
 
-__version__ = "3.78.2"
+__version__ = "4.0.0"
 
 from labelbox.client import Client
-from labelbox.schema.annotation_import import (
-    LabelImport,
-    MALPredictionImport,
-    MEAPredictionImport,
-    MEAToMALPredictionImport,
-)
-from labelbox.schema.asset_attachment import AssetAttachment
-from labelbox.schema.batch import Batch
-from labelbox.schema.benchmark import Benchmark
+from labelbox.schema.project import Project
+from labelbox.schema.model import Model
+from labelbox.schema.model_config import ModelConfig
 from labelbox.schema.bulk_import_request import BulkImportRequest
-from labelbox.schema.catalog import Catalog
-from labelbox.schema.data_row import DataRow
-from labelbox.schema.data_row_metadata import (
-    DataRowMetadata,
-    DataRowMetadataField,
-    DataRowMetadataOntology,
-    DeleteDataRowMetadata,
-)
+from labelbox.schema.annotation_import import MALPredictionImport, MEAPredictionImport, LabelImport, MEAToMALPredictionImport
 from labelbox.schema.dataset import Dataset
+from labelbox.schema.data_row import DataRow
+from labelbox.schema.catalog import Catalog
 from labelbox.schema.enums import AnnotationImportState
-from labelbox.schema.export_task import (
-    BufferedJsonConverterOutput,
-    ExportTask,
-    FileConverter,
-    FileConverterOutput,
-    JsonConverter,
-    JsonConverterOutput,
-    StreamType,
-)
-from labelbox.schema.iam_integration import IAMIntegration
-from labelbox.schema.identifiable import GlobalKey, UniqueId
-from labelbox.schema.identifiables import DataRowIds, GlobalKeys, UniqueIds
-from labelbox.schema.invite import Invite, InviteLimit
 from labelbox.schema.label import Label
-from labelbox.schema.label_score import LabelScore
-from labelbox.schema.labeling_frontend import LabelingFrontend, LabelingFrontendOptions
-from labelbox.schema.labeling_service import LabelingService
-from labelbox.schema.labeling_service_dashboard import LabelingServiceDashboard
-from labelbox.schema.labeling_service_status import LabelingServiceStatus
-from labelbox.schema.media_type import MediaType
-from labelbox.schema.model import Model
-from labelbox.schema.model_config import ModelConfig
-from labelbox.schema.model_run import DataSplit, ModelRun
-from labelbox.schema.ontology import (
-    Classification,
-    FeatureSchema,
-    Ontology,
-    OntologyBuilder,
-    Option,
-    PromptResponseClassification,
-    ResponseOption,
-    Tool,
-)
-from labelbox.schema.ontology_kind import OntologyKind
+from labelbox.schema.batch import Batch
+from labelbox.schema.review import Review
+from labelbox.schema.user import User
 from labelbox.schema.organization import Organization
-from labelbox.schema.project import Project
+from labelbox.schema.task import Task
+from labelbox.schema.export_task import StreamType, ExportTask, JsonConverter, JsonConverterOutput, FileConverter, FileConverterOutput, BufferedJsonConverterOutput
+from labelbox.schema.labeling_frontend import LabelingFrontend, LabelingFrontendOptions
+from labelbox.schema.asset_attachment import AssetAttachment
+from labelbox.schema.webhook import Webhook
+from labelbox.schema.ontology import Ontology, OntologyBuilder, Classification, Option, Tool, FeatureSchema
+from labelbox.schema.ontology import PromptResponseClassification
+from labelbox.schema.ontology import ResponseOption
+from labelbox.schema.role import Role, ProjectRole
+from labelbox.schema.invite import Invite, InviteLimit
+from labelbox.schema.data_row_metadata import DataRowMetadataOntology, DataRowMetadataField, DataRowMetadata, DeleteDataRowMetadata
+from labelbox.schema.model_run import ModelRun, DataSplit
+from labelbox.schema.benchmark import Benchmark
+from labelbox.schema.iam_integration import IAMIntegration
+from labelbox.schema.resource_tag import ResourceTag
 from labelbox.schema.project_model_config import ProjectModelConfig
-from labelbox.schema.project_overview import ProjectOverview, ProjectOverviewDetailed
 from labelbox.schema.project_resource_tag import ProjectResourceTag
+from labelbox.schema.media_type import MediaType
+from labelbox.schema.slice import Slice, CatalogSlice, ModelSlice
 from labelbox.schema.queue_mode import QueueMode
-from labelbox.schema.resource_tag import ResourceTag
-from labelbox.schema.review import Review
-from labelbox.schema.role import ProjectRole, Role
-from labelbox.schema.slice import CatalogSlice, ModelSlice, Slice
-from labelbox.schema.task import Task
 from labelbox.schema.task_queue import TaskQueue
-from labelbox.schema.user import User
-from labelbox.schema.webhook import Webhook
+from labelbox.schema.label_score import LabelScore
+from labelbox.schema.identifiables import UniqueIds, GlobalKeys, DataRowIds
+from labelbox.schema.identifiable import UniqueId, GlobalKey
+from labelbox.schema.ontology_kind import OntologyKind
+from labelbox.schema.project_overview import ProjectOverview, ProjectOverviewDetailed
+from labelbox.schema.labeling_service import LabelingService
+from labelbox.schema.labeling_service_dashboard import LabelingServiceDashboard
+from labelbox.schema.labeling_service_status import LabelingServiceStatus

{labelbox-3.78.2 → labelbox-4.0.0}/src/labelbox/data/annotation_types/__init__.py

@@ -29,7 +29,6 @@ from .ner import TextEntity
 
 from .classification import Checklist
 from .classification import ClassificationAnswer
-from .classification import Dropdown
 from .classification import Radio
 from .classification import Text
 

{labelbox-3.78.2 → labelbox-4.0.0}/src/labelbox/data/annotation_types/annotation.py

@@ -7,6 +7,7 @@ from labelbox.data.mixins import ConfidenceMixin, CustomMetricsMixin
 
 from labelbox.data.annotation_types.classification.classification import ClassificationAnnotation
 from .ner import DocumentEntity, TextEntity, ConversationEntity
+from typing import Optional
 
 
 class ObjectAnnotation(BaseAnnotation, ConfidenceMixin, CustomMetricsMixin):
@@ -29,4 +30,4 @@ class ObjectAnnotation(BaseAnnotation, ConfidenceMixin, CustomMetricsMixin):
     """
 
     value: Union[TextEntity, ConversationEntity, DocumentEntity, Geometry]
-    classifications: List[ClassificationAnnotation] = []
+    classifications: Optional[List[ClassificationAnnotation]] = []

{labelbox-3.78.2 → labelbox-4.0.0}/src/labelbox/data/annotation_types/base_annotation.py

@@ -1,16 +1,18 @@
 import abc
 from uuid import UUID, uuid4
 from typing import Any, Dict, Optional
-from labelbox import pydantic_compat
 
 from .feature import FeatureSchema
+from pydantic import PrivateAttr, ConfigDict
 
 
 class BaseAnnotation(FeatureSchema, abc.ABC):
     """ Base annotation class. Shouldn't be directly instantiated
     """
-    _uuid: Optional[UUID] = pydantic_compat.PrivateAttr()
+    _uuid: Optional[UUID] = PrivateAttr()
     extra: Dict[str, Any] = {}
+    
+    model_config = ConfigDict(extra="allow")
 
     def __init__(self, **data):
         super().__init__(**data)

labelbox-4.0.0/src/labelbox/data/annotation_types/classification/__init__.py

@@ -0,0 +1,2 @@
+from .classification import (Checklist, ClassificationAnswer, Radio,
+                             Text)

{labelbox-3.78.2 → labelbox-4.0.0}/src/labelbox/data/annotation_types/classification/classification.py

@@ -1,28 +1,12 @@
 from typing import Any, Dict, List, Union, Optional
-import warnings
 from labelbox.data.annotation_types.base_annotation import BaseAnnotation
 
 from labelbox.data.mixins import ConfidenceMixin, CustomMetricsMixin
 
-try:
-    from typing import Literal
-except:
-    from typing_extensions import Literal
-
-from labelbox import pydantic_compat
+from pydantic import BaseModel
 from ..feature import FeatureSchema
 
 
-# TODO: Replace when pydantic adds support for unions that don't coerce types
-class _TempName(ConfidenceMixin, pydantic_compat.BaseModel):
-    name: str
-
-    def dict(self, *args, **kwargs):
-        res = super().dict(*args, **kwargs)
-        res.pop('name')
-        return res
-
-
 class ClassificationAnswer(FeatureSchema, ConfidenceMixin, CustomMetricsMixin):
     """
     - Represents a classification option.
@@ -36,18 +20,10 @@ class ClassificationAnswer(FeatureSchema, ConfidenceMixin, CustomMetricsMixin):
     """
     extra: Dict[str, Any] = {}
     keyframe: Optional[bool] = None
-    classifications: List['ClassificationAnnotation'] = []
+    classifications: Optional[List['ClassificationAnnotation']] = None
 
-    def dict(self, *args, **kwargs) -> Dict[str, str]:
-        res = super().dict(*args, **kwargs)
-        if res['keyframe'] is None:
-            res.pop('keyframe')
-        if res['classifications'] == []:
-            res.pop('classifications')
-        return res
 
-
-class Radio(ConfidenceMixin, CustomMetricsMixin, pydantic_compat.BaseModel):
+class Radio(ConfidenceMixin, CustomMetricsMixin, BaseModel):
     """ A classification with only one selected option allowed
 
     >>> Radio(answer = ClassificationAnswer(name = "dog"))
@@ -56,17 +32,16 @@ class Radio(ConfidenceMixin, CustomMetricsMixin, pydantic_compat.BaseModel):
     answer: ClassificationAnswer
 
 
-class Checklist(_TempName):
+class Checklist(ConfidenceMixin, BaseModel):
     """ A classification with many selected options allowed
 
     >>> Checklist(answer = [ClassificationAnswer(name = "cloudy")])
 
     """
-    name: Literal["checklist"] = "checklist"
     answer: List[ClassificationAnswer]
 
 
-class Text(ConfidenceMixin, CustomMetricsMixin, pydantic_compat.BaseModel):
+class Text(ConfidenceMixin, CustomMetricsMixin, BaseModel):
     """ Free form text
 
     >>> Text(answer = "some text answer")
@@ -75,24 +50,6 @@ class Text(ConfidenceMixin, CustomMetricsMixin, pydantic_compat.BaseModel):
     answer: str
 
 
-class Dropdown(_TempName):
-    """
-    - A classification with many selected options allowed .
-    - This is not currently compatible with MAL.
-
-    Deprecation Notice: Dropdown classification is deprecated and will be
-        removed in a future release. Dropdown will also
-        no longer be able to be created in the Editor on 3/31/2022.    
-    """
-    name: Literal["dropdown"] = "dropdown"
-    answer: List[ClassificationAnswer]
-
-    def __init__(self, **data: Any):
-        super().__init__(**data)
-        warnings.warn("Dropdown classification is deprecated and will be "
-                      "removed in a future release")
-
-
 class ClassificationAnnotation(BaseAnnotation, ConfidenceMixin,
                                CustomMetricsMixin):
     """Classification annotations (non localized)
@@ -106,12 +63,9 @@ class ClassificationAnnotation(BaseAnnotation, ConfidenceMixin,
         name (Optional[str])
         classifications (Optional[List[ClassificationAnnotation]]): Optional sub classification of the annotation
         feature_schema_id (Optional[Cuid])
-        value (Union[Text, Checklist, Radio, Dropdown])
+        value (Union[Text, Checklist, Radio])
         extra (Dict[str, Any])
      """
 
-    value: Union[Text, Checklist, Radio, Dropdown]
+    value: Union[Text, Checklist, Radio]
     message_id: Optional[str] = None
-
-
-ClassificationAnswer.update_forward_refs()

{labelbox-3.78.2 → labelbox-4.0.0}/src/labelbox/data/annotation_types/data/base_data.py

@@ -1,10 +1,10 @@
 from abc import ABC
 from typing import Optional, Dict, List, Any
 
-from labelbox import pydantic_compat
+from pydantic import BaseModel
 
 
-class BaseData(pydantic_compat.BaseModel, ABC):
+class BaseData(BaseModel, ABC):
     """
     Base class for objects representing data.
     This class shouldn't directly be used

{labelbox-3.78.2 → labelbox-4.0.0}/src/labelbox/data/annotation_types/data/conversation.py

@@ -3,5 +3,5 @@ from labelbox.utils import _NoCoercionMixin
 from .base_data import BaseData
 
 
-class ConversationData(BaseData):
-    class_name: Literal["ConversationData"] = "ConversationData"
+class ConversationData(BaseData, _NoCoercionMixin):
+    class_name: Literal["ConversationData"] = "ConversationData"

{labelbox-3.78.2 → labelbox-4.0.0}/src/labelbox/data/annotation_types/data/generic_data_row_data.py

@@ -1,8 +1,8 @@
 from typing import Callable, Literal, Optional
 
-from labelbox import pydantic_compat
 from labelbox.data.annotation_types.data.base_data import BaseData
 from labelbox.utils import _NoCoercionMixin
+from pydantic import model_validator
 
 
 class GenericDataRowData(BaseData, _NoCoercionMixin):
@@ -14,7 +14,8 @@ class GenericDataRowData(BaseData, _NoCoercionMixin):
     def create_url(self, signer: Callable[[bytes], str]) -> Optional[str]:
         return self.url
 
-    @pydantic_compat.root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def validate_one_datarow_key_present(cls, data):
         keys = ['external_id', 'global_key', 'uid']
         count = sum([key in data for key in keys])

{labelbox-3.78.2 → labelbox-4.0.0}/src/labelbox/data/annotation_types/data/raster.py

@@ -9,19 +9,23 @@ from requests.exceptions import ConnectTimeout
 import requests
 import numpy as np
 
-from labelbox import pydantic_compat
+from pydantic import BaseModel, model_validator, ConfigDict
 from labelbox.exceptions import InternalServerError
 from .base_data import BaseData
 from ..types import TypedArray
 
 
-class RasterData(pydantic_compat.BaseModel, ABC):
+class RasterData(BaseModel, ABC):
     """Represents an image or segmentation mask.
     """
     im_bytes: Optional[bytes] = None
     file_path: Optional[str] = None
     url: Optional[str] = None
+    uid: Optional[str] = None
+    global_key: Optional[str] = None
     arr: Optional[TypedArray[Literal['uint8']]] = None
+    
+    model_config = ConfigDict(extra="forbid")
 
     @classmethod
     def from_2D_arr(cls, arr: Union[TypedArray[Literal['uint8']],
@@ -155,14 +159,14 @@ class RasterData(pydantic_compat.BaseModel, ABC):
                 "One of url, im_bytes, file_path, arr must not be None.")
         return self.url
 
-    @pydantic_compat.root_validator()
-    def validate_args(cls, values):
-        file_path = values.get("file_path")
-        im_bytes = values.get("im_bytes")
-        url = values.get("url")
-        arr = values.get("arr")
-        uid = values.get('uid')
-        global_key = values.get('global_key')
+    @model_validator(mode="after")
+    def validate_args(self, values):
+        file_path = self.file_path
+        im_bytes = self.im_bytes
+        url = self.url
+        arr = self.arr
+        uid = self.uid
+        global_key = self.global_key
         if uid == file_path == im_bytes == url == global_key == None and arr is None:
             raise ValueError(
                 "One of `file_path`, `im_bytes`, `url`, `uid`, `global_key` or `arr` required."
@@ -175,8 +179,8 @@ class RasterData(pydantic_compat.BaseModel, ABC):
             elif len(arr.shape) != 3:
                 raise ValueError(
                     "unsupported image format. Must be 3D ([H,W,C])."
-                    f"Use {cls.__name__}.from_2D_arr to construct from 2D")
-        return values
+                    f"Use {self.__name__}.from_2D_arr to construct from 2D")
+        return self
 
     def __repr__(self) -> str:
         symbol_or_none = lambda data: '...' if data is not None else None
@@ -185,12 +189,6 @@ class RasterData(pydantic_compat.BaseModel, ABC):
                f"url={self.url}," \
                f"arr={symbol_or_none(self.arr)})"
 
-    class Config:
-        # Required for sharing references
-        copy_on_model_validation = 'none'
-        # Required for discriminating between data types
-        extra = 'forbid'
-
 
 class MaskData(RasterData):
     """Used to represent a segmentation Mask

{labelbox-3.78.2 → labelbox-4.0.0}/src/labelbox/data/annotation_types/data/text.py

@@ -4,7 +4,7 @@ import requests
 from requests.exceptions import ConnectTimeout
 from google.api_core import retry
 
-from labelbox import pydantic_compat
+from pydantic import ConfigDict, model_validator
 from labelbox.exceptions import InternalServerError
 from labelbox.typing_imports import Literal
 from labelbox.utils import _NoCoercionMixin
@@ -26,6 +26,7 @@ class TextData(BaseData, _NoCoercionMixin):
     file_path: Optional[str] = None
     text: Optional[str] = None
     url: Optional[str] = None
+    model_config = ConfigDict(extra="forbid")
 
     @property
     def value(self) -> str:
@@ -64,7 +65,7 @@ class TextData(BaseData, _NoCoercionMixin):
         """
         response = requests.get(self.url)
         if response.status_code in [500, 502, 503, 504]:
-            raise labelbox.exceptions.InternalServerError(response.text)
+            raise InternalServerError(response.text)
         response.raise_for_status()
         return response.text
 
@@ -90,24 +91,20 @@ class TextData(BaseData, _NoCoercionMixin):
                 "One of url, im_bytes, file_path, numpy must not be None.")
         return self.url
 
-    @pydantic_compat.root_validator
-    def validate_date(cls, values):
-        file_path = values.get("file_path")
-        text = values.get("text")
-        url = values.get("url")
-        uid = values.get('uid')
-        global_key = values.get('global_key')
+    @model_validator(mode="after")
+    def validate_date(self, values):
+        file_path = self.file_path
+        text = self.text
+        url = self.url
+        uid = self.uid
+        global_key = self.global_key
         if uid == file_path == text == url == global_key == None:
             raise ValueError(
                 "One of `file_path`, `text`, `uid`, `global_key` or `url` required."
             )
-        return values
+        return self
 
     def __repr__(self) -> str:
         return  f"TextData(file_path={self.file_path}," \
                 f"text={self.text[:30] + '...' if self.text is not None else None}," \
                 f"url={self.url})"
-
-    class config:
-        # Required for discriminating between data types
-        extra = 'forbid'

{labelbox-3.78.2 → labelbox-4.0.0}/src/labelbox/data/annotation_types/data/tiled_image.py

@@ -12,11 +12,11 @@ from google.api_core import retry
 from PIL import Image
 from pyproj import Transformer
 from pygeotile.point import Point as PygeoPoint
-from labelbox import pydantic_compat
 
 from labelbox.data.annotation_types import Rectangle, Point, Line, Polygon
 from .base_data import BaseData
 from .raster import RasterData
+from pydantic import BaseModel, field_validator, model_validator, ConfigDict
 
 VALID_LAT_RANGE = range(-90, 90)
 VALID_LNG_RANGE = range(-180, 180)
@@ -40,7 +40,7 @@ class EPSG(Enum):
     EPSG3857 = 3857
 
 
-class TiledBounds(pydantic_compat.BaseModel):
+class TiledBounds(BaseModel):
     """ Bounds for a tiled image asset related to the relevant epsg.
 
     Bounds should be Point objects.
@@ -54,7 +54,7 @@ class TiledBounds(pydantic_compat.BaseModel):
     epsg: EPSG
     bounds: List[Point]
 
-    @pydantic_compat.validator('bounds')
+    @field_validator('bounds')
     def validate_bounds_not_equal(cls, bounds):
         first_bound = bounds[0]
         second_bound = bounds[1]
@@ -66,10 +66,10 @@ class TiledBounds(pydantic_compat.BaseModel):
         return bounds
 
     #validate bounds are within lat,lng range if they are EPSG4326
-    @pydantic_compat.root_validator
-    def validate_bounds_lat_lng(cls, values):
-        epsg = values.get('epsg')
-        bounds = values.get('bounds')
+    @model_validator(mode="after")
+    def validate_bounds_lat_lng(self):
+        epsg = self.epsg
+        bounds = self.bounds
 
         if epsg == EPSG.EPSG4326:
             for bound in bounds:
@@ -79,10 +79,10 @@ class TiledBounds(pydantic_compat.BaseModel):
                     raise ValueError(f"Invalid lat/lng bounds. Found {bounds}. "
                                      f"lat must be in {VALID_LAT_RANGE}. "
                                      f"lng must be in {VALID_LNG_RANGE}.")
-        return values
+        return self
 
 
-class TileLayer(pydantic_compat.BaseModel):
+class TileLayer(BaseModel):
     """ Url that contains the tile layer. Must be in the format:
 
     https://c.tile.openstreetmap.org/{z}/{x}/{y}.png
@@ -98,7 +98,7 @@ class TileLayer(pydantic_compat.BaseModel):
     def asdict(self) -> Dict[str, str]:
         return {"tileLayerUrl": self.url, "name": self.name}
 
-    @pydantic_compat.validator('url')
+    @field_validator('url')
     def validate_url(cls, url):
         xyz_format = "/{z}/{x}/{y}"
         if xyz_format not in url:
@@ -343,7 +343,7 @@ class TiledImageData(BaseData):
                              f"Max allowed tiles are {max_tiles}"
                              f"Increase max tiles or reduce zoom level.")
 
-    @pydantic_compat.validator('zoom_levels')
+    @field_validator('zoom_levels')
     def validate_zoom_levels(cls, zoom_levels):
         if zoom_levels[0] > zoom_levels[1]:
             raise ValueError(
@@ -352,15 +352,12 @@ class TiledImageData(BaseData):
         return zoom_levels
 
 
-class EPSGTransformer(pydantic_compat.BaseModel):
+class EPSGTransformer(BaseModel):
     """Transformer class between different EPSG's. Useful when wanting to project
     in different formats.
     """
-
-    class Config:
-        arbitrary_types_allowed = True
-
     transformer: Any
+    model_config = ConfigDict(arbitrary_types_allowed = True)
 
     @staticmethod
     def _is_simple(epsg: EPSG) -> bool:

{labelbox-3.78.2 → labelbox-4.0.0}/src/labelbox/data/annotation_types/data/video.py

@@ -12,7 +12,7 @@ from google.api_core import retry
 from .base_data import BaseData
 from ..types import TypedArray
 
-from labelbox import pydantic_compat
+from pydantic import ConfigDict, model_validator
 
 logger = logging.getLogger(__name__)
 
@@ -24,6 +24,8 @@ class VideoData(BaseData):
     file_path: Optional[str] = None
     url: Optional[str] = None
     frames: Optional[Dict[int, TypedArray[Literal['uint8']]]] = None
+    # Required for discriminating between data types
+    model_config = ConfigDict(extra = "forbid")
 
     def load_frames(self, overwrite: bool = False) -> None:
         """
@@ -148,25 +150,21 @@ class VideoData(BaseData):
         out.release()
         return file_path
 
-    @pydantic_compat.root_validator
-    def validate_data(cls, values):
-        file_path = values.get("file_path")
-        url = values.get("url")
-        frames = values.get("frames")
-        uid = values.get("uid")
-        global_key = values.get("global_key")
+    @model_validator(mode="after")
+    def validate_data(self):
+        file_path = self.file_path
+        url = self.url
+        frames = self.frames
+        uid = self.uid
+        global_key = self.global_key
 
         if uid == file_path == frames == url == global_key == None:
             raise ValueError(
                 "One of `file_path`, `frames`, `uid`, `global_key` or `url` required."
             )
-        return values
+        return self
 
     def __repr__(self) -> str:
         return  f"VideoData(file_path={self.file_path}," \
                 f"frames={'...' if self.frames is not None else None}," \
                 f"url={self.url})"
-
-    class Config:
-        # Required for discriminating between data types
-        extra = 'forbid'

labelbox-4.0.0/src/labelbox/data/annotation_types/feature.py

@@ -0,0 +1,21 @@
+from typing import Optional
+from pydantic import BaseModel, model_validator, model_serializer
+from .types import Cuid
+
+
+class FeatureSchema(BaseModel):
+    """
+    Class that represents a feature schema.
+    Could be a annotation, a subclass, or an option.
+    Schema ids might not be known when constructing these objects so both a name and schema id are valid.
+    """
+    name: Optional[str] = None
+    feature_schema_id: Optional[Cuid] = None
+
+    @model_validator(mode="after")
+    def must_set_one(self):
+        if self.feature_schema_id is None and self.name is None:
+            raise ValueError(
+                "Must set either feature_schema_id or name for all feature schemas"
+            )
+        return self