label-studio-sdk 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

label_studio_sdk/label_interface/base.py

@@ -24,8 +24,8 @@ class LabelStudioTag(BaseModel):
         The tag name
     """
 
-    attr: Optional[Dict]
-    tag: Optional[str]
+    attr: Optional[Dict] = {}
+    tag: Optional[str] = ""
 
     def match(
         self,

label_studio_sdk/label_interface/control_tags.py

@@ -145,6 +145,14 @@ class ControlTag(LabelStudioTag):
 
         return tag_class(**tag_info)
 
+    def collect_attrs(self):
+        """Return tag attrs as a single dict"""
+        return {
+            **self.attr,
+            "name": self.name,
+            "toName": self.to_name
+        }
+    
     def get_object(self, name=None):
         """
         This method retrieves the object tag that the control tag maps to.
@@ -473,7 +481,7 @@ class ChoicesValue(BaseModel):
 
 class ChoicesTag(ControlTag):
     """ """
-
+    tag: str = "Choices"
     _label_attr_name: str = "choices"
     _value_class: Type[ChoicesValue] = ChoicesValue
 
@@ -484,7 +492,7 @@ class LabelsValue(SpanSelection):
 
 class LabelsTag(ControlTag):
     """ """
-
+    tag: str = "Labels"
     _label_attr_name: str = "labels"
     _value_class: Type[LabelsValue] = LabelsValue
 
@@ -534,7 +542,7 @@ class BrushLabelsValue(BrushValue):
 
 class BrushTag(ControlTag):
     """ """
-
+    tag: str = "Brush"
     _value_class: Type[BrushValue] = BrushValue
 
     # def validate_value(self, value) -> bool:
@@ -546,7 +554,7 @@ class BrushTag(ControlTag):
 
 class BrushLabelsTag(BrushTag):
     """ """
-
+    tag: str = "BrushLabels"
     _label_attr_name: str = "brushlabels"
     _value_class: Type[BrushLabelsValue] = BrushLabelsValue
 
@@ -565,13 +573,13 @@ class EllipseLabelsValue(EllipseValue):
 
 class EllipseTag(ControlTag):
     """ """
-
+    tag: str = "Ellipse"
     _value_class: Type[EllipseValue] = EllipseValue
 
 
 class EllipseLabelsTag(ControlTag):
     """ """
-
+    tag: str = "EllipseLabels"
     _label_attr_name: str = "ellipselabels"
     _value_class: Type[EllipseLabelsValue] = EllipseLabelsValue
 
@@ -587,13 +595,13 @@ class KeyPointLabelsValue(KeyPointValue):
 
 class KeyPointTag(ControlTag):
     """ """
-
+    tag: str = "KeyPoint"
     _value_class: Type[KeyPointValue] = KeyPointValue
 
 
 class KeyPointLabelsTag(ControlTag):
     """ """
-
+    tag: str = "KeyPointLabels"
     _label_attr_name: str = "keypointlabels"
     _value_class: Type[KeyPointLabelsValue] = KeyPointLabelsValue
 
@@ -608,13 +616,13 @@ class PolygonLabelsValue(PolygonValue):
 
 class PolygonTag(ControlTag):
     """ """
-
+    tag: str = "Polygon"
     _value_class: Type[PolygonValue] = PolygonValue
 
 
 class PolygonLabelsTag(ControlTag):
     """ """
-
+    tag: str = "PolygonLabels"
     _label_attr_name: str = "polygonlabels"
     _value_class: Type[PolygonLabelsValue] = PolygonLabelsValue
 
@@ -633,13 +641,13 @@ class RectangleLabelsValue(RectangleValue):
 
 class RectangleTag(ControlTag):
     """ """
-
+    tag: str = "Rectangle"
     _value_class: Type[RectangleValue] = RectangleValue
 
 
 class RectangleLabelsTag(ControlTag):
     """ """
-
+    tag: str = "RectangleLabels"
     _label_attr_name: str = "rectanglelabels"
     _value_class: Type[RectangleLabelsValue] = RectangleLabelsValue
 
@@ -663,6 +671,7 @@ class VideoRectangleValue(BaseModel):
     
 class VideoRectangleTag(ControlTag):
     """ """
+    tag: str = "VideoRectangle"
     _label_attr_name: str = "labels"
     _value_class: Type[VideoRectangleValue] = VideoRectangleValue
     
@@ -673,6 +682,7 @@ class NumberValue(BaseModel):
 
 class NumberTag(ControlTag):
     """ """
+    tag: str = "Number"
     _value_class: Type[NumberValue] = NumberValue
     
 
@@ -682,6 +692,7 @@ class DateTimeValue(BaseModel):
     
 class DateTimeTag(ControlTag):
     """ """
+    tag: str = "DateTime"
     _value_class: Type[DateTimeValue] = DateTimeValue
 
 
@@ -691,7 +702,7 @@ class HyperTextLabelsValue(SpanSelectionOffsets):
 
 class HyperTextLabelsTag(ControlTag):
     """ """
-
+    tag: str = "HyperTextLabels"
     _label_attr_name: str = "htmllabels"
     _value_class: Type[HyperTextLabelsValue] = HyperTextLabelsValue
 
@@ -702,7 +713,7 @@ class PairwiseValue(BaseModel):
 
 class PairwiseTag(ControlTag):
     """ """
-
+    tag: str = "Pairwise"
     _value_class: Type[PairwiseValue] = PairwiseValue
 
     def label(self, side):
@@ -717,7 +728,7 @@ class ParagraphLabelsValue(SpanSelectionOffsets):
 
 class ParagraphLabelsTag(ControlTag):
     """ """
-
+    tag: str = "ParagraphsLabels"
     _label_attr_name: str = "paragraphlabels"
     _value_class: Type[ParagraphLabelsValue] = ParagraphLabelsValue
 
@@ -736,6 +747,7 @@ class RankerValue(BaseModel):
     
 class RankerTag(ControlTag):
     """ """
+    tag: str = "Ranker"
     _value_class: Type[RankerValue] = RankerValue
 
 
@@ -745,11 +757,13 @@ class RatingValue(BaseModel):
 
 class RatingTag(ControlTag):
     """ """
+    tag: str = "Rating"
     _value_class: Type[RatingValue] = RatingValue
 
 
 class RelationsTag(ControlTag):
     """ """
+    tag: str = "Relations"
     def validate_value(self, ) -> bool:
         """ """
         raise NotImplemented("""Should not be called directly, instead
@@ -768,7 +782,7 @@ class TaxonomyValue(BaseModel):
 
 class TaxonomyTag(ControlTag):
     """ """
-
+    tag: str = "Taxonomy"
     _value_class: Type[TaxonomyValue] = TaxonomyValue
 
 
@@ -778,7 +792,7 @@ class TextAreaValue(BaseModel):
 
 class TextAreaTag(ControlTag):
     """ """
-
+    tag: str = "TextArea"
     _value_class: Type[TextAreaValue] = TextAreaValue
 
 
@@ -789,6 +803,6 @@ class TimeSeriesValue(SpanSelection):
 
 class TimeSeriesLabelsTag(ControlTag):
     """ """
-
+    tag: str = "TimeSeriesLabels"
     _label_attr_name: str = "timeserieslabels"
     _value_class: Type[TimeSeriesValue] = TimeSeriesValue

label_studio_sdk/label_interface/create.py

@@ -0,0 +1,241 @@
+"""
+"""
+from typing import Dict, Optional, List, Tuple, Any, Callable, Union
+import xml.etree.ElementTree as ET
+from xml.dom import minidom
+
+from label_studio_sdk.label_interface.base import LabelStudioTag
+
+import label_studio_sdk.label_interface.object_tags as OT
+import label_studio_sdk.label_interface.control_tags as CT
+
+## syntatic sugar helper functions
+
+def labels(labels, tag_type="Labels", **kwargs):
+    """
+    Converts labels to a tuple structure.
+    
+    Args:
+        labels: The labels to be converted.
+        tag_type: Tag type to assign to each label.
+        
+    Returns:
+        A tuple containing labels as per the tag type.
+    """
+    return (tag_type, kwargs, _convert_to_tuple(labels, tag_type="Label"))
+    
+    
+def taxonomy(labels, **kwargs):
+    """
+    Constructs a taxonomy.
+    
+    Args:
+        labels: The labels to construct the taxonomy.
+        
+    Returns:
+        A tuple containing the taxonomy.
+    """
+    result = []
+    
+    for arg in labels:
+        if isinstance(arg, tuple):
+            parent, *children = _convert_to_tuple(arg)
+            parent_children = (parent[0], parent[1], tuple(children))
+            result.append(parent_children)            
+        else:
+            result.append(("Choice", {"value": arg}, {}))
+    
+    return ("Taxonomy", kwargs, tuple(result))    
+
+def choices(labels, **kwargs):
+    """
+    Constructs a choices tuple.
+    
+    Args:
+        labels: The labels to be converted.
+        
+    Returns:
+        A tuple containing the choices.
+    """ 
+    return ("Choices", kwargs, _convert_to_tuple(labels))
+
+
+def _prettify(element):
+    """
+    Returns a pretty-printed XML string for the Element.
+    """
+    rough_string = ET.tostring(element, 'utf-8')
+    reparsed = minidom.parseString(rough_string)
+    return reparsed.toprettyxml(indent="  ")
+
+
+def _convert_to_tuple(args, tag_type="Choice"):
+    """
+    Converts arguments to a tuple structure of choices.
+
+    Args:
+        args: The labels to be converted.
+        tag_type: Tag type to assign to each label.
+
+    Returns:
+        A tuple containing all labels in specified format.
+    """
+    if not args:
+        return None
+    
+    return tuple(((tag_type, {"value": arg}, {})) for arg in args)
+
+
+def _create_nested_elements(parent: ET.Element, elements: List[Union[str, Dict[str, str], List]]) -> None:
+    """
+    Adds nested elements to the parent element in the Element Tree.
+
+    Args:
+        parent: The parent ET.Element object.
+        elements: A list containing element definitions.
+    """    
+    for element in elements:        
+        if isinstance(element, str):
+            ET.SubElement(parent, element)
+        elif isinstance(element, dict):
+            for k, v in element.items():
+                parent.set(k, v)
+        elif isinstance(element, list) or isinstance(element, tuple):
+            create_element(element, parent=parent)
+
+            
+def _convert(name: str, tag: Union[str, list, tuple, LabelStudioTag]) -> tuple:
+    """
+    Converts tags from str, list, tuple, or class instance to a tuple format.
+
+    Args:
+        name: Name of the tag.
+        tag: Tag in str, list, tuple or class instance format.
+
+    Returns:
+        A tuple version of the input tag.
+    
+    Raises:
+        TypeError: If input tag is not a str, list, tuple, or LabelStudioTag.
+    """
+    
+    if isinstance(tag, LabelStudioTag):
+        tag.name = tag.name or name
+        child_tag_type = "Choice" if tag.tag in ["Choices", "Taxonomy"] else "Label"
+        el = tag.tag, tag.collect_attrs(), _convert_to_tuple(getattr(tag, "labels", None), tag_type=child_tag_type)
+    elif isinstance(tag, (list, tuple)):
+        el = (*tag, ()) if len(tag) < 3 else tag
+    elif isinstance(tag, str):        
+        el = tag, {}, ()
+    else:
+        raise TypeError("Input tag must be one of str, list, tuple, LabelStudioTag")
+
+    el[1].setdefault("name", name)
+    
+    if el[0].lower() in OT._TAG_TO_CLASS and not el[1].get("value"):
+        el[1]["value"] = "$" + name
+            
+    return el
+
+
+def _find_first_object_tag(tags):
+    """
+    Finds the first object tag in the input tags dictionary.
+
+    Args:
+        tags: A dictionary of tags.
+
+    Returns:
+        The first object tag found, or None.
+    """
+    for name, tag in tags.items():
+        tag_tuple = _convert(name, tag)
+        tag_name = tag_tuple[0]
+                
+        if tag_name.lower() in OT._TAG_TO_CLASS:
+            return tag_tuple
+
+            
+def create_element(element: List[Union[str, Dict[str, str], List]], parent=None) -> ET.Element:
+    """
+    Creates an XML element.
+    
+    Args:
+        element: List of tag, attributes and children to feed into the element.
+        parent: Parent element to append the new element to (Optional).
+        
+    Returns:
+        An ElementTree element.
+    """
+    tag, attrs, children = element
+    el = ET.SubElement(parent, tag) if parent is not None else ET.Element(tag)
+    
+    for k, v in attrs.items():
+        el.set(k, v)
+
+    if children:
+        _create_nested_elements(el, children) 
+        
+    return el
+
+        
+def tree_from_tuples(*elements):
+    """
+    Creates an ElementTree from the input element definitions, and return a string for it.
+
+    Args:
+        elements: Variable length argument list of elements to add to the ElementTree.
+
+    Returns:
+        XML configuration
+    """
+    view = ET.Element('View')
+    for element in elements:
+        el = create_element(element)
+        view.append(el)
+
+    return view
+
+
+def tree_to_string(tree, pretty=True):
+    """
+    """    
+    if pretty:
+        pp = _prettify(tree)
+        return pp.replace('<?xml version="1.0" ?>\n', '')
+    else:
+        return ET.tostring(tree, encoding='unicode')
+    
+
+def convert_tags_description(tags: Dict[str, Any],
+                             mapping: Optional[Dict[str, str]]=None) -> List[Union[str, Dict[str, str], List]]:
+    """
+    Convert tags into a structured format.
+
+    Args:
+        tags: A dictionary of tags.
+        mapping: Optional mapping of tag name transformations.
+
+    Returns:
+        A list of the structured tags.
+    """
+    elements = []
+    first_object_tag = _find_first_object_tag(tags)
+        
+    for name, tag in tags.items():
+        el = _convert(name, tag)
+
+        # Set `toName` property of the tag if tag name is in
+        # CT._TAG_TO_CLASS and `toName` key is not in tag attributes
+        # The value of `toName` key is set based on whether `name` of
+        # tag is in the mapping dictionary or the `name` of the first
+        # object tag if it's not in mapping
+        if el[0].lower() in CT._TAG_TO_CLASS and ("toName" not in el[1] or el[1]["toName"] is None):
+            if mapping and el[1].get("name") in mapping:
+                el[1]["toName"] = mapping.get(el[1]["name"])                
+            else:
+                el[1]["toName"] = first_object_tag[1]["name"]
+        
+        elements.append(el)
+    
+    return elements

label_studio_sdk/label_interface/interface.py

@@ -22,6 +22,7 @@ from label_studio_sdk._legacy.exceptions import (
     LabelStudioValidationErrorSentryIgnored,
 )
 
+from .base import LabelStudioTag
 from .control_tags import (
     ControlTag,
     ChoicesTag,
@@ -30,6 +31,7 @@ from .control_tags import (
 from .object_tags import ObjectTag
 from .label_tags import LabelTag
 from .objects import AnnotationValue, TaskValue, PredictionValue
+from . import create as CE
 
 
 dir_path = os.path.dirname(os.path.realpath(__file__))
@@ -189,6 +191,67 @@ class LabelInterface:
     ```
     """
 
+    @classmethod
+    def create(cls, tags, mapping=None, title=None, style=None, pretty=True, *args, **kwargs):
+        """ Simple way of create UI config, it helps you not to thing much about the name/toName mapping
+
+        LabelInterface.create_simple({
+          "txt": "Text",
+          "chc": choices("positive", "negative")
+        })
+        """
+        tuples = CE.convert_tags_description(tags, mapping=mapping)
+
+        if isinstance(title, str):
+            tuples = (("Header", { "value": title }, {}),) + tuples
+
+        # in case we have either title or style, then we can iterate
+        # through the tuples and modify the tree
+        if isinstance(title, dict) or isinstance(style, dict):
+            new_tuples = []
+            for t in tuples:
+                tag, attributes, children = t
+                name = attributes.get("name", None)
+
+                # prepend Header tag to the list
+                if isinstance(title, dict) and name in title:
+                    title_tag = ("Header", { "value": title.get(name) }, {})
+                    new_tuples.append(title_tag)
+
+                # modify the style of the element by wrapping it into
+                # a View with style
+                if isinstance(style, dict) and name in style:
+                    parent_tag = ("View", { "style": style.get(name) }, (t,))
+                    new_tuples.append(parent_tag)
+                else:
+                    new_tuples.append(t)
+
+            tuples = new_tuples
+        
+        tree = CE.tree_from_tuples(*tuples)
+        
+        return CE.tree_to_string(tree, pretty=pretty)
+
+    
+    @classmethod
+    def create_instance(cls, *args, **kwargs):
+        """Create instance is a shortcut to create a config and then
+        parse it right away returning the LabelInterface object
+
+        ```
+        li = LabelInterface.create_instance({ "txt": "Text", "lbl": labels(("person", "org")) })
+        lbl = li.get_control("lbl")
+        reg = lbl.label("person", start=0, end=10)
+        ```
+        
+        The above returns a region that could be serialized to Label
+        Studio JSON format and uploaded to Label Studio
+
+        """
+        config = cls.create(*args, **kwargs)
+        return cls(config=config, **kwargs)
+    
+    
     def __init__(self, config: str, tags_mapping=None, *args, **kwargs):
         """
         Initialize a LabelInterface instance using a config string.
@@ -240,6 +303,11 @@ class LabelInterface:
 
     ##### NEW API
 
+    @property
+    def config(self):
+        """Returns the XML configuration string"""
+        return self._config
+
     @property
     def controls(self):
         """Returns list of control tags"""

label_studio_sdk/label_interface/object_tags.py

@@ -144,7 +144,14 @@ class ObjectTag(LabelStudioTag):
         """Check if value has variable"""
         pattern = re.compile(r"^\$[^, ]+$")
         return bool(pattern.fullmatch(self.value))
-    
+
+    def collect_attrs(self):
+        """Return tag attrs as a single dict"""
+        return {
+            **self.attr,
+            "name": self.name,
+            "value": '$' + self.value if self.value is not None else None
+        }
 
     # and have generate_example in each
     def generate_example_value(self, mode="upload", secure_mode=False):
@@ -174,7 +181,8 @@ class ObjectTag(LabelStudioTag):
 
 class AudioTag(ObjectTag):
     """ """
-
+    tag: str = "Audio"
+    
     def _generate_example(self, examples, only_urls=False):
         """ """
         return examples.get("Audio")
@@ -182,7 +190,8 @@ class AudioTag(ObjectTag):
 
 class ImageTag(ObjectTag):
     """ """
-
+    tag: str = "Image"
+    
     def _generate_example(self, examples, only_urls=False):
         """ """
         return examples.get("Image")
@@ -190,7 +199,8 @@ class ImageTag(ObjectTag):
 
 class TableTag(ObjectTag):
     """ """
-
+    tag: str = "Table"
+    
     def _generate_example(self, examples, only_urls=False):
         """ """
         return examples.get("Table")
@@ -198,7 +208,8 @@ class TableTag(ObjectTag):
 
 class TextTag(ObjectTag):
     """ """
-
+    tag: str = "Text"
+    
     def _generate_example(self, examples, only_urls=False):
         """ """
         if only_urls:
@@ -209,7 +220,8 @@ class TextTag(ObjectTag):
 
 class VideoTag(ObjectTag):
     """ """
-
+    tag: str = "Video"
+    
     def _generate_example(self, examples, only_urls=False):
         """ """
         return examples.get("Video")
@@ -217,7 +229,8 @@ class VideoTag(ObjectTag):
 
 class HyperTextTag(ObjectTag):
     """ """
-
+    tag: str = "HyperText"
+    
     def _generate_example(self, examples, only_urls=False):
         """ """
         examples = data_examples(mode="upload")
@@ -229,7 +242,8 @@ class HyperTextTag(ObjectTag):
 
 class ListTag(ObjectTag):
     """ """
-
+    tag: str = "List"
+    
     def _generate_example(self, examples, only_urls=False):
         """ """
         examples = data_examples(mode="upload")
@@ -238,7 +252,8 @@ class ListTag(ObjectTag):
 
 class ParagraphsTag(ObjectTag):
     """ """
-
+    tag: str = "Paragraphs"
+    
     def _generate_example(self, examples, only_urls=False):
         """ """
         # Paragraphs special case - replace nameKey/textKey if presented
@@ -259,7 +274,8 @@ class ParagraphsTag(ObjectTag):
 
 class TimeSeriesTag(ObjectTag):
     """ """
-
+    tag: str = "TimeSeries"
+    
     def _generate_example(self, examples, only_urls=False):
         """ """
         p = self.attr

label_studio_sdk/label_interface/objects.py

@@ -20,13 +20,13 @@ def serialize_regions(result):
 
 class PredictionValue(BaseModel):
     """ """
-
     model_version: Optional[Any] = None
     score: Optional[float] = 0.00
     result: Optional[List[Union[Dict[str, Any], Region]]]
 
     class Config:
-        allow_population_by_field_name = True
+        populate_by_name = True
+        protected_namespaces = ()
 
     @field_serializer('result')
     def serialize_result(self, result):
@@ -45,7 +45,7 @@ class AnnotationValue(BaseModel):
     result: Optional[List[Union[Dict[str, Any], Region]]]
     
     class Config:
-        allow_population_by_field_name = True
+        populate_by_name = True
 
     @field_serializer('result')
     def serialize_result(self, result):
@@ -56,5 +56,5 @@ class TaskValue(BaseModel):
     """ """
     
     data: Optional[dict]
-    annotations: Optional[List[AnnotationValue]]
-    predictions: Optional[List[PredictionValue]]
+    annotations: Optional[List[AnnotationValue]] = Field(default_factory=list)
+    predictions: Optional[List[PredictionValue]] = Field(default_factory=list)