Revert "Upgrade pydantic to v2"

This reverts commit f41d1e6.

Author: VaghinakDev

requirements.txt

@@ -1,10 +1,9 @@
-pydantic>=2.5,<3
-pydantic-extra-types>=2.0
+pydantic>=1.10,<3,!=2.0.*
 aiohttp~=3.8
 boto3~=1.26
 opencv-python-headless~=4.7
 plotly~=5.14
-pandas~=2.2
+pandas~=2.0
 pillow~=12.1
 tqdm~=4.66
 requests==2.*

src/superannotate/lib/app/interface/base_interface.py

@@ -9,18 +9,17 @@
 from pathlib import Path
 from types import FunctionType
 from typing import Iterable
-from typing import Optional
 from typing import Sized
 
-from pydantic import ValidationError
-
 import lib.core as constants
 from lib.app.interface.types import validate_arguments
 from lib.core import CONFIG
 from lib.core import setup_logging
 from lib.core.entities.base import ConfigEntity
 from lib.core.entities.base import TokenStr
 from lib.core.exceptions import AppException
+from lib.core.pydantic_v1 import ErrorWrapper
+from lib.core.pydantic_v1 import ValidationError
 from lib.infrastructure.controller import Controller
 from lib.infrastructure.utils import extract_project_folder_inputs
 from lib.infrastructure.validators import wrap_error
@@ -31,7 +30,7 @@ class BaseInterfaceFacade:
     REGISTRY = []
 
     @validate_arguments
-    def __init__(self, token: Optional[TokenStr] = None, config_path: Optional[str] = None):
+    def __init__(self, token: TokenStr = None, config_path: str = None):
         try:
             if token:
                 config = ConfigEntity(SA_TOKEN=token)
@@ -81,7 +80,10 @@ def _retrieve_configs_from_json(path: Path) -> typing.Union[ConfigEntity]:
         try:
             config = ConfigEntity(SA_TOKEN=token)
         except ValidationError:
-            raise AppException("Invalid token.")
+            raise ValidationError(
+                [ErrorWrapper(ValueError("Invalid token."), loc="token")],
+                model=ConfigEntity,
+            )
         host = json_data.get("main_endpoint")
         verify_ssl = json_data.get("ssl_verify")
         if host:

src/superannotate/lib/app/interface/sdk_interface.py

@@ -56,26 +56,20 @@
 from lib.core.entities.integrations import IntegrationTypeEnum
 from lib.core.enums import ImageQuality
 from lib.core.enums import CustomFieldEntityEnum
-from pydantic import TypeAdapter
-from pydantic import ValidationError
-
 from lib.core.enums import ProjectType
 from lib.core.enums import ClassTypeEnum
 from lib.core.exceptions import AppException
-from lib.core.pydantic_v1 import constr
-from lib.core.pydantic_v1 import conlist
 from lib.core.types import PriorityScoreEntity
 from lib.core.types import Project
+from lib.core.pydantic_v1 import ValidationError
+from lib.core.pydantic_v1 import constr
+from lib.core.pydantic_v1 import conlist
+from lib.core.pydantic_v1 import parse_obj_as
 from lib.infrastructure.annotation_adapter import BaseMultimodalAnnotationAdapter
 from lib.infrastructure.annotation_adapter import MultimodalSmallAnnotationAdapter
 from lib.infrastructure.annotation_adapter import MultimodalLargeAnnotationAdapter
 from lib.infrastructure.utils import extract_project_folder
 from lib.infrastructure.validators import wrap_error
-
-
-def parse_obj_as(type_, obj):
-    """Compatibility function for pydantic v1 parse_obj_as."""
-    return TypeAdapter(type_).validate_python(obj)
 from lib.app.serializers import WMProjectSerializer
 from lib.core.entities.work_managament import WMUserTypeEnum
 from lib.core.jsx_conditions import EmptyQuery
@@ -1881,7 +1875,7 @@ def get_project_settings(self, project: Union[NotEmptyStr, dict]):
         project = self.controller.projects.get_by_name(project_name).data
         settings = self.controller.projects.list_settings(project).data
         settings = [
-            SettingsSerializer(attribute.model_dump()).serialize() for attribute in settings
+            SettingsSerializer(attribute.dict()).serialize() for attribute in settings
         ]
         return settings
 
@@ -2827,7 +2821,7 @@ def create_annotation_class(
         """
 
         attribute_groups = (
-            list(map(lambda x: x.model_dump(), attribute_groups)) if attribute_groups else []
+            list(map(lambda x: x.dict(), attribute_groups)) if attribute_groups else []
         )
         try:
             annotation_class = AnnotationClassEntity(

src/superannotate/lib/app/interface/types.py

@@ -1,17 +1,15 @@
-import re
 from functools import wraps
-from typing import Annotated
 from typing import Union
 
-from pydantic import AfterValidator
-from pydantic import StrictStr
-from pydantic import validate_call
-from pydantic import ValidationError
-
 from lib.core.enums import BaseTitledEnum
 from lib.core.exceptions import AppException
+from lib.core.pydantic_v1 import constr
 from lib.core.pydantic_v1 import errors
+from lib.core.pydantic_v1 import pydantic_validate_arguments
 from lib.core.pydantic_v1 import PydanticTypeError
+from lib.core.pydantic_v1 import StrictStr
+from lib.core.pydantic_v1 import StrRegexError
+from lib.core.pydantic_v1 import ValidationError
 from lib.infrastructure.validators import wrap_error
 
 
@@ -30,31 +28,27 @@ def __str__(self) -> str:
 errors.EnumMemberError = EnumMemberError
 
 
-# Email validation pattern
-_EMAIL_PATTERN = re.compile(
-    r"^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)"
-    r"*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}"
-    r"[a-zA-Z0-9])?)*$"
-)
-
-
-def _validate_email(value: str) -> str:
-    """Validate email format."""
-    if not _EMAIL_PATTERN.match(value):
-        raise ValueError("Invalid email")
-    return value
-
-
-EmailStr = Annotated[StrictStr, AfterValidator(_validate_email)]
+class EmailStr(StrictStr):
+    @classmethod
+    def validate(cls, value: Union[str]) -> Union[str]:
+        try:
+            constr(
+                regex=r"^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)"
+                r"*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}"
+                r"[a-zA-Z0-9])?)*$"
+            ).validate(  # noqa
+                value
+            )
+        except StrRegexError:
+            raise ValueError("Invalid email")
+        return value
 
 
 def validate_arguments(func):
-    validated_func = validate_call(func)
-
     @wraps(func)
     def wrapped(self, *args, **kwargs):
         try:
-            return validated_func(self, *args, **kwargs)
+            return pydantic_validate_arguments(func)(self, *args, **kwargs)
         except ValidationError as e:
             raise AppException(wrap_error(e)) from e
 

src/superannotate/lib/app/serializers.py

@@ -4,10 +4,9 @@
 from typing import Set
 from typing import Union
 
-from pydantic import BaseModel
-
 import lib.core as constance
 from lib.core.entities import BaseEntity
+from lib.core.pydantic_v1 import BaseModel
 
 
 class BaseSerializer:
@@ -59,16 +58,16 @@ def _serialize(
             if fields:
                 if len(fields) == 1:
                     if flat:
-                        return entity.model_dump(
+                        return entity.dict(
                             include=fields, by_alias=by_alias, exclude=exclude, **kwargs
                         )[next(iter(fields))]
-                    return entity.model_dump(
+                    return entity.dict(
                         include=fields, by_alias=by_alias, exclude=exclude, **kwargs
                     )
-                return entity.model_dump(
+                return entity.dict(
                     include=fields, by_alias=by_alias, exclude=exclude, **kwargs
                 )
-            return entity.model_dump(by_alias=by_alias, exclude=exclude, **kwargs)
+            return entity.dict(by_alias=by_alias, exclude=exclude, **kwargs)
         return entity.to_dict()
 
     @classmethod
@@ -116,7 +115,7 @@ def serialize(
                 to_exclude[field] = True
         if self._entity.classes:
             self._entity.classes = [
-                i.model_dump(by_alias=True, exclude_unset=True) for i in self._entity.classes
+                i.dict(by_alias=True, exclude_unset=True) for i in self._entity.classes
             ]
         data = super().serialize(fields, by_alias, flat, to_exclude)
         if data.get("settings"):
@@ -194,4 +193,4 @@ def serialize(
                 nested_model, "fill_enum_values", False
             ):
                 setattr(data, key, cls.serialize(nested_model, **kwargs))
-        return data.model_dump(**kwargs)
+        return data.dict(**kwargs)