label-studio-sdk 1.0.10__tar.gz → 1.0.12__tar.gz

{label_studio_sdk-1.0.10 → label_studio_sdk-1.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: label-studio-sdk
-Version: 1.0.10
+Version: 1.0.12
 Summary: 
 Requires-Python: >=3.9,<4
 Classifier: Intended Audience :: Developers
@@ -28,10 +28,11 @@ 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: pandas (>=0.24.0)
 Requires-Dist: pydantic (>=1.9.2)
 Requires-Dist: pydantic-core (>=2.18.2,<3.0.0)
+Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
 Requires-Dist: requests (>=2.22.0)
 Requires-Dist: requests-mock (==1.12.1)
 Requires-Dist: typing_extensions (>=4.0.0)

{label_studio_sdk-1.0.10 → label_studio_sdk-1.0.12}/pyproject.toml

@@ -3,7 +3,7 @@ name = "label-studio-sdk"
 
 [tool.poetry]
 name = "label-studio-sdk"
-version = "1.0.10"
+version = "1.0.12"
 description = ""
 readme = "README.md"
 authors = []
@@ -44,10 +44,11 @@ jsf = "^0.11.2"
 jsonschema = ">=4.23.0"
 lxml = ">=4.2.5"
 nltk = "^3.9.1"
-numpy = ">=1.26.4,<2.0.0"
+numpy = ">=1.26.4,<3.0.0"
 pandas = ">=0.24.0"
 pydantic = ">= 1.9.2"
 pydantic-core = "^2.18.2"
+pyjwt = "^2.10.1"
 requests = ">=2.22.0"
 requests-mock = "1.12.1"
 typing_extensions = ">= 4.0.0"
@@ -60,6 +61,7 @@ pytest = "^7.4.0"
 pytest-asyncio = "^0.23.5"
 python-dateutil = "^2.9.0"
 types-python-dateutil = "^2.9.0.20240316"
+respx = "^0.22.0"
 ruff = "^0.5.6"
 
 [tool.pytest.ini_options]

{label_studio_sdk-1.0.10 → label_studio_sdk-1.0.12}/src/label_studio_sdk/__init__.py

@@ -1,11 +1,14 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from .types import (
+    AccessTokenResponse,
     Annotation,
+    AnnotationCompletedBy,
     AnnotationFilterOptions,
     AnnotationLastAction,
     AnnotationsDmField,
     AnnotationsDmFieldLastAction,
+    ApiTokenResponse,
     AzureBlobExportStorage,
     AzureBlobExportStorageStatus,
     AzureBlobImportStorage,
@@ -40,6 +43,7 @@ from .types import (
     InferenceRunOrganization,
     InferenceRunProjectSubset,
     InferenceRunStatus,
+    JwtSettingsResponse,
     KeyIndicatorValue,
     KeyIndicators,
     KeyIndicatorsItem,
@@ -58,6 +62,8 @@ from .types import (
     ModelProviderConnectionOrganization,
     ModelProviderConnectionProvider,
     ModelProviderConnectionScope,
+    Pause,
+    PausePausedBy,
     Prediction,
     Project,
     ProjectImport,
@@ -80,6 +86,7 @@ from .types import (
     RedisImportStorageStatus,
     RefinedPromptResponse,
     RefinedPromptResponseRefinementStatus,
+    RotateTokenResponse,
     S3ExportStorage,
     S3ExportStorageStatus,
     S3ImportStorage,
@@ -101,7 +108,7 @@ from .types import (
     WebhookSerializerForUpdateActionsItem,
     Workspace,
 )
-from .errors import BadRequestError, InternalServerError
+from .errors import BadRequestError, InternalServerError, NotFoundError, UnauthorizedError
 from . import (
     actions,
     annotations,
@@ -109,12 +116,14 @@ from . import (
     export_storage,
     files,
     import_storage,
+    jwt_settings,
     ml,
     model_providers,
     predictions,
     projects,
     prompts,
     tasks,
+    tokens,
     users,
     versions,
     views,
@@ -180,6 +189,7 @@ from .views import (
 from .webhooks import WebhooksUpdateRequestActionsItem
 
 __all__ = [
+    "AccessTokenResponse",
     "ActionsCreateRequestFilters",
     "ActionsCreateRequestFiltersConjunction",
     "ActionsCreateRequestFiltersItemsItem",
@@ -192,12 +202,14 @@ __all__ = [
     "ActionsCreateRequestSelectedItemsExcluded",
     "ActionsCreateRequestSelectedItemsIncluded",
     "Annotation",
+    "AnnotationCompletedBy",
     "AnnotationFilterOptions",
     "AnnotationLastAction",
     "AnnotationsCreateBulkRequestSelectedItems",
     "AnnotationsCreateBulkResponseItem",
     "AnnotationsDmField",
     "AnnotationsDmFieldLastAction",
+    "ApiTokenResponse",
     "AsyncLabelStudio",
     "AzureBlobExportStorage",
     "AzureBlobExportStorageStatus",
@@ -238,6 +250,7 @@ __all__ = [
     "InferenceRunProjectSubset",
     "InferenceRunStatus",
     "InternalServerError",
+    "JwtSettingsResponse",
     "KeyIndicatorValue",
     "KeyIndicators",
     "KeyIndicatorsItem",
@@ -264,6 +277,9 @@ __all__ = [
     "ModelProviderConnectionOrganization",
     "ModelProviderConnectionProvider",
     "ModelProviderConnectionScope",
+    "NotFoundError",
+    "Pause",
+    "PausePausedBy",
     "Prediction",
     "Project",
     "ProjectImport",
@@ -294,6 +310,7 @@ __all__ = [
     "RedisImportStorageStatus",
     "RefinedPromptResponse",
     "RefinedPromptResponseRefinementStatus",
+    "RotateTokenResponse",
     "S3ExportStorage",
     "S3ExportStorageStatus",
     "S3ImportStorage",
@@ -309,6 +326,7 @@ __all__ = [
     "TaskFilterOptions",
     "TasksListRequestFields",
     "TasksListResponse",
+    "UnauthorizedError",
     "UserSimple",
     "UsersGetTokenResponse",
     "UsersResetTokenResponse",
@@ -344,12 +362,14 @@ __all__ = [
     "export_storage",
     "files",
     "import_storage",
+    "jwt_settings",
     "ml",
     "model_providers",
     "predictions",
     "projects",
     "prompts",
     "tasks",
+    "tokens",
     "users",
     "versions",
     "views",

{label_studio_sdk-1.0.10 → label_studio_sdk-1.0.12}/src/label_studio_sdk/_extensions/label_studio_tools/core/utils/json_schema.py

@@ -2,6 +2,7 @@ import json
 import types
 import sys
 import functools
+import logging
 from typing import Type, Dict, Any, Tuple, Generator
 from pathlib import Path
 from tempfile import TemporaryDirectory
@@ -11,6 +12,8 @@ from datamodel_code_generator.parser.jsonschema import JsonSchemaParser
 from pydantic import BaseModel
 from contextlib import contextmanager
 
+logger = logging.getLogger(__name__)
+
 
 @functools.lru_cache(maxsize=128)
 def _generate_model_code(json_schema_str: str, class_name: str = 'MyModel') -> str:
@@ -65,6 +68,7 @@ def json_schema_to_pydantic(json_schema: dict, class_name: str = 'MyModel') -> G
     json_schema_str = json.dumps(json_schema)
     
     # Generate Pydantic model code from the JSON schema string
+    logger.debug(f"Generating Pydantic model code from json schema: {json_schema_str}")
     model_code: str = _generate_model_code(json_schema_str, class_name)
     
     # Create a unique module name using the id of the JSON schema string
@@ -79,6 +83,7 @@ def json_schema_to_pydantic(json_schema: dict, class_name: str = 'MyModel') -> G
         # Add the new module to sys.modules to make it importable
         # This is necessary to avoid Pydantic errors related to undefined models
         sys.modules[module_name] = mod
+        logger.debug(f"Generated Pydantic model: {model_class}")
         yield model_class
     finally:
         if module_name in sys.modules:

{label_studio_sdk-1.0.10 → label_studio_sdk-1.0.12}/src/label_studio_sdk/base_client.py

@@ -23,6 +23,8 @@ from .prompts.client import PromptsClient
 from .model_providers.client import ModelProvidersClient
 from .comments.client import CommentsClient
 from .workspaces.client import WorkspacesClient
+from .tokens.client import TokensClient
+from .jwt_settings.client import JwtSettingsClient
 from .core.client_wrapper import AsyncClientWrapper
 from .annotations.client import AsyncAnnotationsClient
 from .users.client import AsyncUsersClient
@@ -41,6 +43,8 @@ from .prompts.client import AsyncPromptsClient
 from .model_providers.client import AsyncModelProvidersClient
 from .comments.client import AsyncCommentsClient
 from .workspaces.client import AsyncWorkspacesClient
+from .tokens.client import AsyncTokensClient
+from .jwt_settings.client import AsyncJwtSettingsClient
 
 
 class LabelStudioBase:
@@ -122,6 +126,8 @@ class LabelStudioBase:
         self.model_providers = ModelProvidersClient(client_wrapper=self._client_wrapper)
         self.comments = CommentsClient(client_wrapper=self._client_wrapper)
         self.workspaces = WorkspacesClient(client_wrapper=self._client_wrapper)
+        self.tokens = TokensClient(client_wrapper=self._client_wrapper)
+        self.jwt_settings = JwtSettingsClient(client_wrapper=self._client_wrapper)
 
 
 class AsyncLabelStudioBase:
@@ -203,6 +209,8 @@ class AsyncLabelStudioBase:
         self.model_providers = AsyncModelProvidersClient(client_wrapper=self._client_wrapper)
         self.comments = AsyncCommentsClient(client_wrapper=self._client_wrapper)
         self.workspaces = AsyncWorkspacesClient(client_wrapper=self._client_wrapper)
+        self.tokens = AsyncTokensClient(client_wrapper=self._client_wrapper)
+        self.jwt_settings = AsyncJwtSettingsClient(client_wrapper=self._client_wrapper)
 
 
 def _get_base_url(*, base_url: typing.Optional[str] = None, environment: LabelStudioEnvironment) -> str:

{label_studio_sdk-1.0.10 → label_studio_sdk-1.0.12}/src/label_studio_sdk/converter/converter.py

@@ -59,6 +59,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
@@ -167,6 +168,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"],
         },
     }
 
@@ -293,6 +301,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()
@@ -376,6 +397,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

label_studio_sdk-1.0.12/src/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-1.0.10 → label_studio_sdk-1.0.12}/src/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()