label-studio-sdk 1.0.5__py3-none-any.whl → 1.0.8__py3-none-any.whl

label_studio_sdk/converter/utils.py

@@ -17,10 +17,11 @@ from urllib.parse import urlparse
 import numpy as np
 import requests
 from PIL import Image
-from label_studio_sdk._extensions.label_studio_tools.core.utils.params import get_env
 from lxml import etree
 from nltk.tokenize.treebank import TreebankWordTokenizer
 
+from label_studio_sdk._extensions.label_studio_tools.core.utils.params import get_env
+
 logger = logging.getLogger(__name__)
 
 _LABEL_TAGS = {"Label", "Choice"}
@@ -422,7 +423,7 @@ def convert_annotation_to_yolo(label):
     return x, y, w, h
 
 
-def convert_annotation_to_yolo_obb(label):
+def convert_annotation_to_yolo_obb(label, normalize=True):
     """
     Convert LS annotation to Yolo OBB format.
 
@@ -435,6 +436,7 @@ def convert_annotation_to_yolo_obb(label):
             - width (float): Width of the object in percentage of the original width.
             - height (float): Height of the object in percentage of the original height.
             - rotation (float, optional): Rotation angle of the object in degrees (default is 0).
+        normalize (bool, optional): Whether to normalize the coordinates to the range [0, 1] (default is True).
 
     Returns:
         list of tuple or None: List of tuples containing the coordinates of the object in Yolo OBB format.
@@ -470,4 +472,71 @@ def convert_annotation_to_yolo_obb(label):
     ]
 
     # Normalize coordinates
-    return [(coord[0] / org_width, coord[1] / org_height) for coord in coords]
+    if normalize:
+        return [(coord[0] / org_width, coord[1] / org_height) for coord in coords]
+    else:
+        return coords
+
+
+def convert_yolo_obb_to_annotation(xyxyxyxy, original_width, original_height):
+    """
+    Convert YOLO Oriented Bounding Box (OBB) format to Label Studio format.
+
+    Args:
+        xyxyxyxy (list): List of 8 float values representing the absolute pixel coordinates
+                         of the OBB in the format [x1, y1, x2, y2, x3, y3, x4, y4].
+        original_width (int): Original width of the image.
+        original_height (int): Original height of the image.
+
+    Returns:
+        dict: Dictionary containing the converted bounding box with the following keys:
+              - x: X-coordinate of the top-left corner of the bounding box in percentage.
+              - y: Y-coordinate of the top-left corner of the bounding box in percentage.
+              - width: Width of the bounding box in percentage.
+              - height: Height of the bounding box in percentage.
+              - rotation: Rotation angle of the bounding box in degrees.
+    """
+    # Reshape the coordinates into a 4x2 matrix
+    coords = np.array(xyxyxyxy, dtype=np.float64).reshape((4, 2))
+
+    # Calculate the center of the bounding box
+    center_x = np.mean(coords[:, 0])
+    center_y = np.mean(coords[:, 1])
+
+    # Calculate the width and height of the bounding box
+    width = np.linalg.norm(coords[0] - coords[1])
+    height = np.linalg.norm(coords[0] - coords[3])
+
+    # Calculate the rotation angle
+    dx = coords[1, 0] - coords[0, 0]
+    dy = coords[1, 1] - coords[0, 1]
+    r = np.degrees(np.arctan2(dy, dx))
+
+    # Find the top-left corner (x, y)
+    top_left_x = (
+        center_x
+        - (width / 2) * np.cos(np.radians(r))
+        + (height / 2) * np.sin(np.radians(r))
+    )
+    top_left_y = (
+        center_y
+        - (width / 2) * np.sin(np.radians(r))
+        - (height / 2) * np.cos(np.radians(r))
+    )
+
+    # Normalize the values
+    x = (top_left_x / original_width) * 100
+    y = (top_left_y / original_height) * 100
+    width = (width / original_width) * 100
+    height = (height / original_height) * 100
+
+    # Create the dictionary for Label Studio
+    return {
+        "x": x,
+        "y": y,
+        "width": width,
+        "height": height,
+        "rotation": r,
+        "original_width": original_width,
+        "original_height": original_height,
+    }

label_studio_sdk/core/client_wrapper.py

@@ -17,7 +17,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "label-studio-sdk",
-            "X-Fern-SDK-Version": "1.0.4",
+            "X-Fern-SDK-Version": "1.0.8",
         }
         headers["Authorization"] = f"Token  {self.api_key}"
         return headers

label_studio_sdk/files/client.py

@@ -96,7 +96,12 @@ class FilesClient:
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
     def update(
-        self, id: int, *, request: FileUpload, request_options: typing.Optional[RequestOptions] = None
+        self,
+        id_: int,
+        *,
+        id: typing.Optional[int] = OMIT,
+        file: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> FileUpload:
         """
         Update a specific uploaded file. To get the file upload ID, use [Get files list](list).
@@ -109,10 +114,12 @@ class FilesClient:
 
         Parameters
         ----------
-        id : int
+        id_ : int
             A unique integer value identifying this file upload.
 
-        request : FileUpload
+        id : typing.Optional[int]
+
+        file : typing.Optional[str]
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -124,21 +131,19 @@ class FilesClient:
 
         Examples
         --------
-        from label_studio_sdk import FileUpload
         from label_studio_sdk.client import LabelStudio
 
         client = LabelStudio(
             api_key="YOUR_API_KEY",
         )
         client.files.update(
-            id=1,
-            request=FileUpload(),
+            id_=1,
         )
         """
         _response = self._client_wrapper.httpx_client.request(
-            f"api/import/file-upload/{jsonable_encoder(id)}",
+            f"api/import/file-upload/{jsonable_encoder(id_)}",
             method="PATCH",
-            json=request,
+            json={"id": id, "file": file},
             request_options=request_options,
             omit=OMIT,
         )
@@ -367,7 +372,12 @@ class AsyncFilesClient:
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
     async def update(
-        self, id: int, *, request: FileUpload, request_options: typing.Optional[RequestOptions] = None
+        self,
+        id_: int,
+        *,
+        id: typing.Optional[int] = OMIT,
+        file: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> FileUpload:
         """
         Update a specific uploaded file. To get the file upload ID, use [Get files list](list).
@@ -380,10 +390,12 @@ class AsyncFilesClient:
 
         Parameters
         ----------
-        id : int
+        id_ : int
             A unique integer value identifying this file upload.
 
-        request : FileUpload
+        id : typing.Optional[int]
+
+        file : typing.Optional[str]
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -395,21 +407,19 @@ class AsyncFilesClient:
 
         Examples
         --------
-        from label_studio_sdk import FileUpload
         from label_studio_sdk.client import AsyncLabelStudio
 
         client = AsyncLabelStudio(
             api_key="YOUR_API_KEY",
         )
         await client.files.update(
-            id=1,
-            request=FileUpload(),
+            id_=1,
         )
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"api/import/file-upload/{jsonable_encoder(id)}",
+            f"api/import/file-upload/{jsonable_encoder(id_)}",
             method="PATCH",
-            json=request,
+            json={"id": id, "file": file},
             request_options=request_options,
             omit=OMIT,
         )

label_studio_sdk/label_interface/control_tags.py

@@ -93,6 +93,15 @@ class ControlTag(LabelStudioTag):
             and tag.tag not in _NOT_CONTROL_TAGS
         )
 
+    def to_json_schema(self):
+        """
+        Converts the current ControlTag instance into a JSON Schema.
+
+        Returns:
+            dict: A dictionary representing the JSON Schema.
+        """
+        return {"type": "string"}
+
     @classmethod
     def parse_node(cls, tag: xml.etree.ElementTree.Element, tags_mapping=None) -> "ControlTag":
         """
@@ -261,11 +270,11 @@ class ControlTag(LabelStudioTag):
 
     def _validate_labels(self, labels):
         """Check that labels is a subset of self.labels, used for
-        example when you're validate the annotaion or prediction to
+        example when you're validate the annotation or prediction to
         make sure there no undefined labels used.
 
         """
-        if not self.labels:
+        if not self.labels or not labels:
             return True
 
         return set(labels).issubset(set(self.labels))
@@ -335,10 +344,11 @@ class ControlTag(LabelStudioTag):
 
             return to_name
         else:
-            if len(self.to_name) > 1:
-                raise Exception(
-                    "Multiple to_name in control tag, specify to_name in function"
-                )
+            # TODO: "Pairwise" tag has multiple to_name
+            # if len(self.to_name) > 1:
+            #     raise Exception(
+            #         "Multiple to_name in control tag, specify to_name in function"
+            #     )
 
             return self.to_name[0]
 
@@ -415,7 +425,7 @@ class ControlTag(LabelStudioTag):
             )
 
         kwargs[self._label_attr_name] = label
-
+        
         return self._label_simple(to_name=to_name, **kwargs)
 
     def label(
@@ -446,12 +456,29 @@ class ControlTag(LabelStudioTag):
         Region
             A new Region object with the specified label applied.
         """
-        if hasattr(self, "_label_attr_name"):
+        if hasattr(self, "_label_attr_name") and label is not None:
             return self._label_with_labels(
                 label=label, to_name=to_name, *args, **kwargs
             )
         else:
             return self._label_simple(to_name=to_name, *args, **kwargs)
+        
+    def get_labels(self, regions: List[Dict]):
+        """
+        Returns the simplified representation of the label. Sort of a reverse to label() method to retrieve an input `label` from an output regions
+        """
+        values = [region.get('value') for region in regions if region.get('from_name') == self.name]
+        values = list(filter(lambda x: x is not None, values))
+        if not hasattr(self, "_label_attr_name"):
+            return values
+        labels = []
+        for value in values:
+            if len(value) == 1 and self._label_attr_name in value:
+                v = value[self._label_attr_name]
+                labels.append(v[0] if len(v) == 1 else v)
+            else:
+                labels.append(value)
+        return labels[0] if len(labels) == 1 else labels
 
     def as_tuple(self):
         """ """
@@ -485,6 +512,34 @@ class ChoicesTag(ControlTag):
     _label_attr_name: str = "choices"
     _value_class: Type[ChoicesValue] = ChoicesValue
 
+    @property
+    def is_multiple_choice(self):
+        return self.attr.get("choice") == "multiple"
+
+    def to_json_schema(self):
+        """
+        Converts the current ChoicesTag instance into a JSON Schema.
+
+        Returns:
+            dict: A dictionary representing the JSON Schema compatible with OpenAPI 3.
+        """
+        if self.is_multiple_choice:
+            return {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "enum": self.labels,
+                },
+                "uniqueItems": True,
+                "description": f"Choices for {self.to_name[0]}",
+            }
+
+        return {
+            "type": "string",
+            "enum": self.labels,
+            "description": f"Choices for {self.to_name[0]}"
+        }
+
 
 class LabelsValue(SpanSelection):
     labels: List[str]
@@ -496,6 +551,41 @@ class LabelsTag(ControlTag):
     _label_attr_name: str = "labels"
     _value_class: Type[LabelsValue] = LabelsValue
 
+    def to_json_schema(self):
+        """
+        Converts the current LabelsTag instance into a JSON Schema.
+
+        Returns:
+            dict: A dictionary representing the JSON Schema compatible with OpenAPI 3.
+        """
+        return {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["start", "end", "labels"],
+                "properties": {
+                    "start": {
+                        "type": "integer",
+                        "minimum": 0
+                    },
+                    "end": {
+                        "type": "integer",
+                        "minimum": 0
+                    },
+                    "labels": {
+                        "type": "array",
+                        "items": {
+                            "type": "string",
+                            "enum": self.labels
+                        }
+                    },
+                    "text": {
+                        "type": "string"
+                    }
+                }
+            },
+            "description": f"Labels and span indices for {self.to_name[0]}"
+        }
 
 ## Image tags
 
@@ -684,6 +774,26 @@ class NumberTag(ControlTag):
     """ """
     tag: str = "Number"
     _value_class: Type[NumberValue] = NumberValue
+    _label_attr_name: str = "number"
+
+    def to_json_schema(self):
+        """
+        Converts the current NumberTag instance into a JSON Schema.
+
+        Returns:
+            dict: A dictionary representing the JSON Schema compatible with OpenAPI 3.
+        """
+        schema = {
+            "type": "number",
+            "description": f"Number for {self.to_name[0]}"
+        }
+        
+        if 'min' in self.attr:
+            schema["minimum"] = float(self.attr['min'])
+        if 'max' in self.attr:
+            schema["maximum"] = float(self.attr['max'])
+        
+        return schema
     
 
 class DateTimeValue(BaseModel):
@@ -694,6 +804,25 @@ class DateTimeTag(ControlTag):
     """ """
     tag: str = "DateTime"
     _value_class: Type[DateTimeValue] = DateTimeValue
+    _label_attr_name: str = "datetime"
+
+    def _label_simple(self, to_name: Optional[str] = None, *args, **kwargs) -> Region:
+        # TODO: temporary fix to force datetime to be a string
+        kwargs['datetime'] = kwargs['datetime'][0]
+        return super()._label_simple(to_name, *args, **kwargs)
+
+    def to_json_schema(self):
+        """
+        Converts the current DateTimeTag instance into a JSON Schema.
+
+        Returns:
+            dict: A dictionary representing the JSON Schema compatible with OpenAPI 3.
+        """
+        return {
+            "type": "string",
+            "format": "date-time",
+            "description": f"Date and time for {self.to_name[0]}"
+        }
 
 
 class HyperTextLabelsValue(SpanSelectionOffsets):
@@ -715,12 +844,27 @@ class PairwiseTag(ControlTag):
     """ """
     tag: str = "Pairwise"
     _value_class: Type[PairwiseValue] = PairwiseValue
+    _label_attr_name: str = "selected"
 
-    def label(self, side):
+    def label(self, label):
         """ """
-        value = PairwiseValue(selected=side)
+        value = PairwiseValue(selected=label)
+        # <Pairwise> tag has equal from_name and to_name, and string label that's not a list of strings
         return Region(from_tag=self, to_tag=self, value=value)
 
+    def to_json_schema(self):
+        """
+        Converts the current PairwiseTag instance into a JSON Schema.
+
+        Returns:
+            dict: A dictionary representing the JSON Schema compatible with OpenAPI 3.
+        """
+        return {
+            "type": "string",
+            "enum": ["left", "right"],
+            "description": f"Pairwise selection between {self.to_name[0]} (left) and {self.to_name[1]} (right)"
+        }
+
 
 class ParagraphLabelsValue(SpanSelectionOffsets):
     paragraphlabels: List[str]
@@ -759,6 +903,22 @@ class RatingTag(ControlTag):
     """ """
     tag: str = "Rating"
     _value_class: Type[RatingValue] = RatingValue
+    _label_attr_name: str = "rating"
+
+    def to_json_schema(self):
+        """
+        Converts the current RatingTag instance into a JSON Schema.
+
+        Returns:
+            dict: A dictionary representing the JSON Schema compatible with OpenAPI 3.
+        """
+        max_rating = int(self.attr.get('maxRating', 5))  # Default to 5 if not specified
+        return {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": max_rating,
+            "description": f"Rating for {self.to_name[0]} (0 to {max_rating})"
+        }
 
 
 class RelationsTag(ControlTag):
@@ -784,6 +944,27 @@ class TaxonomyTag(ControlTag):
     """ """
     tag: str = "Taxonomy"
     _value_class: Type[TaxonomyValue] = TaxonomyValue
+    _label_attr_name: str = "taxonomy"
+
+    def to_json_schema(self):
+        """
+        Converts the current TaxonomyTag instance into a JSON Schema.
+
+        Returns:
+            dict: A dictionary representing the JSON Schema compatible with OpenAPI 3.
+        """
+        return {
+            "type": "array",
+            "items": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    # TODO: enforce the order of the enums according to the taxonomy tree
+                    "enum": self.labels
+                }
+            },
+            "description": f"Taxonomy for {self.to_name[0]}. Each item is a path from root to selected node."
+        }
 
 
 class TextAreaValue(BaseModel):
@@ -794,6 +975,20 @@ class TextAreaTag(ControlTag):
     """ """
     tag: str = "TextArea"
     _value_class: Type[TextAreaValue] = TextAreaValue
+    _label_attr_name: str = "text"
+
+    def to_json_schema(self):
+        """
+        Converts the current TextAreaTag instance into a JSON Schema.
+
+        Returns:
+            dict: A dictionary representing the JSON Schema compatible with OpenAPI 3.
+        """
+        return {
+            "type": "string",
+            "description": f"Text for {self.to_name[0]}"
+        }
+
 
 
 class TimeSeriesValue(SpanSelection):