darwin-py 3.6.2__tar.gz → 3.6.3__tar.gz

{darwin_py-3.6.2 → darwin_py-3.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: darwin-py
-Version: 3.6.2
+Version: 3.6.3
 Summary: Library and command line interface for darwin.v7labs.com
 License: MIT
 License-File: LICENSE

{darwin_py-3.6.2 → darwin_py-3.6.3}/darwin/dataset/remote_dataset.py

@@ -3,6 +3,7 @@ import shutil
 import tempfile
 import time
 import zipfile
+from collections import defaultdict
 from datetime import datetime
 from pathlib import Path
 from typing import (
@@ -334,6 +335,12 @@ class RemoteDataset(ABC):
                     metadata_dir.mkdir(parents=True, exist_ok=True)
                     shutil.move(str(metadata_file), str(metadata_dir / "metadata.json"))
 
+                # Collect class names per annotation type as we walk the JSONs,
+                # so we don't have to re-parse every annotation file three more
+                # times (once per type) in a separate pass.
+                supported_class_types = ("tag", "polygon", "bounding_box")
+                classes_by_type: Dict[str, set] = defaultdict(set)
+
                 # Move the annotations into the right folder and rename them to have the image
                 # original filename as contained in the json
                 for annotation_path in tmp_dir.glob("*.json"):
@@ -353,6 +360,11 @@ class RemoteDataset(ABC):
                             raise MissingDependency(
                                 "Missing Dependency: OpenCV required for Video Extraction. Install with `pip install darwin-py\[ocv]`"
                             ) from e
+                    for ann in annotation.annotations:
+                        atype = ann.annotation_class.annotation_type
+                        if atype in supported_class_types:
+                            classes_by_type[atype].add(ann.annotation_class.name)
+
                     filename = Path(annotation.filename).stem
                     if filename in stems:
                         stems[filename] += 1
@@ -365,8 +377,23 @@ class RemoteDataset(ABC):
                     )
                     shutil.move(str(annotation_path), str(destination_name))
 
-        # Extract the list of classes and create the text files
-        make_class_lists(release_dir)
+        # Write the class lists next to the annotations we just produced.
+        # Using ``annotations_dir.parent`` keeps the output co-located with
+        # the corresponding ``annotations/`` folder, which is what every
+        # downstream helper expects -- and crucially it works when
+        # ``subset_folder_name`` is set, where the annotations live under
+        # ``<release_dir>/<subset_folder_name>/annotations`` rather than
+        # directly under ``<release_dir>``.
+        lists_path = annotations_dir.parent / "lists"
+        lists_path.mkdir(exist_ok=True)
+        for atype in supported_class_types:
+            class_names = classes_by_type.get(atype)
+            class_list_path = lists_path / f"classes_{atype}.txt"
+            if not class_names:
+                if class_list_path.exists():
+                    class_list_path.unlink()
+                continue
+            class_list_path.write_text("\n".join(sorted(class_names)))
 
         if release.latest and is_unix_like_os():
             try:

{darwin_py-3.6.2 → darwin_py-3.6.3}/darwin/dataset/utils.py

@@ -119,21 +119,30 @@ def extract_classes(
     return classes, indices_to_classes
 
 
-def make_class_lists(release_path: Path) -> None:
+def make_class_lists(release_path: Optional[PathLike]) -> None:
     """
     Support function to extract classes and save the output to file.
 
     Parameters
     ----------
-    release_path : Path
-        Path to the location of the dataset on the file system.
-    """
-    assert release_path is not None
+    release_path : Optional[PathLike]
+        Path to the location of the dataset on the file system, or ``None``.
+
+    Notes
+    -----
+    Silently no-ops when ``release_path`` is ``None`` or when the expected
+    ``annotations`` directory is missing. This makes the helper safe to call
+    on releases that were pulled into a custom subset folder (in which case
+    the caller should pass the subset-aware path) or on empty exports.
+    """
+    if release_path is None:
+        return
     if isinstance(release_path, str):
         release_path = Path(release_path)
 
     annotations_path = release_path / "annotations"
-    assert annotations_path.exists()
+    if not annotations_path.exists():
+        return
     lists_path = release_path / "lists"
     lists_path.mkdir(exist_ok=True)
 

{darwin_py-3.6.2 → darwin_py-3.6.3}/darwin/datatypes.py

@@ -118,6 +118,7 @@ AnnotationType = Literal[  # NB: Some of these are not supported yet
     "tag",
     "line",
     "skeleton",
+    "eye",
     "table",
     "string",
     "graph",
@@ -1003,6 +1004,49 @@ def make_skeleton(
     )
 
 
+def make_eye(
+    class_name: str,
+    nodes: List[Node],
+    subs: Optional[List[SubAnnotation]] = None,
+    slot_names: Optional[List[str]] = None,
+) -> Annotation:
+    """
+    Creates and returns an eye annotation.
+
+    Parameters
+    ----------
+    class_name : str
+        The name of the class for this ``Annotation``.
+    nodes : List[Node]
+        List of ``Node``\\s that comprise the eye. Darwin requires exactly four, named
+        ``inner``, ``outer``, ``upper`` and ``lower``. Each Node will have a format
+        similar to:
+
+        .. code-block:: python
+
+            {
+                "name": "inner",
+                "occluded": false,
+                "x": 141.4359,
+                "y": 149.2308
+            }
+
+    subs : Optional[List[SubAnnotation]], default: None
+        List of ``SubAnnotation``\\s for this ``Annotation``.
+
+    Returns
+    -------
+    Annotation
+        An eye ``Annotation``.
+    """
+    return Annotation(
+        AnnotationClass(class_name, "eye"),
+        {"nodes": nodes},
+        subs or [],
+        slot_names=slot_names or [],
+    )
+
+
 def make_ellipse(
     class_name: str,
     parameters: EllipseData,

{darwin_py-3.6.2 → darwin_py-3.6.3}/darwin/importer/importer.py

@@ -79,6 +79,10 @@ except ImportError:
 # Classes missing import support on backend side
 UNSUPPORTED_CLASSES = ["string", "graph"]
 
+# Classes whose definition carries a node structure that the class creation endpoint
+# cannot express, so they must already exist on the team before importing into them
+UNCREATABLE_CLASS_TYPES = ["skeleton", "eye"]
+
 # Classes that are defined on team level automatically and available in all datasets
 GLOBAL_CLASSES = ["__raster_layer__"]
 
@@ -124,6 +128,7 @@ def _build_main_annotations_lookup_table(
         "link",
         "polygon",
         "skeleton",
+        "eye",
         "tag",
         "string",
         "table",
@@ -1662,13 +1667,18 @@ def import_annotations(  # noqa: C901
         style="info",
     )
 
-    missing_skeletons: List[dt.AnnotationClass] = list(
-        filter(_is_skeleton_class, local_classes_not_in_team)
+    missing_uncreatable_classes: List[dt.AnnotationClass] = list(
+        filter(_is_uncreatable_class, local_classes_not_in_team)
     )
-    missing_skeleton_names: str = ", ".join(map(_get_skeleton_name, missing_skeletons))
-    if missing_skeletons:
+    if missing_uncreatable_classes:
+        missing_class_names: str = ", ".join(
+            f"{_get_class_name(the_class)} ({the_class.annotation_internal_type or the_class.annotation_type})"
+            for the_class in missing_uncreatable_classes
+        )
         console.print(
-            f"Found missing skeleton classes: {missing_skeleton_names}. Missing Skeleton classes cannot be created. Exiting now.",
+            f"Found missing classes that cannot be created: {missing_class_names}. "
+            "Create them in the Darwin UI before importing, or check that the "
+            "annotation type is available for your team. Exiting now.",
             style="error",
         )
         return
@@ -1899,14 +1909,14 @@ def _warn_unsupported_annotations(parsed_files: List[AnnotationFile]) -> None:
             )
 
 
-def _is_skeleton_class(the_class: dt.AnnotationClass) -> bool:
+def _is_uncreatable_class(the_class: dt.AnnotationClass) -> bool:
     return (
         the_class.annotation_internal_type or the_class.annotation_type
-    ) == "skeleton"
+    ) in UNCREATABLE_CLASS_TYPES
 
 
-def _get_skeleton_name(skeleton: dt.AnnotationClass) -> str:
-    return skeleton.name
+def _get_class_name(the_class: dt.AnnotationClass) -> str:
+    return the_class.name
 
 
 def _handle_subs(

{darwin_py-3.6.2 → darwin_py-3.6.3}/darwin/utils/utils.py

@@ -866,6 +866,10 @@ def _parse_darwin_annotation(
         main_annotation = dt.make_skeleton(
             name, annotation["skeleton"]["nodes"], slot_names=slot_names
         )
+    elif "eye" in annotation:
+        main_annotation = dt.make_eye(
+            name, annotation["eye"]["nodes"], slot_names=slot_names
+        )
     elif "table" in annotation:
         main_annotation = dt.make_table(
             name,
@@ -949,6 +953,8 @@ def make_keyframe_annotation(
         return dt.make_cuboid(name, annotation_data)
     elif annotation_type == "skeleton":
         return dt.make_skeleton(name, annotation_data["nodes"])
+    elif annotation_type == "eye":
+        return dt.make_eye(name, annotation_data["nodes"])
     elif annotation_type == "table":
         return dt.make_table(
             name, annotation_data["bounding_box"], annotation_data["cells"]
@@ -1013,7 +1019,7 @@ def update_annotation_data(
             "back": main_annotation_data["back"],
             "front": main_annotation_data["front"],
         }
-    elif annotation_type == "skeleton":
+    elif annotation_type in ("skeleton", "eye"):
         annotation_data = {"nodes": main_annotation_data["nodes"]}
     elif annotation_type == "table":
         annotation_type = "table"
@@ -1142,6 +1148,9 @@ def get_annotation_type_and_data(
     elif "skeleton" in frame:
         annotation_type = "skeleton"
         annotation_data = {"nodes": frame["skeleton"]["nodes"]}
+    elif "eye" in frame:
+        annotation_type = "eye"
+        annotation_data = {"nodes": frame["eye"]["nodes"]}
     elif "table" in frame:
         annotation_type = "table"
         annotation_data = {

darwin_py-3.6.3/darwin/version/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.6.3"

{darwin_py-3.6.2 → darwin_py-3.6.3}/pyproject.toml

@@ -13,7 +13,7 @@ license = "MIT"
 name = "darwin-py"
 readme = "README.md"
 repository = "https://github.com/v7labs/darwin-py"
-version = "3.6.2"
+version = "3.6.3"
 [[tool.poetry.packages]]
 include = "darwin"
 

darwin_py-3.6.2/darwin/version/__init__.py

@@ -1 +0,0 @@
-__version__ = "3.6.2"