label-studio-sdk 1.0.7__tar.gz → 1.0.8__tar.gz

{label_studio_sdk-1.0.7 → label_studio_sdk-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: label-studio-sdk
-Version: 1.0.7
+Version: 1.0.8
 Summary: 
 Requires-Python: >=3.8,<4.0
 Classifier: Intended Audience :: Developers
@@ -21,8 +21,10 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Dist: Pillow (>=10.0.1)
 Requires-Dist: appdirs (>=1.4.3)
+Requires-Dist: datamodel-code-generator (==0.26.1)
 Requires-Dist: httpx (>=0.21.2)
 Requires-Dist: ijson (>=3.2.3)
+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)

{label_studio_sdk-1.0.7 → label_studio_sdk-1.0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "label-studio-sdk"
-version = "1.0.7"
+version = "1.0.8"
 description = ""
 readme = "README.md"
 authors = []
@@ -34,6 +34,7 @@ Repository = 'https://github.com/HumanSignal/label-studio-sdk'
 python = "^3.8"
 Pillow = ">=10.0.1"
 appdirs = ">=1.4.3"
+datamodel-code-generator = "0.26.1"
 httpx = ">=0.21.2"
 ijson = ">=3.2.3"
 jsonschema = ">=4.23.0"
@@ -48,6 +49,7 @@ typing_extensions = ">= 4.0.0"
 ujson = ">=5.8.0"
 xmljson = "0.2.1"
 
+jsf = "^0.11.2"
 [tool.poetry.dev-dependencies]
 mypy = "1.0.1"
 pytest = "^7.4.0"

{label_studio_sdk-1.0.7 → label_studio_sdk-1.0.8}/src/label_studio_sdk/__init__.py

@@ -35,6 +35,7 @@ from .types import (
     GcsImportStorage,
     GcsImportStorageStatus,
     InferenceRun,
+    InferenceRunCostEstimate,
     InferenceRunCreatedBy,
     InferenceRunOrganization,
     InferenceRunProjectSubset,
@@ -52,6 +53,7 @@ from .types import (
     MlBackendAuthMethod,
     MlBackendState,
     ModelProviderConnection,
+    ModelProviderConnectionBudgetResetPeriod,
     ModelProviderConnectionCreatedBy,
     ModelProviderConnectionOrganization,
     ModelProviderConnectionProvider,
@@ -87,6 +89,7 @@ from .types import (
     SerializationOptions,
     Task,
     TaskAnnotatorsItem,
+    TaskCommentAuthorsItem,
     TaskFilterOptions,
     UserSimple,
     View,
@@ -222,6 +225,7 @@ __all__ = [
     "GcsImportStorageStatus",
     "ImportStorageListTypesResponseItem",
     "InferenceRun",
+    "InferenceRunCostEstimate",
     "InferenceRunCreatedBy",
     "InferenceRunOrganization",
     "InferenceRunProjectSubset",
@@ -247,6 +251,7 @@ __all__ = [
     "MlUpdateResponse",
     "MlUpdateResponseAuthMethod",
     "ModelProviderConnection",
+    "ModelProviderConnectionBudgetResetPeriod",
     "ModelProviderConnectionCreatedBy",
     "ModelProviderConnectionOrganization",
     "ModelProviderConnectionProvider",
@@ -290,6 +295,7 @@ __all__ = [
     "SerializationOptions",
     "Task",
     "TaskAnnotatorsItem",
+    "TaskCommentAuthorsItem",
     "TaskFilterOptions",
     "TasksListRequestFields",
     "TasksListResponse",

{label_studio_sdk-1.0.7 → label_studio_sdk-1.0.8}/src/label_studio_sdk/_extensions/label_studio_tools/core/label_config.py

@@ -82,17 +82,26 @@ def parse_config(config_string):
         elif _is_input_tag(tag):
             inputs[tag.attrib["name"]] = {
                 "type": tag.tag,
-                "value": tag.attrib["value"].lstrip("$"),
                 "valueType": tag.attrib.get("valueType"),
             }
+            if 'value' in tag.attrib:
+                inputs[tag.attrib["name"]]["value"] = tag.attrib["value"].lstrip("$")
+            elif 'valueList' in tag.attrib:
+                inputs[tag.attrib["name"]]["valueList"] = tag.attrib["valueList"].lstrip("$")
+            else:
+                raise ValueError(
+                    'Inspecting tag {tag_name}... found no "value" or "valueList" attributes.'.format(
+                        tag_name=etree.tostring(tag, encoding="unicode").strip()[:50]
+                    )
+                )
         if tag.tag not in _LABEL_TAGS:
             continue
         parent_name = _get_parent_output_tag_name(tag, outputs)
         if parent_name is not None:
-            actual_value = tag.attrib.get("alias") or tag.attrib.get("value")
+            actual_value = tag.attrib.get("alias") or tag.attrib.get("value") or tag.attrib.get("valueList")
             if not actual_value:
                 logger.debug(
-                    'Inspecting tag {tag_name}... found no "value" or "alias" attributes.'.format(
+                    'Inspecting tag {tag_name}... found no "value", "valueList", or "alias" attributes.'.format(
                         tag_name=etree.tostring(tag, encoding="unicode").strip()[:50]
                     )
                 )
@@ -137,7 +146,7 @@ def _is_input_tag(tag):
     """
     Check if tag is input
     """
-    return tag.attrib.get("name") and tag.attrib.get("value")
+    return tag.attrib.get("name") and (tag.attrib.get("value") or tag.attrib.get("valueList"))
 
 
 def _is_output_tag(tag):

label_studio_sdk-1.0.8/src/label_studio_sdk/_extensions/label_studio_tools/core/utils/json_schema.py

@@ -0,0 +1,86 @@
+import json
+import types
+import sys
+import functools
+from typing import Type, Dict, Any, Tuple, Generator
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from datamodel_code_generator import DataModelType, PythonVersion, LiteralType
+from datamodel_code_generator.model import get_data_model_types
+from datamodel_code_generator.parser.jsonschema import JsonSchemaParser
+from pydantic import BaseModel
+from contextlib import contextmanager
+
+
+@functools.lru_cache(maxsize=128)
+def _generate_model_code(json_schema_str: str, class_name: str = 'MyModel') -> str:
+
+    data_model_types = get_data_model_types(
+        DataModelType.PydanticV2BaseModel,
+        target_python_version=PythonVersion.PY_311
+    )
+
+    parser = JsonSchemaParser(
+        json_schema_str,
+        data_model_type=data_model_types.data_model,
+        data_model_root_type=data_model_types.root_model,
+        data_model_field_type=data_model_types.field_model,
+        data_type_manager_type=data_model_types.data_type_manager,
+        dump_resolve_reference_action=data_model_types.dump_resolve_reference_action,
+        enum_field_as_literal=LiteralType.All,
+        class_name=class_name
+    )
+
+    model_code = parser.parse()
+    return model_code
+
+@contextmanager
+def json_schema_to_pydantic(json_schema: dict, class_name: str = 'MyModel') -> Generator[Type[BaseModel], None, None]:
+    """
+    Convert a JSON schema to a Pydantic model and provide it as a context manager.
+
+    Args:
+        json_schema (dict): The JSON schema to convert.
+        class_name (str, optional): The name of the generated Pydantic class. Defaults to 'MyModel'.
+
+    Example:
+        ```python
+        example_schema = {
+            "type": "object",
+            "properties": {
+                "sentiment": {
+                    "type": "string",
+                    "description": "Sentiment of the text",
+                    "enum": ["Positive", "Negative", "Neutral"],
+                }
+            },
+            "required": ["sentiment"]
+        }
+        with json_schema_to_pydantic(example_schema) as ResponseModel:
+            instance = ResponseModel(sentiment='Positive')
+            print(instance.model_dump())
+        ```
+    """
+    # Convert the JSON schema dictionary to a JSON string
+    json_schema_str = json.dumps(json_schema)
+    
+    # Generate Pydantic model code from the JSON schema string
+    model_code: str = _generate_model_code(json_schema_str, class_name)
+    
+    # Create a unique module name using the id of the JSON schema string
+    module_name = f'dynamic_module_{id(json_schema_str)}'
+    
+    # Create a new module object with the unique name and execute the generated model code in the context of the new module
+    mod = types.ModuleType(module_name)
+    exec(model_code, mod.__dict__)
+    model_class = getattr(mod, class_name)
+    
+    try:
+        # 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
+        yield model_class
+    finally:
+        if module_name in sys.modules:
+            del sys.modules[module_name]
+        

{label_studio_sdk-1.0.7 → label_studio_sdk-1.0.8}/src/label_studio_sdk/_legacy/schema/label_config_schema.json

@@ -35,22 +35,44 @@
         }
       }
     },
-    "tag_with_value_required_name": {
+    "tag_with_name_and_toname": {
       "type": "object",
-      "anyOf": [
-	{
-          "required": [
-            "@name",
-            "@valueList"
-          ]
-        },
+      "oneOf": [
         {
           "required": [
             "@name",
-            "@value"
+            "@toName"
           ]
         }
       ],
+      "properties": {
+        "@name": {
+          "$ref": "#/definitions/@name"
+        },
+        "@toName": {
+          "$ref": "#/definitions/@toName"
+        },
+        "$": {
+          "$ref": "#/definitions/$"
+        }
+      }
+    },
+    "tag_with_value_required_name": {
+      "type": "object",
+      "oneOf": [
+          {
+            "required": [
+                "@name",
+                "@value"
+            ]
+          },
+          {
+            "required": [
+                "@name",
+                "@valueList"
+            ]
+          }
+      ],
       "properties": {
         "@value": {
           "$ref": "#/definitions/@value"
@@ -80,6 +102,13 @@
         "items": {"$ref": "#/definitions/tag_with_value_required_name"}
       }, {"$ref": "#/definitions/tag_with_value_required_name"}]
     },
+    "tags_with_name_and_toname": {
+      "anyOf": [{"$ref": "#/definitions/tag_with_name_and_toname"},
+        {
+          "type": "array",
+          "items": {"$ref": "#/definitions/tag_with_name_and_toname"}
+        }]
+    },
     "View": {
       "type": "object",
       "additionalProperties": true,
@@ -92,7 +121,8 @@
         "Text": {"$ref": "#/definitions/tags_with_value_required_name"},
         "HyperText": {"$ref": "#/definitions/tags_with_value_required_name"},
         "View": {"$ref": "#/definitions/MaybeMultipleView"},
-        "TextArea": {"$ref": "#/definitions/MaybeMultipleTextAreas"}
+        "TextArea": {"$ref": "#/definitions/MaybeMultipleTextAreas"},
+        "Number": {"$ref": "#/definitions/tags_with_name_and_toname"}
       }
     },
     "MaybeMultipleView": {
@@ -219,7 +249,8 @@
         "Image": {"$ref": "#/definitions/tags_with_value_required_name"},
         "Text": {"$ref": "#/definitions/tags_with_value_required_name"},
         "HyperText": {"$ref": "#/definitions/tags_with_value_required_name"},
-        "TextArea": {"$ref": "#/definitions/MaybeMultipleTextAreas"}
+        "TextArea": {"$ref": "#/definitions/MaybeMultipleTextAreas"},
+        "Number": {"$ref": "#/definitions/tags_with_name_and_toname"}
       }
     }
   }

{label_studio_sdk-1.0.7 → label_studio_sdk-1.0.8}/src/label_studio_sdk/converter/converter.py

@@ -10,7 +10,6 @@ from copy import deepcopy
 from datetime import datetime
 from enum import Enum
 from glob import glob
-from operator import itemgetter
 from shutil import copy2
 from typing import Optional
 
@@ -282,12 +281,16 @@ class Converter(object):
         for name, info in self._schema.items():
             if output_tags is not None and name not in output_tags:
                 continue
-            data_keys |= set(map(itemgetter("value"), info["inputs"]))
+            for input_tag in info["inputs"]:
+                for value_key_name in ["value", "valueList"]:
+                    if value_key_name in input_tag:
+                        data_keys.add(input_tag[value_key_name])
             output_tag_names.append(name)
 
         return list(data_keys), output_tag_names
 
     def _get_supported_formats(self):
+        is_mig = False
         if len(self._data_keys) > 1:
             return [
                 Format.JSON.name,
@@ -300,6 +303,8 @@ class Converter(object):
         for info in self._schema.values():
             output_tag_types.add(info["type"])
             for input_tag in info["inputs"]:
+                if input_tag.get("valueList"):
+                    is_mig = True
                 if input_tag["type"] == "Text" and input_tag.get("valueType") == "url":
                     logger.error('valueType="url" are not supported for text inputs')
                     continue
@@ -308,7 +313,7 @@ class Converter(object):
         all_formats = [f.name for f in Format]
         if not ("Text" in input_tag_types and "Labels" in output_tag_types):
             all_formats.remove(Format.CONLL2003.name)
-        if not (
+        if is_mig or not (
             "Image" in input_tag_types
             and (
                 "RectangleLabels" in output_tag_types
@@ -317,7 +322,7 @@ class Converter(object):
             )
         ):
             all_formats.remove(Format.VOC.name)
-        if not (
+        if is_mig or not (
             "Image" in input_tag_types
             and (
                 "RectangleLabels" in output_tag_types
@@ -346,7 +351,7 @@ class Converter(object):
             and "TextArea" in output_tag_types
         ):
             all_formats.remove(Format.ASR_MANIFEST.name)
-        if 'Video' in input_tag_types and 'TimelineLabels' in output_tag_types:
+        if is_mig or ('Video' in input_tag_types and 'TimelineLabels' in output_tag_types):
             all_formats.remove(Format.YOLO_OBB.name)
 
         return all_formats

{label_studio_sdk-1.0.7 → label_studio_sdk-1.0.8}/src/label_studio_sdk/core/client_wrapper.py

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

{label_studio_sdk-1.0.7 → label_studio_sdk-1.0.8}/src/label_studio_sdk/label_interface/control_tags.py

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