label-studio-sdk 1.0.11__py3-none-any.whl → 1.0.13__py3-none-any.whl

label_studio_sdk/__init__.py

@@ -3,6 +3,7 @@
 from .types import (
     AccessTokenResponse,
     Annotation,
+    AnnotationCompletedBy,
     AnnotationFilterOptions,
     AnnotationLastAction,
     AnnotationsDmField,
@@ -85,6 +86,7 @@ from .types import (
     RedisImportStorageStatus,
     RefinedPromptResponse,
     RefinedPromptResponseRefinementStatus,
+    RotateTokenResponse,
     S3ExportStorage,
     S3ExportStorageStatus,
     S3ImportStorage,
@@ -200,6 +202,7 @@ __all__ = [
     "ActionsCreateRequestSelectedItemsExcluded",
     "ActionsCreateRequestSelectedItemsIncluded",
     "Annotation",
+    "AnnotationCompletedBy",
     "AnnotationFilterOptions",
     "AnnotationLastAction",
     "AnnotationsCreateBulkRequestSelectedItems",
@@ -307,6 +310,7 @@ __all__ = [
     "RedisImportStorageStatus",
     "RefinedPromptResponse",
     "RefinedPromptResponseRefinementStatus",
+    "RotateTokenResponse",
     "S3ExportStorage",
     "S3ExportStorageStatus",
     "S3ImportStorage",

label_studio_sdk/converter/converter.py

@@ -11,13 +11,14 @@ from datetime import datetime
 from enum import Enum
 from glob import glob
 from shutil import copy2
-from typing import Optional
+from typing import Optional, List, Tuple
 
 import ijson
 import ujson as json
 from PIL import Image
 from label_studio_sdk.converter import brush
 from label_studio_sdk.converter.audio import convert_to_asr_json_manifest
+from label_studio_sdk.converter.keypoints import process_keypoints_for_coco, build_kp_order, update_categories_for_keypoints, keypoints_in_label_config, get_yolo_categories_for_keypoints
 from label_studio_sdk.converter.exports import csv2
 from label_studio_sdk.converter.utils import (
     parse_config,
@@ -34,6 +35,7 @@ from label_studio_sdk.converter.utils import (
     convert_annotation_to_yolo_obb,
 )
 from label_studio_sdk._extensions.label_studio_tools.core.utils.io import get_local_path
+from label_studio_sdk.converter.exports.yolo import process_and_save_yolo_annotations
 
 logger = logging.getLogger(__name__)
 
@@ -59,6 +61,7 @@ class Format(Enum):
     YOLO_WITH_IMAGES = 14
     COCO_WITH_IMAGES = 15
     YOLO_OBB_WITH_IMAGES = 16
+    BRUSH_TO_COCO = 17 
 
     def __str__(self):
         return self.name
@@ -108,13 +111,13 @@ class Converter(object):
             "description": "Popular machine learning format used by the COCO dataset for object detection and image "
             "segmentation tasks with polygons and rectangles.",
             "link": "https://labelstud.io/guide/export.html#COCO",
-            "tags": ["image segmentation", "object detection"],
+            "tags": ["image segmentation", "object detection", "keypoints"],
         },
         Format.COCO_WITH_IMAGES: {
             "title": "COCO with Images",
             "description": "COCO format with images downloaded.",
             "link": "https://labelstud.io/guide/export.html#COCO",
-            "tags": ["image segmentation", "object detection"],
+            "tags": ["image segmentation", "object detection", "keypoints"],
         },
         Format.VOC: {
             "title": "Pascal VOC XML",
@@ -127,13 +130,13 @@ class Converter(object):
             "description": "Popular TXT format is created for each image file. Each txt file contains annotations for "
             "the corresponding image file, that is object class, object coordinates, height & width.",
             "link": "https://labelstud.io/guide/export.html#YOLO",
-            "tags": ["image segmentation", "object detection"],
+            "tags": ["image segmentation", "object detection", "keypoints"],
         },
         Format.YOLO_WITH_IMAGES: {
             "title": "YOLO with Images",
             "description": "YOLO format with images downloaded.",
             "link": "https://labelstud.io/guide/export.html#YOLO",
-            "tags": ["image segmentation", "object detection"],
+            "tags": ["image segmentation", "object detection", "keypoints"],
         },
         Format.YOLO_OBB: {
             "title": "YOLOv8 OBB",
@@ -167,6 +170,13 @@ class Converter(object):
             "format expected by NVIDIA NeMo models.",
             "link": "https://labelstud.io/guide/export.html#ASR-MANIFEST",
             "tags": ["speech recognition"],
+        },   
+        Format.BRUSH_TO_COCO: {
+
+            "title": "Brush labels to COCO",
+            "description": "Export your brush labels as COCO format for segmentation tasks. Converts RLE encoded masks to COCO polygons.",
+            "link": "https://labelstud.io/guide/export.html#COCO",
+            "tags": ["image segmentation", "brush annotations"],
         },
     }
 
@@ -197,6 +207,7 @@ class Converter(object):
         self._schema = None
         self.access_token = access_token
         self.hostname = hostname
+        self.is_keypoints = None
 
         if isinstance(config, dict):
             self._schema = config
@@ -293,6 +304,19 @@ class Converter(object):
                 upload_dir=self.upload_dir,
                 download_resources=self.download_resources,
             )
+        elif format == Format.BRUSH_TO_COCO:
+            items = (
+                self.iter_from_dir(input_data)
+                if is_dir
+                else self.iter_from_json_file(input_data)
+            )
+            from label_studio_sdk.converter.exports.brush_to_coco import convert_to_coco
+            image_dir = kwargs.get("image_dir")
+            convert_to_coco(
+                items, 
+                output_data, 
+                output_image_dir=image_dir
+            )
 
     def _get_data_keys_and_output_tags(self, output_tags=None):
         data_keys = set()
@@ -355,11 +379,14 @@ class Converter(object):
             and (
                 "RectangleLabels" in output_tag_types
                 or "PolygonLabels" in output_tag_types
+                or "KeyPointLabels" in output_tag_types
             )
             or "Rectangle" in output_tag_types
             and "Labels" in output_tag_types
             or "PolygonLabels" in output_tag_types
             and "Labels" in output_tag_types
+            or "KeyPointLabels" in output_tag_types
+            and "Labels" in output_tag_types
         ):
             all_formats.remove(Format.COCO.name)
             all_formats.remove(Format.COCO_WITH_IMAGES.name)
@@ -376,6 +403,7 @@ class Converter(object):
         ):
             all_formats.remove(Format.BRUSH_TO_NUMPY.name)
             all_formats.remove(Format.BRUSH_TO_PNG.name)
+            all_formats.remove(Format.BRUSH_TO_COCO.name) 
         if not (
             ("Audio" in input_tag_types or "AudioPlus" in input_tag_types)
             and "TextArea" in output_tag_types
@@ -500,6 +528,9 @@ class Converter(object):
                     if "original_height" in r:
                         v["original_height"] = r["original_height"]
                     outputs[r["from_name"]].append(v)
+                    if self.is_keypoints:
+                        v['id'] = r.get('id')
+                        v['parentID'] = r.get('parentID')
 
             data = Converter.get_data(task, outputs, annotation)
             if "agreement" in task:
@@ -616,6 +647,7 @@ class Converter(object):
             os.makedirs(output_image_dir, exist_ok=True)
         images, categories, annotations = [], [], []
         categories, category_name_to_id = self._get_labels()
+        categories, category_name_to_id = update_categories_for_keypoints(categories, category_name_to_id, self._schema)
         data_key = self._data_keys[0]
         item_iterator = (
             self.iter_from_dir(input_data)
@@ -681,9 +713,10 @@ class Converter(object):
                 logger.debug(f'Empty bboxes for {item["output"]}')
                 continue
 
+            keypoint_labels = []
             for label in labels:
                 category_name = None
-                for key in ["rectanglelabels", "polygonlabels", "labels"]:
+                for key in ["rectanglelabels", "polygonlabels", "keypointlabels", "labels"]:
                     if key in label and len(label[key]) > 0:
                         category_name = label[key][0]
                         break
@@ -753,11 +786,22 @@ class Converter(object):
                             "area": get_polygon_area(x, y),
                         }
                     )
+                elif "keypointlabels" in label:
+                    keypoint_labels.append(label)
                 else:
                     raise ValueError("Unknown label type")
 
                 if os.getenv("LABEL_STUDIO_FORCE_ANNOTATOR_EXPORT"):
                     annotations[-1].update({"annotator": get_annotator(item)})
+            if keypoint_labels:
+                kp_order = build_kp_order(self._schema)
+                annotations.append(process_keypoints_for_coco(
+                    keypoint_labels,
+                    kp_order,
+                    annotation_id=len(annotations),
+                    image_id=image_id,
+                    category_name_to_id=category_name_to_id,
+                ))
 
         with io.open(output_file, mode="w", encoding="utf8") as fout:
             json.dump(
@@ -824,7 +868,14 @@ class Converter(object):
         else:
             output_label_dir = os.path.join(output_dir, "labels")
             os.makedirs(output_label_dir, exist_ok=True)
-        categories, category_name_to_id = self._get_labels()
+        is_keypoints = keypoints_in_label_config(self._schema)
+
+        if is_keypoints:
+            # we use this attribute to add id and parentID to annotation data
+            self.is_keypoints = True
+            categories, category_name_to_id = get_yolo_categories_for_keypoints(self._schema)
+        else:
+            categories, category_name_to_id = self._get_labels()
         data_key = self._data_keys[0]
         item_iterator = (
             self.iter_from_dir(input_data)
@@ -901,82 +952,7 @@ class Converter(object):
                         pass
                 continue
 
-            annotations = []
-            for label in labels:
-                category_name = None
-                category_names = []  # considering multi-label
-                for key in ["rectanglelabels", "polygonlabels", "labels"]:
-                    if key in label and len(label[key]) > 0:
-                        # change to save multi-label
-                        for category_name in label[key]:
-                            category_names.append(category_name)
-
-                if len(category_names) == 0:
-                    logger.debug(
-                        "Unknown label type or labels are empty: " + str(label)
-                    )
-                    continue
-
-                for category_name in category_names:
-                    if category_name not in category_name_to_id:
-                        category_id = len(categories)
-                        category_name_to_id[category_name] = category_id
-                        categories.append({"id": category_id, "name": category_name})
-                    category_id = category_name_to_id[category_name]
-
-                    if (
-                        "rectanglelabels" in label
-                        or "rectangle" in label
-                        or "labels" in label
-                    ):
-                        # yolo obb
-                        if is_obb:
-                            obb_annotation = convert_annotation_to_yolo_obb(label)
-                            if obb_annotation is None:
-                                continue
-
-                            top_left, top_right, bottom_right, bottom_left = (
-                                obb_annotation
-                            )
-                            x1, y1 = top_left
-                            x2, y2 = top_right
-                            x3, y3 = bottom_right
-                            x4, y4 = bottom_left
-                            annotations.append(
-                                [category_id, x1, y1, x2, y2, x3, y3, x4, y4]
-                            )
-
-                        # simple yolo
-                        else:
-                            annotation = convert_annotation_to_yolo(label)
-                            if annotation is None:
-                                continue
-
-                            (
-                                x,
-                                y,
-                                w,
-                                h,
-                            ) = annotation
-                            annotations.append([category_id, x, y, w, h])
-
-                    elif "polygonlabels" in label or "polygon" in label:
-                        if not ('points' in label):
-                            continue
-                        points_abs = [(x / 100, y / 100) for x, y in label["points"]]
-                        annotations.append(
-                            [category_id]
-                            + [coord for point in points_abs for coord in point]
-                        )
-                    else:
-                        raise ValueError(f"Unknown label type {label}")
-            with open(label_path, "w") as f:
-                for annotation in annotations:
-                    for idx, l in enumerate(annotation):
-                        if idx == len(annotation) - 1:
-                            f.write(f"{l}\n")
-                        else:
-                            f.write(f"{l} ")
+            categories, category_name_to_id = process_and_save_yolo_annotations(labels, label_path, category_name_to_id, categories, is_obb, is_keypoints, self._schema)
         with open(class_file, "w", encoding="utf8") as f:
             for c in categories:
                 f.write(c["name"] + "\n")

label_studio_sdk/converter/exports/brush_to_coco.py

@@ -0,0 +1,332 @@
+"""
+Convert brush annotations and polygon annotations to COCO format.
+This module handles RLE encoded brush masks and converts them to COCO segmentation format.
+"""
+import logging
+import random
+import io
+import os
+import json
+import numpy as np
+import cv2
+from copy import deepcopy
+from datetime import datetime
+
+from label_studio_sdk.converter.utils import ensure_dir, get_annotator
+import label_studio_sdk.converter.brush as brush_module
+
+logger = logging.getLogger(__name__)
+
+
+def generate_random_color():
+    """Generates a random hex color for category visualization"""
+    return '#{:02x}{:02x}{:02x}'.format(random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+
+
+def flatten(item):
+    """Flatten nested lists for segmentation format"""
+    if isinstance(item, list):
+        for subitem in item:
+            yield from flatten(subitem)
+    else:
+        yield item
+
+
+def generate_contour_from_rle(rle, original_width, original_height):
+    """Convert RLE encoded masks to COCO segmentation format
+    
+    Args:
+        rle: RLE encoded mask data
+        original_width: Width of the original image
+        original_height: Height of the original image
+        
+    Returns:
+        tuple: (segmentation, bbox_list, area_list) in COCO format
+    """
+    # Ensure rle is bytes, not string
+    if isinstance(rle, str):
+        rle = rle.encode('utf-8')
+        
+    # Decode RLE
+    try:
+        rle_binary = brush_module.decode_rle(rle)
+    except Exception as e:
+        logger.warning(f"Failed to decode RLE: {e}")
+        return [], [], []
+    
+    # Reshape to image dimensions with 4 channels (RGBA)
+    try:
+        reshaped_image = np.reshape(rle_binary, [original_height, original_width, 4])
+    except Exception as e:
+        logger.warning(f"Failed to reshape RLE data: {e}")
+        return [], [], []
+    
+    # Use only the alpha channel for contour detection
+    alpha_channel = np.array(reshaped_image[:, :, 3]).astype('uint8')
+    
+    # Find contours
+    contours, _ = cv2.findContours(
+        alpha_channel, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+    )
+
+    segmentation = []
+    bbox_list = []
+    area_list = []
+    for contour in contours:
+        # OpenCV contours are in format [[[x1,y1]], [[x2,y2]], ...], 
+        # we need to convert to a flat list [x1,y1,x2,y2,...]
+        contour_points = [point[0] for point in contour]
+        
+        # Flatten to a single list
+        contour_flat = []
+        for point in contour_points:
+            contour_flat.extend(point.tolist())
+        
+        # Check if we have at least 3 points (6 coordinates) for a valid polygon
+        if len(contour_points) >= 3:
+            segmentation.append(contour_flat)
+
+            x, y, w, h = cv2.boundingRect(contour)
+            bbox_list.append([x, y, w, h])   # Format: [top-left x, top-left y, width, height]
+
+            # Compute the area of the contour
+            area = cv2.contourArea(contour)
+            area_list.append(int(area))
+
+    return segmentation, bbox_list, area_list
+
+
+def generate_contour_from_polygon(points, original_width, original_height):
+    """Convert polygon annotations to COCO segmentation format
+    
+    Args:
+        points: List of [x, y] points in percentage format
+        original_width: Width of the original image
+        original_height: Height of the original image
+        
+    Returns:
+        tuple: (segmentation, bbox, area) in COCO format
+    """
+    # Convert from percentage to absolute coordinates
+    modified_points = [
+        [round(x * original_width / 100), round(y * original_height / 100)]
+        for x, y in points
+    ]
+
+    # Initialize lists
+    segmentation = [list(flatten(modified_points))]
+
+    # Convert points to a NumPy array and reshape for OpenCV
+    contour = np.array(modified_points, dtype=np.float32).reshape((-1, 1, 2))
+
+    # Calculate bounding box
+    bbox = cv2.boundingRect(contour)
+    bbox = [int(coordinate) for coordinate in bbox]
+
+    # Compute the area of the contour
+    area = cv2.contourArea(contour)
+
+    return segmentation, bbox, int(area)
+
+
+def convert_to_coco(items, output_dir, output_image_dir=None):
+    """Convert Label Studio annotations to COCO format
+
+    Args:
+        items: Iterable of annotation items
+        output_dir: Directory where to save the resulting COCO JSON
+        output_image_dir: Optional directory for images
+
+    Returns:
+        Path to the generated COCO JSON file
+    """
+    ensure_dir(output_dir)
+    output_file = os.path.join(output_dir, "result_coco.json")
+    
+    if output_image_dir is not None:
+        ensure_dir(output_image_dir)
+    else:
+        output_image_dir = os.path.join(output_dir, "images")
+        os.makedirs(output_image_dir, exist_ok=True)
+
+    # Initialize COCO JSON structure
+    coco_data = {
+        'images': [],
+        'annotations': [],
+        'categories': [],
+        'info': {
+            'year': datetime.now().year,
+            'version': '1.0',
+            'description': 'Converted from Label Studio',
+            'contributor': 'Label Studio Converter',
+            'date_created': str(datetime.now()),
+        }
+    }
+
+    category_map = {}  # To track unique categories
+    annotation_id = 0
+
+    # Process each item
+    for image_id, item in enumerate(items):
+        # Extract image information
+        image_path = None
+        for key, value in item['input'].items():
+            if isinstance(value, str) and any(value.lower().endswith(ext) for ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp']):
+                image_path = value
+                break
+        
+        if not image_path:
+            logger.warning(f"No image path found for item {item.get('id')}. Skipping.")
+            continue
+
+        image_info = {
+            'id': image_id,
+            'file_name': os.path.basename(image_path),
+            'path': image_path,
+            'width': None,  # Will be filled from annotations
+            'height': None  # Will be filled from annotations
+        }
+
+        # Skip tasks without annotations
+        if not item['output']:
+            logger.warning(f"No annotations found for item {item.get('id')}")
+            continue
+
+        valid_annotations = False
+
+        # Process all annotations
+        for output_key, annotations in item['output'].items():
+            for annotation in annotations:
+                # Get image dimensions from the first annotation
+                if image_info['width'] is None and 'original_width' in annotation:
+                    image_info['width'] = annotation['original_width']
+                    image_info['height'] = annotation['original_height']
+                
+                # Identify annotation type and extract labels
+                annotation_type = annotation.get('type', '').lower()
+                labels = []
+                
+                if 'brushlabels' in annotation:
+                    labels = annotation['brushlabels']
+                    type_key = 'brushlabels'
+                elif 'polygonlabels' in annotation:
+                    labels = annotation['polygonlabels']
+                    type_key = 'polygonlabels'
+                elif 'rectanglelabels' in annotation:
+                    labels = annotation['rectanglelabels']
+                    type_key = 'rectanglelabels'
+                elif 'labels' in annotation:
+                    labels = annotation['labels']
+                    type_key = 'labels'
+                else:
+                    logger.debug(f"Unsupported annotation type: {annotation_type}")
+                    continue
+                
+                # Process each label
+                for label in labels:
+                    # Add new categories to the map
+                    if label not in category_map:
+                        category_id = len(category_map) + 1
+                        category_map[label] = category_id
+                        coco_data['categories'].append({
+                            'id': category_id,
+                            'name': label,
+                            'supercategory': '',
+                            'color': generate_random_color(),
+                            'metadata': {}
+                        })
+                    
+                    category_id = category_map[label]
+                    
+                    # Convert annotation based on type
+                    if 'rle' in annotation and type_key == 'brushlabels':
+
+                        # check required keys exist
+                        if not all(k in annotation for k in ['rle', 'original_width', 'original_height']):
+                            logger.warning(f"Missing required keys for RLE annotation. Skipping.")
+                            continue
+
+                        # Process brush annotation (RLE encoded mask)
+                        segmentations, bboxes, areas = generate_contour_from_rle(
+                            annotation['rle'], 
+                            annotation['original_width'], 
+                            annotation['original_height']
+                        )
+                        
+                        # Create separate annotation for each contour
+                        for i, (segmentation, bbox, area) in enumerate(zip(segmentations, bboxes, areas)):
+                            coco_annotation = {
+                                'id': annotation_id,
+                                'image_id': image_id,
+                                'category_id': category_id,
+                                'segmentation': [segmentation],  # COCO format requires double nesting
+                                'area': area,
+                                'bbox': bbox,
+                                'iscrowd': 0,
+                                'annotator': get_annotator(item, "unknown")
+                            }
+                            coco_data['annotations'].append(coco_annotation)
+                            annotation_id += 1
+                            valid_annotations = True
+                    
+                    elif 'points' in annotation and type_key == 'polygonlabels':
+                        # check required keys exist
+                        if not all(k in annotation for k in ['points', 'original_width', 'original_height']):
+                            logger.warning(f"Missing required keys for polygon annotation. Skipping.")
+                            continue
+                        # Process polygon annotation
+                        segmentation, bbox, area = generate_contour_from_polygon(
+                            annotation['points'], 
+                            annotation['original_width'], 
+                            annotation['original_height']
+                        )
+                        
+                        coco_annotation = {
+                            'id': annotation_id,
+                            'image_id': image_id,
+                            'category_id': category_id,
+                            'segmentation': segmentation,
+                            'area': area,
+                            'bbox': bbox,
+                            'iscrowd': 0,
+                            'annotator': get_annotator(item, "unknown")
+                        }
+                        coco_data['annotations'].append(coco_annotation)
+                        annotation_id += 1
+                        valid_annotations = True
+                    
+                    elif annotation_type == 'rectanglelabels' or type_key == 'labels':
+                        # check required keys exist
+                        if not all(k in annotation for k in ['x', 'y', 'width', 'height', 'original_width', 'original_height']):
+                            logger.warning(f"Missing required keys for rectangle annotation. Skipping.")
+                            continue
+
+                        # Convert from percentage to absolute coordinates
+                        x = annotation['x'] * annotation['original_width'] / 100
+                        y = annotation['y'] * annotation['original_height'] / 100
+                        w = annotation['width'] * annotation['original_width'] / 100
+                        h = annotation['height'] * annotation['original_height'] / 100
+                        
+                        coco_annotation = {
+                            'id': annotation_id,
+                            'image_id': image_id,
+                            'category_id': category_id,
+                            'segmentation': [],  # Empty for bounding boxes
+                            'area': w * h,
+                            'bbox': [x, y, w, h],
+                            'iscrowd': 0,
+                            'annotator': get_annotator(item, "unknown")
+                        }
+                        coco_data['annotations'].append(coco_annotation)
+                        annotation_id += 1
+                        valid_annotations = True
+        
+        # Add image to the dataset if it has valid dimensions
+        if image_info['width'] is not None and image_info['height'] is not None and valid_annotations:
+            coco_data['images'].append(image_info)
+
+    # Write COCO JSON to file
+    with io.open(output_file, 'w', encoding='utf8') as f:
+        json.dump(coco_data, f, indent=2, ensure_ascii=False)
+    
+    return output_file

label_studio_sdk/converter/exports/yolo.py

@@ -0,0 +1,149 @@
+import logging
+from label_studio_sdk.converter.utils import convert_annotation_to_yolo, convert_annotation_to_yolo_obb
+from label_studio_sdk.converter.keypoints import build_kp_order
+
+logger = logging.getLogger(__name__)
+
+def process_keypoints_for_yolo(labels, label_path,
+                               category_name_to_id, categories,
+                               is_obb, kp_order):
+    class_map = {c['name']: c['id'] for c in categories}
+
+    rectangles = {}
+    for item in labels:
+        if item['type'].lower() == 'rectanglelabels':
+            bbox_id = item['id']
+            cls_name = item['rectanglelabels'][0]
+            cls_idx = class_map.get(cls_name)
+            if cls_idx is None:
+                continue
+
+            x      = item['x'] / 100.0
+            y      = item['y'] / 100.0
+            width  = item['width']  / 100.0
+            height = item['height'] / 100.0
+            x_c    = x + width  / 2.0
+            y_c    = y + height / 2.0
+
+            rectangles[bbox_id] = {
+                'class_idx': cls_idx,
+                'x_center':  x_c,
+                'y_center':  y_c,
+                'width':     width,
+                'height':    height,
+                'kp_dict':   {}
+            }
+
+    for item in labels:
+        if item['type'].lower() == 'keypointlabels':
+            parent_id = item.get('parentID')
+            if parent_id not in rectangles:
+                continue
+            label_name = item['keypointlabels'][0]
+            kp_x = item['x'] / 100.0
+            kp_y = item['y'] / 100.0
+            rectangles[parent_id]['kp_dict'][label_name] = (kp_x, kp_y, 2)  # 2 = visible
+
+    lines = []
+    for rect in rectangles.values():
+        base = [
+            rect['class_idx'],
+            rect['x_center'],
+            rect['y_center'],
+            rect['width'],
+            rect['height']
+        ]
+        keypoints = []
+        for k in kp_order:
+            keypoints.extend(rect['kp_dict'].get(k, (0.0, 0.0, 0)))
+        line = ' '.join(map(str, base + keypoints))
+        lines.append(line)
+
+    with open(label_path, 'w', encoding='utf-8') as f:
+        f.write('\n'.join(lines))
+
+
+def process_and_save_yolo_annotations(labels, label_path, category_name_to_id, categories, is_obb, is_keypoints, label_config):
+    if is_keypoints:
+        kp_order = build_kp_order(label_config)
+        process_keypoints_for_yolo(labels, label_path, category_name_to_id, categories, is_obb, kp_order)
+        return categories, category_name_to_id
+
+    annotations = []
+    for label in labels:
+        category_name = None
+        category_names = []  # considering multi-label
+        for key in ["rectanglelabels", "polygonlabels", "labels"]:
+            if key in label and len(label[key]) > 0:
+                # change to save multi-label
+                for category_name in label[key]:
+                    category_names.append(category_name)
+
+        if len(category_names) == 0:
+            logger.debug(
+                "Unknown label type or labels are empty: " + str(label)
+            )
+            continue
+
+        for category_name in category_names:
+            if category_name not in category_name_to_id:
+                category_id = len(categories)
+                category_name_to_id[category_name] = category_id
+                categories.append({"id": category_id, "name": category_name})
+            category_id = category_name_to_id[category_name]
+
+            if (
+                "rectanglelabels" in label
+                or "rectangle" in label
+                or "labels" in label
+            ):
+                # yolo obb
+                if is_obb:
+                    obb_annotation = convert_annotation_to_yolo_obb(label)
+                    if obb_annotation is None:
+                        continue
+
+                    top_left, top_right, bottom_right, bottom_left = (
+                        obb_annotation
+                    )
+                    x1, y1 = top_left
+                    x2, y2 = top_right
+                    x3, y3 = bottom_right
+                    x4, y4 = bottom_left
+                    annotations.append(
+                        [category_id, x1, y1, x2, y2, x3, y3, x4, y4]
+                    )
+
+                # simple yolo
+                else:
+                    annotation = convert_annotation_to_yolo(label)
+                    if annotation is None:
+                        continue
+
+                    (
+                        x,
+                        y,
+                        w,
+                        h,
+                    ) = annotation
+                    annotations.append([category_id, x, y, w, h])
+
+            elif "polygonlabels" in label or "polygon" in label:
+                if not ('points' in label):
+                    continue
+                points_abs = [(x / 100, y / 100) for x, y in label["points"]]
+                annotations.append(
+                    [category_id]
+                    + [coord for point in points_abs for coord in point]
+                )
+            else:
+                raise ValueError(f"Unknown label type {label}")
+    with open(label_path, "w") as f:
+        for annotation in annotations:
+            for idx, l in enumerate(annotation):
+                if idx == len(annotation) - 1:
+                    f.write(f"{l}\n")
+                else:
+                    f.write(f"{l} ")
+
+    return categories, category_name_to_id

label_studio_sdk/converter/keypoints.py

@@ -0,0 +1,146 @@
+import os
+import json
+
+
+def keypoints_in_label_config(label_config):
+    """
+    Check if the label config contains keypoints.
+    :param label_config: Label config in JSON format.
+    :return: True if keypoints are present, False otherwise.
+    """
+    for cfg in label_config.values():
+        if cfg.get("type") == "KeyPointLabels":
+            return True
+    return False
+
+
+def update_categories_for_keypoints(categories, category_name_to_id, label_config):
+    keypoint_labels = []
+    for cfg in label_config.values():
+        if cfg.get("type") == "KeyPointLabels":
+            keypoint_labels.extend(cfg.get("labels", []))
+    keypoint_labels = list(dict.fromkeys(keypoint_labels))
+
+    non_kp = [cat.copy() for cat in categories if cat["name"] not in keypoint_labels]
+
+    new_categories = []
+    new_mapping = {}
+    next_id = 0
+    for cat in non_kp:
+        cat["id"] = next_id
+        new_categories.append(cat)
+        new_mapping[cat["name"]] = next_id
+        next_id += 1
+
+    if keypoint_labels:
+        merged_id = next_id
+        merged_category = {
+            "id": merged_id,
+            "name": "default",
+            "supercategory": "default",
+            "keypoints": keypoint_labels,
+            "skeleton": []
+        }
+        new_categories.append(merged_category)
+        for kp_name in keypoint_labels:
+            new_mapping[kp_name] = merged_id
+
+    return new_categories, new_mapping
+
+
+def build_kp_order(label_config):
+    kp_block = {}
+
+    for tag in label_config.values():
+        if tag.get("type") == "KeyPointLabels":
+            kp_block.update(tag.get("labels_attrs", {}))
+
+    pairs, used = [], set()
+
+    for name, attrs in kp_block.items():
+        try:
+            idx = int(attrs.get("model_index"))
+        except (TypeError, ValueError):
+            continue
+        if idx in used:
+            continue
+        pairs.append((idx, name))
+        used.add(idx)
+
+    pairs.sort(key=lambda p: p[0])
+    result = [name for _, name in pairs]
+    return result
+
+
+def get_bbox_coco(keypoints, kp_order):
+    xs = [keypoints[3*i] for i in range(len(kp_order)) if keypoints[3*i + 2] > 0]
+    ys = [keypoints[3*i + 1] for i in range(len(kp_order)) if keypoints[3*i + 2] > 0]
+    if xs and ys:
+        x_min = min(xs)
+        y_min = min(ys)
+        x_max = max(xs)
+        y_max = max(ys)
+        width = x_max - x_min
+        height = y_max - y_min
+        bbox = [x_min, y_min, width, height]
+    else:
+        bbox = [0, 0, 0, 0]
+    return bbox
+
+
+def process_keypoints_for_coco(keypoint_labels, kp_order, annotation_id, image_id, category_name_to_id):
+    keypoints = [0] * (len(kp_order) * 3)
+
+    for kp in keypoint_labels:
+        width, height = kp["original_width"], kp["original_height"]
+        x, y = kp['x'] / 100 * width, kp['y'] / 100 * height
+        labels = kp.get('keypointlabels', [])
+        v = 2 if labels else 0
+        for label in labels:
+            if label in kp_order:
+                idx = kp_order.index(label)
+                keypoints[3 * idx] = int(round(x))
+                keypoints[3 * idx + 1] = int(round(y))
+                keypoints[3 * idx + 2] = v
+
+    num_keypoints = sum(1 for i in range(len(kp_order)) if keypoints[3*i + 2] > 0)
+
+    bbox = get_bbox_coco(keypoints, kp_order)
+
+    category_id = category_name_to_id.get(kp_order[0], 0)
+    annotation = {
+        'id': annotation_id,
+        'image_id': image_id,
+        'category_id': category_id,
+        'keypoints': keypoints,
+        'num_keypoints': num_keypoints,
+        'bbox': bbox,
+        'iscrowd': 0
+    }
+    return annotation
+
+
+def get_yolo_categories_for_keypoints(label_config):
+    # Get all keypoint labels from the label config
+    keypoint_labels = []
+    for cfg in label_config.values():
+        if cfg.get("type") == "KeyPointLabels":
+            keypoint_labels.extend(cfg.get("labels", []))
+    keypoint_labels = list(dict.fromkeys(keypoint_labels))  # Remove duplicates
+
+    # Get all rectangle labels from the label config
+    rectangle_labels = []
+    for cfg in label_config.values():
+        if cfg.get("type") == "RectangleLabels":
+            rectangle_labels.extend(cfg.get("labels", []))
+    rectangle_labels = list(dict.fromkeys(rectangle_labels))  # Remove duplicates
+
+    # Create categories for each rectangle label
+    categories = []
+    category_name_to_id = {}
+
+    for i, label in enumerate(rectangle_labels):
+        categories.append({"id": i, "name": label, "keypoints": keypoint_labels})
+        category_name_to_id[label] = i
+
+    return categories, category_name_to_id

label_studio_sdk/converter/main.py

@@ -79,6 +79,12 @@ def get_export_args(parser):
         default=True,
         help="Set this flag if your annotations are in one JSON file instead of multiple JSON files from directory",
     )
+    parser.add_argument(
+        "--brush-to-coco",
+        dest="brush_to_coco",
+        action="store_true",
+        help="If set, brush annotations will be converted to COCO format"
+    )
 
 
 def get_all_args():
@@ -158,6 +164,14 @@ def export(args):
         c.convert_to_yolo(
             args.input, args.output, is_dir=not args.heartex_format, is_obb=True
         )
+    elif args.format == Format.BRUSH_TO_COCO:
+        c.convert(
+            args.input,
+            args.output,
+            Format.BRUSH_TO_COCO,
+            output_image_dir=args.image_dir,
+            is_dir=not args.heartex_format,
+        )
     else:
         raise FormatNotSupportedError()
 

label_studio_sdk/jwt_settings/client.py

@@ -19,7 +19,7 @@ class JwtSettingsClient:
 
     def get(self, *, request_options: typing.Optional[RequestOptions] = None) -> JwtSettingsResponse:
         """
-        Retrieve JWT settings for the currently active organization.
+        Retrieve JWT settings for the currently-active organization.
 
         Parameters
         ----------
@@ -134,7 +134,7 @@ class AsyncJwtSettingsClient:
 
     async def get(self, *, request_options: typing.Optional[RequestOptions] = None) -> JwtSettingsResponse:
         """
-        Retrieve JWT settings for the currently active organization.
+        Retrieve JWT settings for the currently-active organization.
 
         Parameters
         ----------

label_studio_sdk/tokens/client.py

@@ -10,6 +10,8 @@ from ..core.api_error import ApiError
 from ..types.api_token_response import ApiTokenResponse
 from ..types.access_token_response import AccessTokenResponse
 from ..errors.unauthorized_error import UnauthorizedError
+from ..types.rotate_token_response import RotateTokenResponse
+from ..errors.bad_request_error import BadRequestError
 from ..core.client_wrapper import AsyncClientWrapper
 
 # this is used as the default value for optional parameters
@@ -225,6 +227,70 @@ class TokensClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
+    def rotate(self, *, refresh: str, request_options: typing.Optional[RequestOptions] = None) -> RotateTokenResponse:
+        """
+        Blacklist existing refresh token, and get a new refresh token.
+
+        Parameters
+        ----------
+        refresh : str
+            JWT refresh token
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        RotateTokenResponse
+            Refresh token successfully rotated
+
+        Examples
+        --------
+        from label_studio_sdk import LabelStudio
+
+        client = LabelStudio(
+            api_key="YOUR_API_KEY",
+        )
+        client.tokens.rotate(
+            refresh="refresh",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "api/token/rotate",
+            method="POST",
+            json={
+                "refresh": refresh,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    RotateTokenResponse,
+                    parse_obj_as(
+                        type_=RotateTokenResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
 
 class AsyncTokensClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -468,3 +534,77 @@ class AsyncTokensClient:
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def rotate(
+        self, *, refresh: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> RotateTokenResponse:
+        """
+        Blacklist existing refresh token, and get a new refresh token.
+
+        Parameters
+        ----------
+        refresh : str
+            JWT refresh token
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        RotateTokenResponse
+            Refresh token successfully rotated
+
+        Examples
+        --------
+        import asyncio
+
+        from label_studio_sdk import AsyncLabelStudio
+
+        client = AsyncLabelStudio(
+            api_key="YOUR_API_KEY",
+        )
+
+
+        async def main() -> None:
+            await client.tokens.rotate(
+                refresh="refresh",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "api/token/rotate",
+            method="POST",
+            json={
+                "refresh": refresh,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    RotateTokenResponse,
+                    parse_obj_as(
+                        type_=RotateTokenResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)

label_studio_sdk/types/__init__.py

@@ -2,6 +2,7 @@
 
 from .access_token_response import AccessTokenResponse
 from .annotation import Annotation
+from .annotation_completed_by import AnnotationCompletedBy
 from .annotation_filter_options import AnnotationFilterOptions
 from .annotation_last_action import AnnotationLastAction
 from .annotations_dm_field import AnnotationsDmField
@@ -84,6 +85,7 @@ from .redis_import_storage import RedisImportStorage
 from .redis_import_storage_status import RedisImportStorageStatus
 from .refined_prompt_response import RefinedPromptResponse
 from .refined_prompt_response_refinement_status import RefinedPromptResponseRefinementStatus
+from .rotate_token_response import RotateTokenResponse
 from .s3export_storage import S3ExportStorage
 from .s3export_storage_status import S3ExportStorageStatus
 from .s3import_storage import S3ImportStorage
@@ -108,6 +110,7 @@ from .workspace import Workspace
 __all__ = [
     "AccessTokenResponse",
     "Annotation",
+    "AnnotationCompletedBy",
     "AnnotationFilterOptions",
     "AnnotationLastAction",
     "AnnotationsDmField",
@@ -190,6 +193,7 @@ __all__ = [
     "RedisImportStorageStatus",
     "RefinedPromptResponse",
     "RefinedPromptResponseRefinementStatus",
+    "RotateTokenResponse",
     "S3ExportStorage",
     "S3ExportStorageStatus",
     "S3ImportStorage",

label_studio_sdk/types/annotation.py

@@ -3,6 +3,7 @@
 from ..core.pydantic_utilities import UniversalBaseModel
 import typing
 import pydantic
+from .annotation_completed_by import AnnotationCompletedBy
 import datetime as dt
 from .annotation_last_action import AnnotationLastAction
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
@@ -25,7 +26,7 @@ class Annotation(UniversalBaseModel):
     Time delta from creation time
     """
 
-    completed_by: typing.Optional[int] = None
+    completed_by: typing.Optional[AnnotationCompletedBy] = None
     unique_id: typing.Optional[str] = None
     was_cancelled: typing.Optional[bool] = pydantic.Field(default=None)
     """

label_studio_sdk/types/annotation_completed_by.py

@@ -0,0 +1,6 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .user_simple import UserSimple
+
+AnnotationCompletedBy = typing.Union[UserSimple, int]

label_studio_sdk/types/rotate_token_response.py

@@ -0,0 +1,22 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+
+
+class RotateTokenResponse(UniversalBaseModel):
+    refresh: str = pydantic.Field()
+    """
+    New JWT refresh token
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

{label_studio_sdk-1.0.11.dist-info → label_studio_sdk-1.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: label-studio-sdk
-Version: 1.0.11
+Version: 1.0.13
 Summary: 
 Requires-Python: >=3.9,<4
 Classifier: Intended Audience :: Developers
@@ -28,7 +28,8 @@ Requires-Dist: jsf (>=0.11.2,<0.12.0)
 Requires-Dist: jsonschema (>=4.23.0)
 Requires-Dist: lxml (>=4.2.5)
 Requires-Dist: nltk (>=3.9.1,<4.0.0)
-Requires-Dist: numpy (>=1.26.4,<2.0.0)
+Requires-Dist: numpy (>=1.26.4,<3.0.0)
+Requires-Dist: opencv-python (>=4.9.0,<5.0.0)
 Requires-Dist: pandas (>=0.24.0)
 Requires-Dist: pydantic (>=1.9.2)
 Requires-Dist: pydantic-core (>=2.18.2,<3.0.0)

{label_studio_sdk-1.0.11.dist-info → label_studio_sdk-1.0.13.dist-info}/RECORD

@@ -1,4 +1,4 @@
-label_studio_sdk/__init__.py,sha256=qFFiMpqu4V-mUCD290rXW5oLBu8qL0A0RiRVWg4QKPw,10945
+label_studio_sdk/__init__.py,sha256=_-HHT-pw6BSHqpL65CAaZLsirX14w9UxghASGcecRU8,11053
 label_studio_sdk/_extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 label_studio_sdk/_extensions/eval/categorical.py,sha256=MxH2Jl8Mc6HS2byBnlRgABZgwMutSQdH3tgspwCkxqk,2703
 label_studio_sdk/_extensions/label_studio_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -50,10 +50,12 @@ label_studio_sdk/comments/client.py,sha256=k359u7Q8YyPtaawoA1FW4dAuYzGVmeGM9rR2G
 label_studio_sdk/converter/__init__.py,sha256=qppSJed16HAiZbGons0yVrPRjszuWFia025Rm477q1c,201
 label_studio_sdk/converter/audio.py,sha256=U9oTULkeimodZhIkB16Gl3eJD8YzsbADWxW_r2tPcxw,1905
 label_studio_sdk/converter/brush.py,sha256=jRL3fLl_J06fVEX7Uat31ru0uUZ71C4zrXnX2qOcrIo,13370
-label_studio_sdk/converter/converter.py,sha256=l2BgDUNyfSDmU0g8jpxjLFTl00qoJ4_fxPFPUGJUk_s,50403
+label_studio_sdk/converter/converter.py,sha256=Fx3IZpTRLe1_rHPwPYHYeaWsHnK2QJ7RnXpjyabI68Y,49731
 label_studio_sdk/converter/exports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+label_studio_sdk/converter/exports/brush_to_coco.py,sha256=YeVSyZxmXwLbqox7dS3IRuzR1mYTlUhg6YgK4Txq00U,13355
 label_studio_sdk/converter/exports/csv.py,sha256=F4t04tFsg5gBXTZNmkjw_NeEVsobRH_Y_vfFDi7R0Zw,2865
 label_studio_sdk/converter/exports/csv2.py,sha256=9FxcPtIDcuztDF-y4Z7Mm0AgbYUR1oMitYT6BlcOFes,3125
+label_studio_sdk/converter/exports/yolo.py,sha256=0g57qBFDnTEIMJF8oD-vaPYJbtQeecJB74yWISt5EXo,5419
 label_studio_sdk/converter/funsd.py,sha256=QHoa8hzWQLkZQ87e9EgURit9kGGUCgDxoRONcSzmWlw,2544
 label_studio_sdk/converter/imports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 label_studio_sdk/converter/imports/coco.py,sha256=FDUij8i329XRs3RFZEo-hKWseieyfE7vbQUtHYHpQs8,10312
@@ -61,7 +63,8 @@ label_studio_sdk/converter/imports/colors.py,sha256=F5_K4FIhOZl6LNEIVT2UU5L8HcmY
 label_studio_sdk/converter/imports/label_config.py,sha256=8RT2Jppvi1-Sl3ZNDA1uFyHr2NoU4-gM26S9iAEuQh8,1218
 label_studio_sdk/converter/imports/pathtrack.py,sha256=Xxxbw8fLLHTR57FEjVeeitjh35YbcIh_eVzuw2e5K9w,8096
 label_studio_sdk/converter/imports/yolo.py,sha256=kAJhsUV4ZxOEJE8yk7CvMGf_3w6aslqrj7OUOqHIwbo,8888
-label_studio_sdk/converter/main.py,sha256=tB1HbxV_prR67tEjk-YLk4pLJ5isxQAsyChxaktEIaQ,6004
+label_studio_sdk/converter/keypoints.py,sha256=KACb3W4aoiM3GBvXehooFS2SqUD82zsLMAXpZgioNyw,4561
+label_studio_sdk/converter/main.py,sha256=gfe5zPV2dnIk4ifG1AT95ExkzOSLzje0EOjnW0oC3q8,6442
 label_studio_sdk/converter/utils.py,sha256=VshPBwZLu2VPIGVsShKAkZwB_zKz0VvMkNRCwWeEqWg,18702
 label_studio_sdk/core/__init__.py,sha256=-t9txgeQZL_1FDw_08GEoj4ft1Cn9Dti6X0Drsadlr0,1519
 label_studio_sdk/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
@@ -148,7 +151,7 @@ label_studio_sdk/import_storage/s3s/client.py,sha256=iqJJ8d-DZ35lj8KKKsR6emA1cix
 label_studio_sdk/import_storage/types/__init__.py,sha256=LSPRtCZ04H1CRzFC6KQnse2KDh5Weeo9IPmRoluhvoc,203
 label_studio_sdk/import_storage/types/import_storage_list_types_response_item.py,sha256=jfoSmhutkqNO9vGtz6Soku6wQ8UA9-cmfiYwGSoaj10,642
 label_studio_sdk/jwt_settings/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
-label_studio_sdk/jwt_settings/client.py,sha256=X8bbRLbbQicaklvgvxZTqXqwcAjpzf3ywP81dMFD7-o,8161
+label_studio_sdk/jwt_settings/client.py,sha256=v7e5oxvMBcpkh_JF7A3qeg-AlZlHMS82pmiMM_RKj7k,8161
 label_studio_sdk/label_interface/__init__.py,sha256=Eg6y3mAaYdKzJ5ZPhU_BTX2qoNPafthdxLD2I_rmXoU,38
 label_studio_sdk/label_interface/base.py,sha256=NCgY7ntk0WSc9O9iXu3g37-CxbZgCx_WO2pvOEHK-cg,2786
 label_studio_sdk/label_interface/control_tags.py,sha256=qLe4gsRxvppuNtrxfmgZHFX1ahM-XhePlrchZfnJiL0,30141
@@ -211,11 +214,12 @@ label_studio_sdk/tasks/types/__init__.py,sha256=F5n2075irgvO9TyLAXzp26Tybg_lxMC5
 label_studio_sdk/tasks/types/tasks_list_request_fields.py,sha256=5YXxQgyzoaL0QjSE-aLs_fepCUuzj28iqUndh5NxGGg,166
 label_studio_sdk/tasks/types/tasks_list_response.py,sha256=j1pNluAWQOQ8-d9YXQyRQAefnrl8uLQEB7_L55Z8DME,1136
 label_studio_sdk/tokens/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
-label_studio_sdk/tokens/client.py,sha256=BFoj9BY6APX12WujEGHtvMFbpQ_NYnQ5HGwxpM5l_kg,14662
+label_studio_sdk/tokens/client.py,sha256=SvBcKXIsrTihMJC72Ifxv0U1N3gtLGz3JxqdXYA_hD4,19101
 label_studio_sdk/tokens/client_ext.py,sha256=chhzBuVYp0YeUrAnYVwDX5yJq5IJlomGhBQ1zvjZAkI,3976
-label_studio_sdk/types/__init__.py,sha256=5rtRvvxxS1gkkJZ9cNr1L12ln2No4H334rFATLS9VUs,8735
+label_studio_sdk/types/__init__.py,sha256=fQykjzHpX04ftslk5I_hWSJQ_H9Kd8XJAmSv18EVOIc,8905
 label_studio_sdk/types/access_token_response.py,sha256=RV9FqkIiFR_9kmKueB-KiqjVyneiqUkMVueAlk5fUyc,624
-label_studio_sdk/types/annotation.py,sha256=8f9poNV7xJrsGKJrsmLTemLY-11L9J7-yIYEPA-qe-Y,3080
+label_studio_sdk/types/annotation.py,sha256=AnHm2VjMasWZsaNXVSUzLYbpYrmM4NPZgWQh7WGa6ZQ,3157
+label_studio_sdk/types/annotation_completed_by.py,sha256=0JTdVQqtgsRhVLoYnA02vq2aUWsg1AWG4wfVKUd9-iw,170
 label_studio_sdk/types/annotation_filter_options.py,sha256=84D7v0l8Gmn2sGyWh-3uQZy-mHc4qDWuwDTxqeou73E,929
 label_studio_sdk/types/annotation_last_action.py,sha256=g1CU8ypFyneqqf_eWtNH-lC6Q_h1i_IporC-Fq6nkxs,392
 label_studio_sdk/types/annotations_dm_field.py,sha256=v9wLW5vsM-j1-fvKVTBrfgqzhMAfM8O8HaoHbU39c6o,3245
@@ -298,6 +302,7 @@ label_studio_sdk/types/redis_import_storage.py,sha256=00CCOr8BS3luBBZjJx6buJbpjM
 label_studio_sdk/types/redis_import_storage_status.py,sha256=KmGl0_RWK20owkGdLZ2Tx19v7fZrSSBDhN-SScYh5hM,217
 label_studio_sdk/types/refined_prompt_response.py,sha256=CTFWlzKKisUroQfeLsawgFuuy-Njzm5hTyUxOJr0i90,1559
 label_studio_sdk/types/refined_prompt_response_refinement_status.py,sha256=k2VmjpYtv4E19KV0pjcgUmC_UEn3TOWUI0S3MbllaG4,215
+label_studio_sdk/types/rotate_token_response.py,sha256=ZoHAfsN50MDLDiED75-So_wzPWLamUKkNXnqkuhjsBY,626
 label_studio_sdk/types/s3export_storage.py,sha256=TDHfvEljtCfuXBuMTc-gERvXcM6TIuIuy4QMWhjFCvg,3323
 label_studio_sdk/types/s3export_storage_status.py,sha256=HYCH0ZH90Oi-_1WgOo6d19rFm5JJ9M7tn5tVPL71P70,214
 label_studio_sdk/types/s3import_storage.py,sha256=2mLWZ0DlLPREqyH2OF0F1bExFmUzbDGan7UB4wDlPzg,3500
@@ -359,7 +364,7 @@ label_studio_sdk/workspaces/members/client.py,sha256=IVM52Yq_9zMQ3TUHT0AkZ5BTQ9a
 label_studio_sdk/workspaces/members/types/__init__.py,sha256=ZIa_rd7d6K9ZITjTU6fptyGgvjNDySksJ7Rbn4wyhD4,252
 label_studio_sdk/workspaces/members/types/members_create_response.py,sha256=7Hp5FSWm4xR5ZOEmEIglq5HYtM9KWZZBDp87jw7jYFg,668
 label_studio_sdk/workspaces/members/types/members_list_response_item.py,sha256=DIc5DJoVahI9olBis_iFgOJrAf05m2fCE8g4R5ZeDko,712
-label_studio_sdk-1.0.11.dist-info/LICENSE,sha256=ymVrFcHiJGjHeY30NWZgdV-xzNEtfuC63oK9ZeMDjhs,11341
-label_studio_sdk-1.0.11.dist-info/METADATA,sha256=lXJG4DPfXqNKy_ZcdQT9i2WnRqN4xL7bpkgNAfg7Cy4,5987
-label_studio_sdk-1.0.11.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-label_studio_sdk-1.0.11.dist-info/RECORD,,
+label_studio_sdk-1.0.13.dist-info/LICENSE,sha256=ymVrFcHiJGjHeY30NWZgdV-xzNEtfuC63oK9ZeMDjhs,11341
+label_studio_sdk-1.0.13.dist-info/METADATA,sha256=-1jBn5dwOCPtA4yi0RN5kq7HY373qPlf5dSWNP1r7YU,6033
+label_studio_sdk-1.0.13.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+label_studio_sdk-1.0.13.dist-info/RECORD,,

{label_studio_sdk-1.0.11.dist-info → label_studio_sdk-1.0.13.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.1
+Generator: poetry-core 2.1.2
 Root-Is-Purelib: true
 Tag: py3-none-any