superannotate 4.5.4.dev1__py3-none-any.whl → 4.5.5.dev3__py3-none-any.whl

superannotate/__init__.py

@@ -2,7 +2,7 @@ import logging
 import os
 import sys
 
-__version__ = "4.5.4dev1"
+__version__ = "4.5.5dev3"
 
 
 os.environ.update({"sa_version": __version__})

superannotate/lib/app/analytics/aggregators.py

@@ -384,9 +384,7 @@ class DataAggregator:
             annotation_json = None
             with open(annotation_path) as fp:
                 annotation_json = json.load(fp)
-            parts = Path(annotation_path).name.split(self._annotation_suffix)
             row_data = self.__fill_image_metadata(row_data, annotation_json["metadata"])
-            annotation_instance_id = 0
 
             # include comments
             for annotation in annotation_json["comments"]:
@@ -433,10 +431,8 @@ class DataAggregator:
                 if Path(annotation_path).parent != Path(self.project_root):
                     folder_name = Path(annotation_path).parent.name
                 instance_row.folderName = folder_name
-                num_added = 0
                 if not attributes:
                     rows.append(instance_row)
-                    num_added = 1
                 else:
                     for attribute in attributes:
                         attribute_row = copy.copy(instance_row)
@@ -469,10 +465,6 @@ class DataAggregator:
                             attribute_row.attributeName = attribute_name
 
                         rows.append(attribute_row)
-                        num_added += 1
-
-                if num_added > 0:
-                    annotation_instance_id += 1
 
         df = pd.DataFrame([row.__dict__ for row in rows], dtype=object)
         df = df.astype({"probability": float})

superannotate/lib/app/analytics/common.py

@@ -3,7 +3,6 @@ import logging
 from pathlib import Path
 
 import pandas as pd
-import plotly.express as px
 from lib.core.exceptions import AppException
 
 logger = logging.getLogger("sa")
@@ -558,50 +557,3 @@ def consensus(df, item_name, annot_type):
             instance_id += 1
 
     return image_data
-
-
-def consensus_plot(consensus_df, *_, **__):
-    plot_data = consensus_df.copy()
-
-    # annotator-wise boxplot
-    annot_box_fig = px.box(
-        plot_data,
-        x="creatorEmail",
-        y="score",
-        points="all",
-        color="creatorEmail",
-        color_discrete_sequence=px.colors.qualitative.Dark24,
-    )
-    annot_box_fig.show()
-
-    # project-wise boxplot
-    project_box_fig = px.box(
-        plot_data,
-        x="folderName",
-        y="score",
-        points="all",
-        color="folderName",
-        color_discrete_sequence=px.colors.qualitative.Dark24,
-    )
-    project_box_fig.show()
-
-    # scatter plot of score vs area
-    fig = px.scatter(
-        plot_data,
-        x="area",
-        y="score",
-        color="className",
-        symbol="creatorEmail",
-        facet_col="folderName",
-        color_discrete_sequence=px.colors.qualitative.Dark24,
-        hover_data={
-            "className": False,
-            "itemName": True,
-            "folderName": False,
-            "area": False,
-            "score": False,
-        },
-    )
-    fig.for_each_annotation(lambda a: a.update(text=a.text.split("=")[-1]))
-    fig.for_each_trace(lambda t: t.update(name=t.name.split("=")[-1]))
-    fig.show()

superannotate/lib/app/input_converters/conversion.py

@@ -94,16 +94,6 @@ def _passes_type_sanity(params_info):
             )
 
 
-def _passes_list_members_type_sanity(lists_info):
-    for _list in lists_info:
-        for _list_member in _list[0]:
-            if not isinstance(_list_member, _list[2]):
-                raise AppException(
-                    "'%s' should be list of '%s', but contains '%s'"
-                    % (_list[1], _list[2], type(_list_member))
-                )
-
-
 def _passes_value_sanity(values_info):
     for value in values_info:
         if value[0] not in value[2]:

superannotate/lib/app/input_converters/converters/supervisely_converters/supervisely_strategies.py

@@ -24,11 +24,11 @@ class SuperviselyStrategy(baseStrategy):
             == "supervisely_keypoint_detection_to_sa_vector"
         ):
             meta_json = json.load(open(self.export_root / "meta.json"))
-            sa_jsons = self.conversion_algorithm(
+            self.conversion_algorithm(
                 json_files, classes_id_map, meta_json, self.output_dir
             )
         else:
-            sa_jsons = self.conversion_algorithm(
+            self.conversion_algorithm(
                 json_files, classes_id_map, self.task, self.output_dir
             )
         (self.output_dir / "classes").mkdir(exist_ok=True)

superannotate/lib/app/input_converters/converters/voc_converters/voc_helper.py

@@ -38,17 +38,6 @@ def _iou(bbox1, bbox2):
     )
 
 
-def _get_image_shape_from_xml(file_path):
-    with open(os.path.splitext(file_path)[0] + ".xml") as f:
-        tree = ET.parse(f)
-
-    size = tree.find("size")
-    width = int(size.find("width").text)
-    height = int(size.find("height").text)
-
-    return height, width
-
-
 def _get_image_metadata(file_path):
     with open(os.path.splitext(file_path)[0] + ".xml") as f:
         tree = ET.parse(f)

superannotate/lib/app/interface/responses.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from collections.abc import Iterator
+from typing import Generic
+from typing import overload
+from typing import TypeVar
+
+T = TypeVar("T")
+
+
+class BaseResult(list, Generic[T]):
+    """A generic list-like wrapper for results with lazy loading support.
+
+    Inherits from ``list`` for full backward compatibility with code that
+    expects a real list (``isinstance(x, list)``, JSON serializers, etc.).
+    Data is fetched lazily on first access.
+    """
+
+    def __init__(self, data_fetcher: Callable[[], list[T]]) -> None:
+        super().__init__()
+        self._data_fetcher = data_fetcher
+        self._loaded = False
+
+    def _ensure_data(self) -> None:
+        """Lazily fetch data if not already loaded."""
+        if not self._loaded:
+            list.extend(self, self._data_fetcher())
+            self._loaded = True
+
+    def data(self) -> list[T]:
+        self._ensure_data()
+        return list(self)
+
+    def __iter__(self) -> Iterator[T]:
+        self._ensure_data()
+        return list.__iter__(self)
+
+    def __len__(self) -> int:
+        self._ensure_data()
+        return list.__len__(self)
+
+    @overload
+    def __getitem__(self, index: int) -> T: ...
+
+    @overload
+    def __getitem__(self, index: slice) -> list[T]: ...
+
+    def __getitem__(self, index: int | slice) -> T | list[T]:
+        self._ensure_data()
+        return list.__getitem__(self, index)
+
+    def __repr__(self) -> str:
+        self._ensure_data()
+        return list.__repr__(self)
+
+    def __bool__(self) -> bool:
+        self._ensure_data()
+        return list.__len__(self) > 0
+
+    def __contains__(self, item: object) -> bool:
+        self._ensure_data()
+        return list.__contains__(self, item)
+
+    def __eq__(self, other: object) -> bool:
+        self._ensure_data()
+        return list.__eq__(self, other)
+
+    __hash__ = None  # type: ignore[assignment]
+
+
+class QueryResult(BaseResult[dict]):
+    """A list-like wrapper for query results that supports .count() method.
+
+    This class wraps a list of query results while maintaining full backward
+    compatibility with list-like operations (iteration, indexing, len()).
+    Data is fetched lazily - only when accessed. Calling .count() does not
+    trigger data fetching.
+    """
+
+    def __init__(
+        self,
+        data_fetcher: Callable[[], list[dict]],
+        count_fetcher: Callable[[], int],
+    ) -> None:
+        super().__init__(data_fetcher)
+        self._count_fetcher = count_fetcher
+
+    def count(self) -> int:
+        """Return the count of items matching the query from the server.
+
+        This method does not trigger data fetching - it makes a separate
+        lightweight API call to get only the count.
+        """
+        return self._count_fetcher()