label-studio-sdk 1.0.12__py3-none-any.whl → 1.0.14__py3-none-any.whl

label_studio_sdk/_extensions/label_studio_tools/core/utils/io.py

@@ -3,6 +3,7 @@ import io
 import logging
 import os
 import shutil
+import base64
 from contextlib import contextmanager
 from tempfile import mkdtemp
 from urllib.parse import urlparse
@@ -201,7 +202,7 @@ def download_and_cache(
 
     # local storage: /data/local-files?d=dir/1.jpg => 1.jpg
     if is_local_storage_file:
-        url_filename = os.path.basename(url.split('?d=')[1])
+        url_filename = os.path.basename(url.split("?d=")[1])
     # cloud storage: s3://bucket/1.jpg => 1.jpg
     elif is_cloud_storage_file:
         url_filename = os.path.basename(url)
@@ -213,7 +214,11 @@ def download_and_cache(
     filepath = os.path.join(cache_dir, url_hash + "__" + url_filename)
 
     if not os.path.exists(filepath):
-        logger.info("Download {url} to {filepath}. download_resources: {download_resources}".format(url=url, filepath=filepath, download_resources=download_resources))
+        logger.info(
+            "Download {url} to {filepath}. download_resources: {download_resources}".format(
+                url=url, filepath=filepath, download_resources=download_resources
+            )
+        )
         if download_resources:
             headers = {
                 # avoid requests.exceptions.HTTPError: 403 Client Error: Forbidden. Please comply with the User-Agent policy:
@@ -256,3 +261,123 @@ def get_all_files_from_dir(d):
         if os.path.isfile(filepath):
             out.append(filepath)
     return out
+
+
+def get_base64_content(
+    url,
+    hostname=None,
+    access_token=None,
+    task_id=None,
+):
+    """This helper function is used to download a file and return its base64 representation without saving to filesystem.
+
+    :param url: File URL to download, it can be a uploaded file, local storage, cloud storage file or just http(s) url
+    :param hostname: Label Studio Hostname, it will be used for uploaded files, local storage files and cloud storage files
+      if not provided, it will be taken from LABEL_STUDIO_URL env variable
+    :param access_token: Label Studio access token, it will be used for uploaded files, local storage files and cloud storage files
+      if not provided, it will be taken from LABEL_STUDIO_API_KEY env variable
+    :param task_id: Label Studio Task ID, required for cloud storage files
+      because the URL will be rebuilt to `{hostname}/tasks/{task_id}/presign/?fileuri={url}`
+
+    :return: base64 encoded file content
+    """
+    # get environment variables
+    hostname = (
+        hostname
+        or os.getenv("LABEL_STUDIO_URL", "")
+        or os.getenv("LABEL_STUDIO_HOST", "")
+    )
+    access_token = (
+        access_token
+        or os.getenv("LABEL_STUDIO_API_KEY", "")
+        or os.getenv("LABEL_STUDIO_ACCESS_TOKEN", "")
+    )
+    if "localhost" in hostname:
+        logger.warning(
+            f"Using `localhost` ({hostname}) in LABEL_STUDIO_URL, "
+            f"`localhost` is not accessible inside of docker containers. "
+            f"You can check your IP with utilities like `ifconfig` and set it as LABEL_STUDIO_URL."
+        )
+    if hostname and not (
+        hostname.startswith("http://") or hostname.startswith("https://")
+    ):
+        raise ValueError(
+            f"Invalid hostname in LABEL_STUDIO_URL: {hostname}. "
+            "Please provide full URL starting with protocol (http:// or https://)."
+        )
+
+    # fix file upload url
+    if url.startswith("upload") or url.startswith("/upload"):
+        url = "/data" + ("" if url.startswith("/") else "/") + url
+
+    is_uploaded_file = url.startswith("/data/upload")
+    is_local_storage_file = url.startswith("/data/") and "?d=" in url
+    is_cloud_storage_file = (
+        url.startswith("s3:") or url.startswith("gs:") or url.startswith("azure-blob:")
+    )
+
+    # Local storage file: try to load locally
+    if is_local_storage_file:
+        filepath = url.split("?d=")[1]
+        filepath = safe_build_path(LOCAL_FILES_DOCUMENT_ROOT, filepath)
+        if os.path.exists(filepath):
+            logger.debug(
+                f"Local Storage file path exists locally, read content directly: {filepath}"
+            )
+            with open(filepath, "rb") as f:
+                return base64.b64encode(f.read()).decode("utf-8")
+
+    # Upload or Local Storage file
+    if is_uploaded_file or is_local_storage_file or is_cloud_storage_file:
+        # hostname check
+        if not hostname:
+            raise FileNotFoundError(
+                f"Can't resolve url, hostname not provided: {url}. "
+                "You can set LABEL_STUDIO_URL environment variable to use it as a hostname."
+            )
+        # uploaded and local storage file
+        elif is_uploaded_file or is_local_storage_file:
+            url = concat_urls(hostname, url)
+            logger.info("Resolving url using hostname [" + hostname + "]: " + url)
+        # s3, gs, azure-blob file
+        elif is_cloud_storage_file:
+            if task_id is None:
+                raise Exception(
+                    "Label Studio Task ID is required for cloud storage files"
+                )
+            url = concat_urls(hostname, f"/tasks/{task_id}/presign/?fileuri={url}")
+            logger.info(
+                "Cloud storage file: Resolving url using hostname ["
+                + hostname
+                + "]: "
+                + url
+            )
+
+        # check access token
+        if not access_token:
+            raise FileNotFoundError(
+                "To access uploaded and local storage files you have to "
+                "set LABEL_STUDIO_API_KEY environment variable."
+            )
+
+    # Download the content but don't save to filesystem
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36"
+    }
+
+    # check if url matches hostname - then uses access token to this Label Studio instance
+    parsed_url = urlparse(url)
+    if access_token and hostname and parsed_url.netloc == urlparse(hostname).netloc:
+        headers["Authorization"] = "Token " + access_token
+        logger.debug("Authorization token is used for get_base64_content")
+
+    try:
+        r = requests.get(url, headers=headers, verify=VERIFY_SSL)
+        r.raise_for_status()
+        return base64.b64encode(r.content).decode("utf-8")
+    except requests.exceptions.SSLError as e:
+        logger.error(
+            f"SSL error during requests.get('{url}'): {e}\n"
+            f"Try to set VERIFY_SSL=False in environment variables to bypass SSL verification."
+        )
+        raise e

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__)
 
@@ -109,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",
@@ -128,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",
@@ -205,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
@@ -376,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)
@@ -522,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:
@@ -638,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)
@@ -703,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
@@ -775,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(
@@ -846,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)
@@ -923,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/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/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
 
         # even in the async case, refreshing access token (when the existing one is expired) should be sync
         from ..tokens.client_ext import TokensClientExt
-        self._tokens_client = TokensClientExt(base_url=base_url, api_key=api_key)
+        self._tokens_client = TokensClientExt(base_url=base_url, api_key=api_key, client_wrapper=self)
 
 
     def get_timeout(self) -> typing.Optional[float]:

label_studio_sdk/label_interface/interface.py

@@ -8,9 +8,11 @@ import re
 import json
 import jsonschema
 
+from functools import cached_property
 from typing import Dict, Optional, List, Tuple, Any, Callable, Union
 from pydantic import BaseModel
 
+
 # from typing import Dict, Optional, List, Tuple, Any
 from collections import defaultdict, OrderedDict
 from lxml import etree
@@ -517,6 +519,19 @@ class LabelInterface:
 
         return lst
     
+    @cached_property
+    def ner_tags(self):
+        return self.find_tags('controls', lambda t: t.tag.lower() in ('labels', 'hypertextlabels'))
+    
+    @cached_property
+    def image_tags(self):
+        return self.find_tags('objects', lambda t: t.tag.lower() == 'image')
+    
+    @cached_property
+    def pdf_tags(self):
+        return self.find_tags('objects', lambda t: t.tag.lower() == 'pdf')
+
+
     def load_task(self, task):
         """Loads a task and substitutes the value in each object tag
         with actual data from the task, returning a copy of the

label_studio_sdk/label_interface/object_tags.py

@@ -189,12 +189,17 @@ class AudioTag(ObjectTag):
 
 
 class ImageTag(ObjectTag):
-    """ """
+    """Image tag"""
     tag: str = "Image"
     
     def _generate_example(self, examples, only_urls=False):
         """ """
         return examples.get("Image")
+    
+    @property
+    def is_image_list(self):
+        """Check if the tag is an image list, i.e. it has a valueList attribute that accepts list of images"""
+        return bool(self.attr.get("valueList")) if self.attr else False
 
 
 class TableTag(ObjectTag):

label_studio_sdk/tokens/client_ext.py

@@ -1,6 +1,7 @@
 import threading
 import typing
 from datetime import datetime, timezone
+import inspect
 
 import httpx
 import jwt
@@ -12,9 +13,10 @@ from ..types.access_token_response import AccessTokenResponse
 class TokensClientExt:
     """Client for managing authentication tokens."""
 
-    def __init__(self, base_url: str, api_key: str):
+    def __init__(self, base_url: str, api_key: str, client_wrapper=None):
         self._base_url = base_url
         self._api_key = api_key
+        self._client_wrapper = client_wrapper
         self._use_legacy_token = not self._is_valid_jwt_token(api_key, raise_if_expired=True)
 
         # cache state for access token when using jwt-based api_key
@@ -78,9 +80,24 @@ class TokensClientExt:
 
     def refresh(self) -> AccessTokenResponse:
         """Refresh the access token and return the token response."""
-        # We don't do this often, just use a separate httpx client for simplicity here
+        # We don't do this often, just use a separate sync httpx client for simplicity here
         # (avoids complicated state management and sync vs async handling)
-        with httpx.Client() as sync_client:
+        # Create a new client with the same parameters as the existing one
+        existing_client = self._client_wrapper.httpx_client.httpx_client
+
+        # Get all parameters from httpx.Client.__init__
+        client_params = {}
+        sig = inspect.signature(httpx.Client.__init__)
+        for param_name in sig.parameters:
+            if param_name != 'self':  # Skip 'self' parameter
+                try:
+                    value = getattr(existing_client, param_name, None)
+                    if value is not None:
+                        client_params[param_name] = value
+                except AttributeError:
+                    continue
+
+        with httpx.Client(**client_params) as sync_client:
             response = sync_client.request(
                 method="POST",
                 url=f"{self._base_url}/api/token/refresh/",

{label_studio_sdk-1.0.12.dist-info → label_studio_sdk-1.0.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: label-studio-sdk
-Version: 1.0.12
+Version: 1.0.14
 Summary: 
 Requires-Python: >=3.9,<4
 Classifier: Intended Audience :: Developers
@@ -29,6 +29,7 @@ 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,<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.12.dist-info → label_studio_sdk-1.0.14.dist-info}/RECORD

@@ -6,7 +6,7 @@ label_studio_sdk/_extensions/label_studio_tools/core/__init__.py,sha256=47DEQpj8
 label_studio_sdk/_extensions/label_studio_tools/core/label_config.py,sha256=P1S7dPjFkqF2zIQzk11iljhharrUc9qQRM_rUN38iJQ,6406
 label_studio_sdk/_extensions/label_studio_tools/core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 label_studio_sdk/_extensions/label_studio_tools/core/utils/exceptions.py,sha256=JxaXUMghUp1YvL--s8KFC4mCHVbV39giE3kSBHCmuFU,66
-label_studio_sdk/_extensions/label_studio_tools/core/utils/io.py,sha256=FO0fBVvffuDjbQQcvqLsXmGUn1gCP1YmA-tmNsvX8oo,9650
+label_studio_sdk/_extensions/label_studio_tools/core/utils/io.py,sha256=NJHLJA8Q93_MLmo_Yx9F4_Z-kkWCZmF_Ahi3MtDQCPo,14800
 label_studio_sdk/_extensions/label_studio_tools/core/utils/json_schema.py,sha256=_Lg3DxhRqGhzlk3egGUDufx-iaoEWec19upZKp-Cwic,3378
 label_studio_sdk/_extensions/label_studio_tools/core/utils/params.py,sha256=ZSUb-IXG5OcPQ7pJ8NDRLon-cMxnjVq6XtinxvTuJso,1244
 label_studio_sdk/_extensions/label_studio_tools/etl/__init__.py,sha256=SdN7JGLJ1araqbx-nL2fVdhm6E6CNyru-vWVs6sMswI,31
@@ -50,11 +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=o90sU1oY7xE6Ni6O5qMkBUcT96QzqwVg9yd6zu-1gqw,51338
+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
@@ -62,11 +63,12 @@ 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/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
-label_studio_sdk/core/client_wrapper.py,sha256=fThAUV72_apQ4I2bS60iM84082lgXo4YMM6yvl07Kpg,2209
+label_studio_sdk/core/client_wrapper.py,sha256=lAGxJnIC7HMfysZS9sLHX1lnc82jw_n3eo_pTeljlFc,2230
 label_studio_sdk/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 label_studio_sdk/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 label_studio_sdk/core/http_client.py,sha256=siUQ6UV0ARZALlxubqWSSAAPC9B4VW8y6MGlHStfaeo,19552
@@ -155,9 +157,9 @@ label_studio_sdk/label_interface/base.py,sha256=NCgY7ntk0WSc9O9iXu3g37-CxbZgCx_W
 label_studio_sdk/label_interface/control_tags.py,sha256=qLe4gsRxvppuNtrxfmgZHFX1ahM-XhePlrchZfnJiL0,30141
 label_studio_sdk/label_interface/create.py,sha256=c3h5_FF4u5J62_mqq1oK2mjqXL-I1559C6MfoxkgO6s,6993
 label_studio_sdk/label_interface/data_examples.json,sha256=uCYvCtMIxPi1-jLlFhwJPh01tLyMIRwTjINeAeW-JzE,8195
-label_studio_sdk/label_interface/interface.py,sha256=U_2IkpQXxw8fBW_buwfWIOvgdk1z_xLHFdk8YPUC1eE,45519
+label_studio_sdk/label_interface/interface.py,sha256=nEC_RQJ9VCCtYRKqJ7AYhggbLqvTKvJkPIRTQeIm8vc,45959
 label_studio_sdk/label_interface/label_tags.py,sha256=nWEo21Gd8IPzIO72UqraLrChIbvrSMCA_eEhzYGnGCc,2282
-label_studio_sdk/label_interface/object_tags.py,sha256=EGe3bYTZr92SezzWka8grYnvOQNtyfEYa5-yoM4a7Es,8705
+label_studio_sdk/label_interface/object_tags.py,sha256=9k3DEYEh7aXSLh2JjH-SWNVupP1qgwHFte85Ix7-4dQ,8944
 label_studio_sdk/label_interface/objects.py,sha256=V1Spp0S9qE7iA-5kPCi0QyHrJ80Du9BUuYMsQUAQqc0,1535
 label_studio_sdk/label_interface/region.py,sha256=th39WeQk8ypi-4krEpsW0BZnoygu4XgvP4w7NkRQp2M,1755
 label_studio_sdk/ml/__init__.py,sha256=J4ncAcAOU_qriOx_Im9eFmXyupKM19SXMcpMcXSmw-I,455
@@ -213,7 +215,7 @@ label_studio_sdk/tasks/types/tasks_list_request_fields.py,sha256=5YXxQgyzoaL0QjS
 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=SvBcKXIsrTihMJC72Ifxv0U1N3gtLGz3JxqdXYA_hD4,19101
-label_studio_sdk/tokens/client_ext.py,sha256=chhzBuVYp0YeUrAnYVwDX5yJq5IJlomGhBQ1zvjZAkI,3976
+label_studio_sdk/tokens/client_ext.py,sha256=LHy29mBizrxVs_xOVMiIJwNsQKcOjS8V8LWfWMdAdYU,4730
 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=AnHm2VjMasWZsaNXVSUzLYbpYrmM4NPZgWQh7WGa6ZQ,3157
@@ -362,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.12.dist-info/LICENSE,sha256=ymVrFcHiJGjHeY30NWZgdV-xzNEtfuC63oK9ZeMDjhs,11341
-label_studio_sdk-1.0.12.dist-info/METADATA,sha256=Wn4jvmJgSE1RkJyMXNV0RjrjMcmzk33Mn7jN_2STUWE,5987
-label_studio_sdk-1.0.12.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-label_studio_sdk-1.0.12.dist-info/RECORD,,
+label_studio_sdk-1.0.14.dist-info/LICENSE,sha256=ymVrFcHiJGjHeY30NWZgdV-xzNEtfuC63oK9ZeMDjhs,11341
+label_studio_sdk-1.0.14.dist-info/METADATA,sha256=v1D-HsVQxvhu1dESF077Nr-mtaIylYb1KQx6pOxoqww,6033
+label_studio_sdk-1.0.14.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+label_studio_sdk-1.0.14.dist-info/RECORD,,