darwin-py 3.5.2__tar.gz → 3.5.3__tar.gz

{darwin_py-3.5.2 → darwin_py-3.5.3}/PKG-INFO

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

{darwin_py-3.5.2 → darwin_py-3.5.3}/darwin/cli.py

@@ -175,6 +175,7 @@ def _run(args: Namespace, parser: ArgumentParser) -> None:
                 args.retry_timeout,
                 args.retry_interval,
                 args.team,
+                multi_processed=not args.no_multi_processed,
             )
         elif args.action == "import":
             f.dataset_import(

{darwin_py-3.5.2 → darwin_py-3.5.3}/darwin/cli_functions.py

@@ -364,6 +364,7 @@ def pull_dataset(
     retry_timeout: int = 600,
     retry_interval: int = 10,
     team: Optional[str] = None,
+    multi_processed: bool = True,
 ) -> None:
     """
     Downloads a remote dataset (images and annotations) in the datasets directory.
@@ -392,6 +393,9 @@ def pull_dataset(
         If retrying, time to wait between retries of checking if the release is ready for download.
     team: Optional[str]
         Specify the team to use for the operation.
+    multi_processed: bool
+        If True (default), uses multiprocessing to download files in parallel.
+        If False, the dataset is downloaded on a single process.
     """
     identifier: DatasetIdentifier = DatasetIdentifier.parse(dataset_slug)
     if team:
@@ -427,6 +431,7 @@ def pull_dataset(
             retry=retry,
             retry_timeout=retry_timeout,
             retry_interval=retry_interval,
+            multi_processed=multi_processed,
         )
         print_new_version_info(client)
     except NotFound:
@@ -1512,7 +1517,7 @@ def print_new_version_info(client: Optional[Client] = None) -> None:
     if not client or not client.newer_darwin_version:
         return
 
-    (a, b, c) = tuple(client.newer_darwin_version)
+    a, b, c = tuple(client.newer_darwin_version)
 
     console = Console(theme=_console_theme(), stderr=True)
     console.print(

{darwin_py-3.5.2 → darwin_py-3.5.3}/darwin/datatypes.py

@@ -23,7 +23,7 @@ from pydantic import BaseModel
 try:
     from numpy.typing import NDArray
 except ImportError:
-    NDArray = Any  # type:ignore
+    NDArray = Any  # type: ignore
 
 if TYPE_CHECKING:
     from darwin.client import Client
@@ -33,6 +33,8 @@ from darwin.future.data_objects.properties import (
     PropertyGranularity,
     PropertyType,
     SelectedProperty,
+    TriggerCondition,
+    property_key,
 )
 from darwin.path_utils import construct_full_path, is_properties_enabled, parse_metadata
 
@@ -42,7 +44,7 @@ NumberLike = Union[
     int, float
 ]  # Used for functions that can take either an int or a float
 # Used for functions that _genuinely_ don't know what type they're dealing with, such as those that test if something is of a certain type.
-UnknownType = Any  # type:ignore
+UnknownType = Any  # type: ignore
 
 # Specific types
 
@@ -492,6 +494,37 @@ class Property:
     # Granularity of the property
     granularity: PropertyGranularity = PropertyGranularity("section")
 
+    # Name of the parent property as declared in ``.v7/metadata.json``.
+    parent_name: Optional[str] = None
+
+    # Name-based trigger condition (parent value names).
+    trigger_condition: Optional[TriggerCondition] = None
+
+    @classmethod
+    def from_metadata_dict(cls, p: dict[str, Any]) -> "Property":
+        """
+        Build a ``Property`` from a ``.v7/metadata.json`` entry. Raises
+        ``ValueError`` when ``parent_name`` and ``trigger_condition`` are
+        not both set or both omitted.
+        """
+        parent_name = p.get("parent_name")
+        raw_trigger = p.get("trigger_condition")
+        _validate_property_metadata_nesting(parent_name, raw_trigger)
+        return cls(
+            name=p["name"],
+            type=p["type"],
+            required=p["required"],
+            property_values=p["property_values"],
+            description=p.get("description"),
+            granularity=PropertyGranularity(p.get("granularity", "section")),
+            parent_name=parent_name,
+            trigger_condition=(
+                TriggerCondition.model_validate(raw_trigger)
+                if raw_trigger is not None
+                else None
+            ),
+        )
+
 
 @dataclass
 class PropertyClass:
@@ -503,6 +536,22 @@ class PropertyClass:
     properties: Optional[list[Property]] = None
 
 
+def _validate_property_metadata_nesting(
+    parent_name: Any, trigger_condition: Any
+) -> None:
+    """
+    Enforce the ``parent_name`` ↔ ``trigger_condition`` invariant for a
+    ``.v7/metadata.json`` property: the two SDK-local nesting fields must be
+    set together or both omitted.
+    """
+    if (parent_name is None) != (trigger_condition is None):
+        raise ValueError(
+            "metadata.json property has inconsistent nesting metadata: "
+            "'parent_name' and 'trigger_condition' must both be present or "
+            "both omitted."
+        )
+
+
 def parse_property_classes(metadata: dict[str, Any]) -> list[PropertyClass]:
     """
     Parses the metadata file and returns a list of PropertyClass objects.
@@ -525,15 +574,7 @@ def parse_property_classes(metadata: dict[str, Any]) -> list[PropertyClass]:
             "properties" in metadata_cls
         ), "Metadata class does not contain properties"
         properties = [
-            Property(
-                name=p["name"],
-                type=p["type"],
-                required=p["required"],
-                property_values=p["property_values"],
-                description=p.get("description"),
-                granularity=PropertyGranularity(p.get("granularity", "section")),
-            )
-            for p in metadata_cls["properties"]
+            Property.from_metadata_dict(p) for p in metadata_cls["properties"]
         ]
         classes.append(
             PropertyClass(
@@ -1664,13 +1705,14 @@ class TeamPropertyLookups:
         self.item_properties = {}
 
         for prop in team_properties:
-            if (
-                prop.granularity.value == "section"
-                or prop.granularity.value == "annotation"
-            ):
-                self.annotation_properties[(prop.name, prop.annotation_class_id)] = prop
-            elif prop.granularity.value == "item":
-                self.item_properties[prop.name] = prop
+            self.register(prop)
+
+    def register(self, prop: FullProperty) -> None:
+        """Place ``prop`` into the appropriate lookup bucket by granularity."""
+        if prop.granularity.value in ("section", "annotation"):
+            self.annotation_properties[property_key(prop)] = prop
+        elif prop.granularity.value == "item":
+            self.item_properties[prop.name] = prop
 
 
 class ReportJob(BaseModel):

{darwin_py-3.5.2 → darwin_py-3.5.3}/darwin/future/data_objects/properties.py

@@ -4,9 +4,9 @@ import json
 import os
 from enum import Enum
 from pathlib import Path
-from typing import List, Literal, Optional, Tuple, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
-from pydantic import field_validator
+from pydantic import field_validator, model_validator
 
 from darwin.future.data_objects.pydantic_base import DefaultDarwin
 
@@ -20,6 +20,49 @@ PropertyType = Literal[
 ]
 
 
+class TriggerCondition(DefaultDarwin):
+    type: Literal["value_match", "any_value"]
+    property_value_ids: Optional[List[str]] = None
+    values: Optional[List[str]] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def _validate_shape(cls, data: Any) -> Any:
+        if not isinstance(data, dict):
+            return data
+        trigger_type = data.get("type")
+        values = data.get("values")
+        property_value_ids = data.get("property_value_ids")
+        if trigger_type == "any_value":
+            if values:
+                raise ValueError(
+                    "trigger_condition.values must be empty/None for 'any_value'"
+                )
+            if property_value_ids:
+                raise ValueError(
+                    "trigger_condition.property_value_ids must be empty/None for 'any_value'"
+                )
+        elif trigger_type == "value_match":
+            if not values and not property_value_ids:
+                raise ValueError(
+                    "trigger_condition must set either 'values' (names) or "
+                    "'property_value_ids' (UUIDs) for 'value_match'"
+                )
+        return data
+
+    def to_api_payload(self) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {"type": self.type}
+        if self.type == "value_match":
+            if not self.property_value_ids:
+                raise ValueError(
+                    "TriggerCondition.to_api_payload requires non-empty "
+                    "property_value_ids for 'value_match'. Resolve "
+                    "'values' (names) to UUIDs first via _resolve_parent_property_for_create."
+                )
+            payload["property_value_ids"] = list(self.property_value_ids)
+        return payload
+
+
 class PropertyGranularity(str, Enum):
     section = "section"
     annotation = "annotation"
@@ -85,11 +128,34 @@ class FullProperty(DefaultDarwin):
     dataset_ids: Optional[List[int]] = None
     options: Optional[List[PropertyValue]] = None
     granularity: PropertyGranularity = PropertyGranularity("section")
+    parent_name: Optional[str] = None
+    parent_property_id: Optional[str] = None
+    trigger_condition: Optional[TriggerCondition] = None
 
     def to_create_endpoint(
         self,
     ) -> dict:
-        include_fields = {
+        if (
+            self.granularity != PropertyGranularity.item
+            and self.annotation_class_id is None
+        ):
+            raise ValueError("annotation_class_id must be set")
+
+        # Nesting fields are coherent: all three set, or none set.
+        nesting_set = (
+            self.parent_name is not None,
+            self.parent_property_id is not None,
+            self.trigger_condition is not None,
+        )
+        if any(nesting_set) and not all(nesting_set):
+            raise ValueError(
+                "parent_name, parent_property_id and trigger_condition must "
+                "all be set or all be None. Resolve parent_name to a "
+                "parent_property_id (and trigger_condition.values to "
+                "property_value_ids) before serialising."
+            )
+
+        include_fields: Dict[str, Any] = {
             "name": True,
             "type": True,
             "required": True,
@@ -99,12 +165,15 @@ class FullProperty(DefaultDarwin):
         if self.type != "text":
             include_fields["property_values"] = {"__all__": {"value", "color", "type"}}
         if self.granularity != PropertyGranularity.item:
-            if self.annotation_class_id is None:
-                raise ValueError("annotation_class_id must be set")
             include_fields["annotation_class_id"] = True
         if self.dataset_ids is not None:
             include_fields["dataset_ids"] = True
-        return self.model_dump(mode="json", include=include_fields)
+
+        payload = self.model_dump(mode="json", include=include_fields)
+        if all(nesting_set):
+            payload["parent_property_id"] = self.parent_property_id
+            payload["trigger_condition"] = self.trigger_condition.to_api_payload()
+        return payload
 
     def to_update_endpoint(self) -> Tuple[str, dict]:
         if self.id is None:
@@ -113,6 +182,10 @@ class FullProperty(DefaultDarwin):
         updated_base = self.to_create_endpoint()
         updated_base.pop("annotation_class_id", None)  # Can't update this field
         del updated_base["granularity"]  # Can't update this field
+        if "parent_property_id" in updated_base:
+            del updated_base["parent_property_id"]
+        if "trigger_condition" in updated_base:
+            del updated_base["trigger_condition"]
         return self.id, updated_base
 
 
@@ -172,3 +245,10 @@ class SelectedProperty(DefaultDarwin):
     name: str
     type: Optional[str] = None
     value: Optional[str] = None
+
+
+PropertyKey = Tuple[str, Optional[int]]
+
+
+def property_key(prop: "FullProperty") -> PropertyKey:
+    return (prop.name, prop.annotation_class_id)