Merge pull request #301 from superannotateai/validations

Validations

Author: VaghinakDev

src/superannotate/lib/app/annotation_helpers.py

@@ -4,23 +4,23 @@
 from superannotate.lib.app.exceptions import AppException
 
 
-def fill_in_missing(annotation_json):
+def fill_in_missing(annotation_json, image_name: str = ""):
     for field in ["instances", "comments", "tags"]:
         if field not in annotation_json:
             annotation_json[field] = []
     if "metadata" not in annotation_json:
-        annotation_json["metadata"] = {}
+        annotation_json["metadata"] = {"name": image_name}
 
 
-def _preprocess_annotation_json(annotation_json):
+def _preprocess_annotation_json(annotation_json, image_name: str = ""):
     path = None
     if not isinstance(annotation_json, dict) and annotation_json is not None:
         path = annotation_json
         annotation_json = json.load(open(annotation_json))
     elif annotation_json is None:
         annotation_json = {}
 
-    fill_in_missing(annotation_json)
+    fill_in_missing(annotation_json, image_name)
 
     return (annotation_json, path)
 
@@ -60,7 +60,7 @@ def add_annotation_comment_to_json(
         "type": "comment",
         "x": comment_coords[0],
         "y": comment_coords[1],
-        "correspondence": [{"text": comment_text, "id": comment_author}],
+        "correspondence": [{"text": comment_text, "email": comment_author}],
         "resolved": resolved,
     }
     annotation_json["comments"].append(annotation)
@@ -74,6 +74,7 @@ def add_annotation_bbox_to_json(
     annotation_class_name,
     annotation_class_attributes=None,
     error=None,
+    image_name: str = "",
 ):
     """Add a bounding box annotation to SuperAnnotate format annotation JSON
 
@@ -94,7 +95,7 @@ def add_annotation_bbox_to_json(
     if len(bbox) != 4:
         raise AppException("Bounding boxes should have 4 float elements")
 
-    annotation_json, path = _preprocess_annotation_json(annotation_json)
+    annotation_json, path = _preprocess_annotation_json(annotation_json, image_name)
 
     annotation = {
         "type": "bbox",

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

@@ -2477,6 +2477,7 @@ def upload_annotations_from_folder_to_project(
         folder_name=folder_name,
         annotation_paths=annotation_paths,  # noqa: E203
         client_s3_bucket=from_s3_bucket,
+        folder_path=folder_path,
     )
     if response.errors:
         raise AppException(response.errors)
@@ -3070,7 +3071,12 @@ def add_annotation_bbox_to_image(
     """
     annotations = get_image_annotations(project, image_name)["annotation_json"]
     annotations = add_annotation_bbox_to_json(
-        annotations, bbox, annotation_class_name, annotation_class_attributes, error,
+        annotations,
+        bbox,
+        annotation_class_name,
+        annotation_class_attributes,
+        error,
+        image_name,
     )
     upload_image_annotations(project, image_name, annotations, verbose=False)
 
@@ -3639,12 +3645,23 @@ def attach_document_urls_to_project(
 def validate_annotations(
     project_type: ProjectTypes, annotations_json: Union[NotEmptyStr, Path]
 ):
+    """
+    Validates given annotation JSON.
+        :param project_type: project_type (str) – the project type Vector, Pixel, Video or Document
+        :type project_type: str
+        :param annotations_json: path to annotation JSON
+        :type annotations_json: Path-like (str or Path)
+
+        :return: The success of the validation
+        :rtype: bool
+        """
     with open(annotations_json) as file:
         annotation_data = json.loads(file.read())
-        response = controller.validate_annotations(project_type, annotation_data)
+        response = controller.validate_annotations(project_type, annotation_data, allow_extra=False)
         if response.errors:
             raise AppException(response.errors)
-        if response.data:
+        is_valid, _ = response.data
+        if is_valid:
             return True
         print(response.report)
         return False

src/superannotate/lib/core/entities/__init__.py

@@ -0,0 +1,41 @@
+from lib.core.entities.document import DocumentAnnotation
+from lib.core.entities.pixel import PixelAnnotation
+from lib.core.entities.project_entities import AnnotationClassEntity
+from lib.core.entities.project_entities import BaseEntity
+from lib.core.entities.project_entities import ConfigEntity
+from lib.core.entities.project_entities import FolderEntity
+from lib.core.entities.project_entities import ImageEntity
+from lib.core.entities.project_entities import ImageInfoEntity
+from lib.core.entities.project_entities import MLModelEntity
+from lib.core.entities.project_entities import ProjectEntity
+from lib.core.entities.project_entities import ProjectSettingEntity
+from lib.core.entities.project_entities import S3FileEntity
+from lib.core.entities.project_entities import TeamEntity
+from lib.core.entities.project_entities import UserEntity
+from lib.core.entities.project_entities import WorkflowEntity
+from lib.core.entities.vector import VectorAnnotation
+from lib.core.entities.video import VideoAnnotation
+from lib.core.entities.video_export import VideoAnnotation as VideoExportAnnotation
+
+
+__all__ = [
+    "BaseEntity",
+    "ProjectEntity",
+    "ProjectSettingEntity",
+    "ConfigEntity",
+    "WorkflowEntity",
+    "FolderEntity",
+    "ImageEntity",
+    "ImageInfoEntity",
+    "S3FileEntity",
+    "AnnotationClassEntity",
+    "UserEntity",
+    "TeamEntity",
+    "MLModelEntity",
+    # annotations
+    "DocumentAnnotation",
+    "VideoAnnotation",
+    "VectorAnnotation",
+    "PixelAnnotation",
+    "VideoExportAnnotation",
+]

src/superannotate/lib/core/entities/document.py

@@ -0,0 +1,22 @@
+from typing import List
+from typing import Optional
+
+from lib.core.entities.utils import Attribute
+from lib.core.entities.utils import BaseInstance
+from lib.core.entities.utils import BaseModel
+from lib.core.entities.utils import MetadataBase
+from lib.core.entities.utils import Tag
+from pydantic import Field
+
+
+class DocumentInstance(BaseInstance):
+    start: int
+    end: int
+    attributes: Optional[List[Attribute]] = Field(list())
+
+
+class DocumentAnnotation(BaseModel):
+    metadata: MetadataBase
+    instances: Optional[List[DocumentInstance]] = Field(list())
+    tags: Optional[List[Tag]] = Field(list())
+    free_text: Optional[str] = Field(None, alias="freeText")

src/superannotate/lib/core/entities/pixel.py

@@ -0,0 +1,34 @@
+from typing import List
+from typing import Optional
+
+from lib.core.entities.utils import BaseImageInstance
+from lib.core.entities.utils import BaseModel
+from lib.core.entities.utils import Metadata
+from lib.core.entities.utils import Tag
+from pydantic import Field
+from pydantic import validator
+from pydantic.color import Color
+from pydantic.color import ColorType
+
+
+class PixelMetaData(Metadata):
+    is_segmented: Optional[bool] = Field(None, alias="isSegmented")
+
+
+class PixelAnnotationPart(BaseModel):
+    color: ColorType
+
+    @validator("color")
+    def validate_color(cls, v):
+        color = Color(v)
+        return color.as_hex()
+
+
+class PixelAnnotationInstance(BaseImageInstance):
+    parts: List[PixelAnnotationPart]
+
+
+class PixelAnnotation(BaseModel):
+    metadata: PixelMetaData
+    instances: List[PixelAnnotationInstance]
+    tags: Optional[List[Tag]] = Field(list())

src/superannotate/lib/core/entities.py …te/lib/core/entities/project_entities.pysrc/superannotate/lib/core/entities.py renamed to src/superannotate/lib/core/entities/project_entities.py src/superannotate/lib/core/entities.py renamed to src/superannotate/lib/core/entities/project_entities.py

@@ -0,0 +1,188 @@
+from enum import Enum
+from typing import Dict
+from typing import List
+from typing import Optional
+
+from pydantic import BaseModel as PyDanticBaseModel
+from pydantic import conlist
+from pydantic import constr
+from pydantic import EmailStr
+from pydantic import Field
+from pydantic import Extra
+from pydantic import validator
+from pydantic.errors import EnumMemberError
+
+
+def enum_error_handling(self) -> str:
+    permitted = ", ".join(repr(v.value) for v in self.enum_values)
+    return f"Invalid value, permitted: {permitted}"
+
+
+EnumMemberError.__str__ = enum_error_handling
+
+
+NotEmptyStr = constr(strict=True, min_length=1)
+
+
+DATE_REGEX = r"\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d(?:\.\d{3})Z"
+
+
+class BaseModel(PyDanticBaseModel):
+
+    class Config:
+        extra = Extra.allow
+        use_enum_values = True
+        error_msg_templates = {
+            "type_error.integer": "integer type expected",
+            "type_error.string": "str type expected",
+            "value_error.missing": "field required",
+        }
+
+
+class VectorAnnotationTypeEnum(str, Enum):
+    BBOX = "bbox"
+    ELLIPSE = "ellipse"
+    TEMPLATE = "template"
+    CUBOID = "cuboid"
+    POLYLINE = "polyline"
+    POLYGON = "polygon"
+    POINT = "point"
+    RBBOX = "rbbox"
+
+
+class CreationTypeEnum(str, Enum):
+    MANUAL = "Manual"
+    PREDICTION = "Prediction"
+    PRE_ANNOTATION = "Preannotation"
+
+
+class AnnotationStatusEnum(str, Enum):
+    NOT_STARTED = "NotStarted"
+    IN_PROGRESS = "InProgress"
+    QUALITY_CHECK = "QualityCheck"
+    RETURNED = "Returned"
+    COMPLETED = "Completed"
+    SKIPPED = "Skipped"
+
+
+class BaseRoleEnum(str, Enum):
+    ADMIN = "Admin"
+    ANNOTATOR = "Annotator"
+    QA = "QA"
+
+
+class BaseImageRoleEnum(str, Enum):
+    CUSTOMER = "Customer"
+    ADMIN = "Admin"
+    ANNOTATOR = "Annotator"
+    QA = "QA"
+
+
+class Attribute(BaseModel):
+    id: Optional[int]
+    group_id: Optional[int] = Field(None, alias="groupId")
+    name: NotEmptyStr
+    group_name: NotEmptyStr = Field(None, alias="groupName")
+
+
+class Tag(BaseModel):
+    __root__: str
+
+
+class AttributeGroup(BaseModel):
+    name: NotEmptyStr
+    is_multiselect: Optional[int] = False
+    attributes: List[Attribute]
+
+
+class BboxPoints(BaseModel):
+    x1: float
+    x2: float
+    y1: float
+    y2: float
+
+
+class TimedBaseModel(BaseModel):
+    created_at: constr(regex=DATE_REGEX) = Field(None, alias="createdAt")
+    updated_at: constr(regex=DATE_REGEX) = Field(None, alias="updatedAt")
+
+
+class UserAction(BaseModel):
+    email: EmailStr
+    role: BaseImageRoleEnum
+
+
+class TrackableModel(BaseModel):
+    created_by: Optional[UserAction] = Field(None, alias="createdBy")
+    updated_by: Optional[UserAction] = Field(None, alias="updatedBy")
+    creation_type: Optional[CreationTypeEnum] = Field(
+        CreationTypeEnum.PRE_ANNOTATION.value, alias="creationType"
+    )
+
+    @validator("creation_type", always=True)
+    def clean_creation_type(cls, _):
+        return CreationTypeEnum.PRE_ANNOTATION.value
+
+
+class LastUserAction(BaseModel):
+    email: EmailStr
+    timestamp: float
+
+
+class BaseInstance(TrackableModel, TimedBaseModel):
+    class_id: Optional[str] = Field(None, alias="classId")
+    class_name: Optional[str] = Field(None, alias="className")
+
+
+class MetadataBase(BaseModel):
+    name: NotEmptyStr
+    last_action: Optional[LastUserAction] = Field(None, alias="lastAction")
+    width: Optional[int]
+    height: Optional[int]
+    project_id: Optional[int] = Field(None, alias="projectId")
+    annotator_email: Optional[EmailStr] = Field(None, alias="annotatorEmail")
+    qa_email: Optional[EmailStr] = Field(None, alias="qaEmail")
+    status: Optional[AnnotationStatusEnum]
+
+
+class PointLabels(BaseModel):
+    __root__: Dict[constr(regex=r"^[0-9]*$"), str]  # noqa: F722 E261
+
+
+class Correspondence(BaseModel):
+    text: NotEmptyStr
+    email: EmailStr
+
+
+class Comment(TimedBaseModel, TrackableModel):
+    x: float
+    y: float
+    resolved: Optional[bool] = Field(False)
+    correspondence: conlist(Correspondence, min_items=1)
+
+
+class BaseImageInstance(BaseInstance):
+    class_id: Optional[int] = Field(None, alias="classId")
+    class_name: str = Field(alias="className")
+    visible: Optional[bool]
+    locked: Optional[bool]
+    probability: Optional[int] = Field(100)
+    attributes: Optional[List[Attribute]] = Field(list())
+    error: Optional[bool]
+
+    class Config:
+        error_msg_templates = {
+            "value_error.missing": "field required for annotation",
+        }
+
+
+class BaseVectorInstance(BaseImageInstance):
+    type: VectorAnnotationTypeEnum
+    point_labels: Optional[PointLabels] = Field(None, alias="pointLabels")
+    tracking_id: Optional[str] = Field(None, alias="trackingId")
+    group_id: Optional[int] = Field(None, alias="groupId")
+
+
+class Metadata(MetadataBase):
+    pinned: Optional[bool]
+    is_predicted: Optional[bool] = Field(None, alias="isPredicted")