label-studio-sdk 0.0.30__py3-none-any.whl → 0.0.34__py3-none-any.whl

tests/test_export.py

@@ -0,0 +1,105 @@
+from unittest.mock import Mock
+
+import requests_mock
+
+from label_studio_sdk.client import Client
+from label_studio_sdk.data_manager import Filters, Operator, Type, Column
+
+
+def test_client_headers():
+    mock_session = Mock(spec=["request"])
+    mock_session.request.return_value = Mock(status_code=200)
+    client = Client(
+        url="http://fake.url",
+        api_key="fake_key",
+        session=mock_session,
+        versions={"label-studio": "1.0.0"},
+        extra_headers={"Proxy-Authorization": "Bearer fake_bearer"},
+    )
+
+    client.check_connection()
+    args, kwargs = mock_session.request.call_args
+    assert kwargs["headers"] == {
+        "Authorization": f"Token fake_key",
+        "Proxy-Authorization": "Bearer fake_bearer",
+    }
+
+
+def test_client_no_extra_headers():
+    mock_session = Mock(spec=["request"])
+    mock_session.request.return_value = Mock(status_code=200)
+    client = Client(
+        url="http://fake.url",
+        api_key="fake_key",
+        session=mock_session,
+        versions={"label-studio": "1.0.0"},
+    )
+
+    client.check_connection()
+    args, kwargs = mock_session.request.call_args
+    assert kwargs["headers"] == {"Authorization": f"Token fake_key"}
+
+
+def test_project_export_with_filters():
+    with requests_mock.Mocker() as m:
+        m.get(
+            'http://fake.url/api/version',
+            json={"version": "1.0.0"},
+            status_code=200,
+        )
+        m.get(
+            'http://fake.url/api/projects/1',
+            json={"id": 1, "title": "fake_project"},
+            status_code=200,
+        )
+        m.post(
+            'http://fake.url/api/projects/1/exports',
+            json={"id": 1, "title": "fake_project"},
+            status_code=200,
+        )
+        m.post(
+            'http://fake.url/api/dm/views',
+            json={"id": 1, "title": "fake_project"},
+            status_code=200,
+        )
+        m.post(
+            'http://fake.url/api/projects/1/exports',
+            json={"id": 1, "title": "fake_project"},
+            status_code=200,
+        )
+        m.get(
+            'http://fake.url/api/projects/1/exports/1',
+            json={"id": 1, "title": "fake_project", "status": "completed"},
+            status_code=200,
+        )
+        m.get(
+            'http://fake.url/api/projects/1/exports/1/download?exportType=JSON',
+            headers={"Content-Disposition": "attachment; filename=fake_project.json"},
+            status_code=200,
+        )
+        m.delete(
+            'http://fake.url/api/dm/views/1',
+            status_code=200,
+        )
+
+        filters = Filters.create(
+            Filters.AND,
+            [
+                Filters.item(
+                    Column.inner_id,
+                    Operator.GREATER_OR_EQUAL,
+                    Type.Number,
+                    Filters.value(1),
+                ),
+                Filters.item(
+                    Column.inner_id,
+                    Operator.LESS,
+                    Type.Number,
+                    Filters.value(100),
+                ),
+            ],
+        )
+
+        ls = Client(url='http://fake.url', api_key='fake_key')
+        project = ls.get_project(1)
+        project.export(filters=filters)

tests/test_interface/__init__.py

@@ -0,0 +1 @@
+

tests/test_interface/configs.py

@@ -0,0 +1,137 @@
+FROM_NAME = "from_name"
+FROM_NAME_PREFIX = "from"
+TO_NAME = "to_name"
+ANOTHER_NAME = "another_name"
+ANOTHER_TO_NAME = "another_to_name"
+
+VALUE = "$var"
+VALUE_KEY = "var"
+ANOTHER_VALUE = "$var2"
+
+LABEL1 = "yes"
+LABEL2 = "no"
+
+CORRECT_TASK = {VALUE_KEY: "value"}
+
+CORRECT_REGION = {
+    "from_name": FROM_NAME,
+    "to_name": TO_NAME,
+    "type": "choices",
+    "value": {"choices": [LABEL1]},
+}
+
+SIMPLE_CONF = f"""
+    <View>
+      <Text name="{TO_NAME}" value="{VALUE}" />      
+      <Choices name="{FROM_NAME}" toName="{TO_NAME}">
+        <Choice value="{LABEL1}" />
+        <Choice value="{LABEL2}" />
+      </Choices>
+    </View>
+"""
+
+SIMPLE_WRONG_CONF = f"""
+    <View>
+      <Text name="{TO_NAME}" value="{VALUE}" />
+      <Text name="{TO_NAME}" value="{VALUE}" />
+      <Choices name="{FROM_NAME}" toName="{ANOTHER_TO_NAME}">
+        <Choice value="{LABEL1}" />
+        <Choice value="{LABEL2}" />
+      </Choices>
+    </View>
+"""
+
+CONF_WITH_COMMENT = (
+    '<!-- {"data": { "hello": "world" }, "predictions": [], "annotations": [] } -->'
+    + f"""{SIMPLE_CONF}"""
+)
+
+CONF_COMPLEX = f"""
+<View>
+  <Labels name="label" toName="text">
+    <Label value="PER" background="red"/>
+    <Label value="ORG" background="darkorange"/>
+    <Label value="LOC" background="orange"/>
+    <Label value="MISC" background="green"/>
+  </Labels>
+
+  <Text name="text" value="$text"/>
+  <Choices name="sentiment" toName="text"
+             choice="single" showInLine="true">
+      <Choice value="Positive"/>
+      <Choice value="Negative"/>
+      <Choice value="Neutral"/>
+    </Choices>
+</View>
+"""
+
+TWO_TONAMES = f"""
+    <View>
+      <Text name="{TO_NAME}" value="{VALUE}" />
+      <Text name="{ANOTHER_TO_NAME}" value="{VALUE}" />
+      <Choices name="{FROM_NAME}" toName="{TO_NAME},{ANOTHER_TO_NAME}">
+        <Choice value="{LABEL1}" />
+        <Choice value="{LABEL2}" />
+      </Choices>
+    </View>
+"""
+
+TEXTAREA_CONF = f"""
+<View>
+  <Textarea name="{FROM_NAME}" toName="{TO_NAME}" />
+  <Text name="{TO_NAME}" value="{VALUE}" />
+
+  <Choices name="{ANOTHER_NAME}" toName="{TO_NAME}">
+    <Choice value="{LABEL1}" />
+    <Choice value="{LABEL2}" />
+  </Choices>
+</View>
+"""
+
+VIDEO_CONF = f"""
+<View>
+  <Labels name="videoLabels" toName="video">
+    <Label value="Car"/>
+    <Label value="Person"/>
+  </Labels>
+  <Video name="video" value="$video"/>
+  <VideoRectangle name="box" toName="video"/>
+</View>
+"""
+
+NO_DYNAMIC_LABELS_CONF = f"""
+<View>
+  <Header value="Select label and click the image to start"/>
+  <Image name="image" value="$image" zoom="true"/>
+  <PolygonLabels name="label" toName="image"
+     strokeWidth="3" pointSize="small"
+     opacity="0.9" />
+</View>
+"""
+
+DYNAMIC_LABELS_CONF = f"""
+<View>
+  <Header value="Select label and click the image to start"/>
+  <Image name="image" value="$image" zoom="true"/>
+  <PolygonLabels name="label" toName="image"
+     strokeWidth="3" pointSize="small"
+     opacity="0.9" value="$options" />
+</View>
+"""
+
+RECT_CONFIG = f"""
+<View>
+  <Image name="{TO_NAME}" value="{VALUE}" />
+  <Rectangle name="{FROM_NAME}" toName="{TO_NAME}"></Rectangle>
+</View>
+"""
+
+EMPTY_VALUE_CONF = f"""
+<View>
+  <Text name="text" value="$text"/>
+  <Labels name="type" toName="text">
+    <Label value="" />
+    <Label value="" />
+  </Labels>
+</View>
+"""

tests/test_interface/mockups.py

@@ -0,0 +1,22 @@
+import json
+
+# Example of the output of summary table for a specific project
+# project_id  created_at                  all_data_columns               common_data_columns    created_annotations                                    created_labels                                                created_labels_drafts
+# ----------  --------------------------  -----------------------------  ---------------------  -----------------------------------------------------  ------------------------------------------------------------  ----------------------------------------------------
+# 9           2024-03-02 20:47:43.710926  {"text": 20, "sentiment": 20}  ["sentiment", "text"]  {"label|text|labels": 2, "sentiment|text|choices": 2}  {"label": {"PER": 1, "ORG": 1}, "sentiment": {"Positive": 1,  {"label": {"MISC": 1}, "sentiment": {"Negative": 1}}
+#                                                                                                                                                       "Negative": 1}}
+
+
+class SummaryMockup:
+    """
+    """
+
+    created_labels = json.loads(
+        '{"label": {"PER": 1, "ORG": 1}, "sentiment": {"Positive": 1, "Negative": 1}}'
+    )
+    created_labels_drafts = json.loads(
+        '{"label": {"MISC": 1}, "sentiment": {"Negative": 1}}'
+    )
+    created_annotations = json.loads(
+        '{"label|text|labels": 2, "sentiment|text|choices": 2}'
+    )

tests/test_interface/test_compat.py

@@ -0,0 +1,64 @@
+## Testing compatibility functions
+##
+## Compatibility function is a function that was implemented in
+## label_studio.core.label_config or tools and is reimplemented within
+## SDK using new LabelInterface
+
+import pytest
+
+from label_studio_sdk.label_interface import LabelInterface
+from label_studio_sdk.objects import PredictionValue
+
+from . import configs as c
+
+
+def test_get_first_tag_occurence_simple():
+    conf = LabelInterface(c.SIMPLE_CONF)
+    from_name, to_name, value = conf.get_first_tag_occurence("Choices", "Text")
+
+    assert from_name == c.FROM_NAME
+    assert to_name == c.TO_NAME
+    assert value == c.VALUE_KEY
+
+    with pytest.raises(ValueError):
+        conf.get_first_tag_occurence("Choices", "Image")
+
+    with pytest.raises(ValueError):
+        conf.get_first_tag_occurence("Labels", "Text")
+
+    with pytest.raises(ValueError):
+        conf.get_first_tag_occurence("Labels", "Image")
+
+
+def test_get_first_tag_occurence_complex():
+    conf = LabelInterface(c.SIMPLE_CONF)
+    from_name, to_name, value = conf.get_first_tag_occurence(
+        "Choices",
+        ("Image", "Text"),
+        name_filter=lambda s: s.startswith(c.FROM_NAME_PREFIX),
+        to_name_filter=lambda s: s == c.TO_NAME,
+    )
+
+    assert from_name == c.FROM_NAME
+    assert to_name == c.TO_NAME
+    assert value == c.VALUE_KEY
+
+    with pytest.raises(ValueError):
+        conf.get_first_tag_occurence(
+            "Choices",
+            ("Image", "Text"),
+            name_filter=lambda s: s.startswith("wrong_prefix"),
+        )
+
+    with pytest.raises(ValueError):
+        conf.get_first_tag_occurence(
+            "Choices", ("Image", "Text"), to_name_filter=lambda s: s == "wrong_name"
+        )
+
+
+def test_is_video_object_tracking():
+    conf1 = LabelInterface(c.SIMPLE_CONF)
+    assert conf1.is_video_object_tracking() is False
+
+    conf2 = LabelInterface(c.VIDEO_CONF)
+    assert conf2.is_video_object_tracking() is True

tests/test_interface/test_control_tags.py

@@ -0,0 +1,55 @@
+import json
+from lxml.etree import Element
+
+from label_studio_sdk.label_interface import LabelInterface
+from label_studio_sdk.label_interface.control_tags import ControlTag
+
+import tests.test_interface.configs as c
+
+
+def test_parse():
+    tag = Element(
+        "tag",
+        {"name": "my_name", "toName": "name1,name2", "apiUrl": "http://myapi.com"},
+    )
+    control_tag = ControlTag.parse_node(tag)
+
+    assert isinstance(control_tag, ControlTag)
+    assert control_tag.tag == "tag"
+    assert control_tag.name == "my_name"
+    assert control_tag.to_name == ["name1", "name2"]
+    assert control_tag.dynamic_value == True
+
+
+def test_validate():
+    tag = Element("tag", {"name": "my_name", "toName": "name1,name2"})
+    is_control_tag1 = ControlTag.validate_node(tag)
+
+    assert is_control_tag1 == True
+
+    tag2 = Element("not_control_tag", {"name": "my_name"})
+    is_control_tag2 = ControlTag.validate_node(tag2)
+
+    assert is_control_tag2 == False
+
+
+def test_textarea_label():
+    conf = LabelInterface(c.TEXTAREA_CONF)
+
+    region = conf.get_control(c.FROM_NAME).label(text=["Hello", "World"])
+
+
+def test_label_with_choices():
+    conf = LabelInterface(c.SIMPLE_CONF)
+    region = conf.get_control().label(label=c.LABEL1)
+
+    rjs = region.to_json()
+    assert isinstance(rjs, str)
+
+    rpy = json.loads(rjs)
+    assert rpy["from_name"] == c.FROM_NAME
+    assert rpy["to_name"] == c.TO_NAME
+    assert "value" in rpy
+
+    assert "choices" in rpy.get("value")
+    assert c.LABEL1 in rpy["value"]["choices"]

tests/test_interface/test_data_generation.py

@@ -0,0 +1,45 @@
+from lxml.etree import Element
+
+from label_studio_sdk.label_interface import LabelInterface
+from label_studio_sdk.label_interface.object_tags import ObjectTag
+import tests.test_interface.configs as c
+
+
+def test_generate_sample_task():
+    conf = LabelInterface(c.SIMPLE_CONF)
+    task = conf.generate_sample_task()
+    value = c.VALUE[1:]
+
+    print(task)
+
+    assert value in task
+    assert len(task[value])
+
+
+def test_generate_url():
+    """Quick check that each object tag generates the right data
+    """
+
+    def url_validator(url):
+        assert url.startswith("https://") or url.startswith("http://")
+
+    # TODO need to add other validators
+    m = {
+        "Audio": url_validator,
+        "Image": url_validator,
+        # "Table": None,
+        "Text": url_validator,
+        "Video": url_validator,
+        # "HyperText": None,
+        # "List": None,
+        "Paragraphs": url_validator,
+        # "TimeSeries": url_validator
+    }
+
+    for tag_name, validator in m.items():
+
+        tag = Element(tag_name, {"name": "my_name", "value": "my_value"})
+        inst = ObjectTag.parse_node(tag)
+
+        res = inst.generate_example_value(mode="editor_preview", secure_mode=True)
+        validator(res)

tests/test_interface/test_lpi.py

@@ -0,0 +1,15 @@
+from label_studio_sdk.label_interface.region import Region
+from label_studio_sdk.label_interface.object_tags import ImageTag
+from label_studio_sdk.label_interface.control_tags import RectangleTag
+
+
+def test_li():
+    """Test using Label Interface to label things
+    """
+    img = ImageTag(
+        name="img", tag="image", value="http://example.com/image.jpg", attr={}
+    )
+    rect = RectangleTag(name="rect", to_name=["img"], tag="rectangle", attr={})
+    rect.set_object(img)
+
+    region = rect.label(x=10, y=10, width=10, height=10, rotation=10)

tests/test_interface/test_main.py

@@ -0,0 +1,196 @@
+"""
+"""
+import json
+import pytest
+import xmljson
+import copy
+
+from label_studio_sdk.objects import PredictionValue
+from label_studio_sdk.label_interface import LabelInterface
+from label_studio_sdk.label_interface.control_tags import (
+    ControlTag,
+    ChoicesTag,
+    LabelsTag,
+    Region,
+)
+from label_studio_sdk.exceptions import LabelStudioValidationErrorSentryIgnored
+
+# from label_studio_sdk.label_config.regions import Region
+import tests.test_interface.configs as c
+
+
+## testing basic functionality
+
+
+def test_parse_configs():
+    conf1 = LabelInterface(c.SIMPLE_CONF)
+    conf2 = LabelInterface(c.VIDEO_CONF)
+    conf3 = LabelInterface(c.DYNAMIC_LABELS_CONF)
+
+
+def test_accessors():
+    conf = LabelInterface(c.SIMPLE_CONF)
+
+    c1 = conf.get_control()
+    assert c1.name == c.FROM_NAME
+
+    c2 = conf.get_control(c.FROM_NAME)
+    assert c2.name == c.FROM_NAME
+
+    o1 = conf.get_object(c.TO_NAME)
+    assert o1.name == c.TO_NAME
+
+    o2 = c2.get_object(c.TO_NAME)
+    assert o2.name == c.TO_NAME
+
+
+def test_parse_two_to_names():
+    conf = LabelInterface(c.TWO_TONAMES)
+    ctrl = conf.get_control()
+
+    assert isinstance(ctrl, ControlTag)
+
+    with pytest.raises(Exception):
+        obj = conf.get_object()
+
+    obj1 = conf.get_object(c.TO_NAME)
+    assert obj1.name == c.TO_NAME
+
+    obj2 = conf.get_object(c.ANOTHER_TO_NAME)
+    assert obj2.name == c.ANOTHER_TO_NAME
+
+
+def test_parse_textarea():
+    conf = LabelInterface(c.TEXTAREA_CONF)
+
+
+# def test_parse_config_to_json():
+#     json = LabelInterface.parse_config_to_json(c.SIMPLE_CONF)
+
+
+def test_to_name_validation():
+    LabelInterface._to_name_validation(None, c.SIMPLE_CONF)
+
+    with pytest.raises(LabelStudioValidationErrorSentryIgnored):
+        LabelInterface._to_name_validation(None, c.SIMPLE_WRONG_CONF)
+
+
+def test_unique_names_validation():
+    with pytest.raises(LabelStudioValidationErrorSentryIgnored):
+        LabelInterface._unique_names_validation(None, c.SIMPLE_WRONG_CONF)
+
+
+def test_get_sample_task():
+    conf = LabelInterface(c.SIMPLE_CONF)
+    task, _, _ = conf._sample_task()
+    value = c.VALUE[1:]
+
+    assert value in task
+    assert len(task[value])
+
+
+## various edge cases
+
+
+def test_config_essential_data_has_changed():
+    conf = LabelInterface(c.SIMPLE_CONF)
+    assert conf.config_essential_data_has_changed(c.SIMPLE_CONF) is False
+
+    new_conf = c.SIMPLE_CONF.replace(c.FROM_NAME, "wrong_name")
+    assert conf.config_essential_data_has_changed(new_conf) is True
+
+    new_conf_2 = c.SIMPLE_CONF.replace(c.LABEL1, "wrong_label")
+    assert conf.config_essential_data_has_changed(new_conf_2) is True
+
+
+def test_get_task_from_labeling_config():
+    task_data, annotations, predictions = LabelInterface.get_task_from_labeling_config(
+        c.CONF_WITH_COMMENT
+    )
+
+    # assert task_data == "some_data"
+    # assert annotations == "some_annotations"
+    # assert predictions == "some_predictions"
+
+
+def test_find_tags():
+    conf = LabelInterface(c.SIMPLE_CONF)
+    tags = conf.find_tags(match_fn=lambda tag: tag.name == c.TO_NAME)
+
+    assert len(tags) > 0
+    assert tags[0].name == c.TO_NAME
+
+
+def test_find_tags_by_class():
+    conf = LabelInterface(c.SIMPLE_CONF)
+    tags = conf.find_tags_by_class(ChoicesTag)
+
+    assert len(tags) > 0
+    assert tags[0].name == c.FROM_NAME
+
+    tags2 = conf.find_tags_by_class(LabelsTag)
+    assert len(tags2) == 0
+
+
+## testing generation
+
+
+def test_task_generation():
+    val = c.VALUE[1:]
+    conf = LabelInterface(c.SIMPLE_CONF)
+    task = conf.generate_sample_task()
+
+    assert val in task
+    print(task)
+    assert len(task.get(val))
+
+
+## testing object tags
+
+## testing control tags
+
+
+def test_label_with_choices():
+    conf = LabelInterface(c.SIMPLE_CONF)
+    region: Region = conf.get_control().label(label=c.LABEL1)
+
+    rjs = region.to_json()
+    assert isinstance(rjs, str)
+
+    rpy = json.loads(rjs)
+    assert rpy["from_name"] == c.FROM_NAME
+    assert rpy["to_name"] == c.TO_NAME
+    assert "value" in rpy
+
+    print(rpy)
+
+    assert "choices" in rpy.get("value")
+    assert c.LABEL1 in rpy["value"]["choices"]
+
+
+## testing all other tags
+
+## test other method
+
+
+def test_load_task():
+    conf = LabelInterface(c.SIMPLE_CONF)
+    var_name = c.VALUE[1:]
+    value = "test"
+
+    tree = conf.load_task({var_name: value})
+
+    assert isinstance(tree, LabelInterface)
+    assert tree.get_object(c.TO_NAME).value == value
+
+
+def test_load_random_task():
+    conf = LabelInterface(c.SIMPLE_CONF)
+    task, _, _ = conf._sample_task()
+
+    tree = conf.load_task(task)
+    assert len(tree.get_object(c.TO_NAME).value)
+
+
+def test_empty_value_config():
+    conf = LabelInterface(c.EMPTY_VALUE_CONF)

tests/test_interface/test_object_tags.py

@@ -0,0 +1,36 @@
+from label_studio_sdk.label_interface.object_tags import ObjectTag
+from lxml.etree import Element
+
+
+def test_parse():
+    tag = Element("tag", {"name": "my_name", "value": "my_value"})
+    object_tag = ObjectTag.parse_node(tag)
+
+    assert object_tag.name == "my_name"
+    assert object_tag.value == "my_value"
+    assert object_tag.value_type == None
+
+
+def test_validate():
+    tag = Element("tag", {"name": "my_name", "value": "$my_value"})
+    validation_result = ObjectTag.validate_node(tag)
+
+    assert validation_result == True
+
+
+def test_value_type():
+    tag = Element(
+        "tag", {"name": "my_name", "value": "my_value", "valueType": "string"}
+    )
+    object_tag = ObjectTag.parse_node(tag)
+    tag_value_type = object_tag.value_type
+
+    assert tag_value_type == "string"
+
+
+def test_value_is_variable():
+    tag = Element("tag", {"name": "my_name", "value": "$my_var"})
+    object_tag = ObjectTag.parse_node(tag)
+    is_variable = object_tag.value_is_variable
+
+    assert is_variable == True