wip

Author: Matt Sokoloff

labelbox/schema/__init__.py

@@ -1,4 +1,5 @@
 import labelbox.schema.asset_metadata
+import labelbox.schema.asset_attachment
 import labelbox.schema.bulk_import_request
 import labelbox.schema.benchmark
 import labelbox.schema.data_row

labelbox/schema/asset_attachment.py

@@ -0,0 +1,25 @@
+from enum import Enum
+from labelbox.orm.db_object import DbObject
+from labelbox.orm.model import Field
+
+class AssetAttachment(DbObject):
+    """ Asset attachment provides extra context about an asset while labeling.
+
+    Attributes:
+        attachment_type (str): IMAGE, VIDEO, TEXT, or IMAGE_OVERLAY
+        attachment_value (str): URL to an external file or a string of text
+    """
+
+    class MetaType(Enum):
+        VIDEO = "VIDEO"
+        IMAGE = "IMAGE"
+        TEXT = "TEXT"
+        IMAGE_OVERLAY = "IMAGE_OVERLAY"
+
+    # For backwards compatibility
+    for topic in MetaType:
+        vars()[topic.name] = topic.value
+
+
+    attachment_type = Field.String("attachment_type")
+    attachment_value = Field.String("attachment_value")

labelbox/schema/asset_metadata.py

@@ -1,8 +1,10 @@
 from enum import Enum
+import logging
 
 from labelbox.orm.db_object import DbObject
 from labelbox.orm.model import Field
 
+logger = logging.getLogger(__name__)
 
 class AssetMetadata(DbObject):
     """ Asset metadata (AKA Attachments) provides extra context about an asset while labeling.
@@ -12,6 +14,12 @@ class AssetMetadata(DbObject):
         meta_value (str): URL to an external file or a string of text
     """
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        logger.warning(
+            "`create_metadata` is deprecated. Use `create_attachment` instead."
+        )
+
     class MetaType(Enum):
         VIDEO = "VIDEO"
         IMAGE = "IMAGE"

labelbox/schema/data_row.py

@@ -1,8 +1,11 @@
 from labelbox.orm import query
 from labelbox.orm.db_object import DbObject, Updateable, BulkDeletable
 from labelbox.orm.model import Entity, Field, Relationship
-from labelbox.schema.asset_metadata import AssetMetadata
+from labelbox.schema.asset_attchment import AssetAttachment
 
+import logging
+
+logger = logging.getLogger(__name__)
 
 class DataRow(DbObject, Updateable, BulkDeletable):
     """ Internal Labelbox representation of a single piece of data (e.g. image, video, text).
@@ -33,12 +36,15 @@ class DataRow(DbObject, Updateable, BulkDeletable):
     created_by = Relationship.ToOne("User", False, "created_by")
     organization = Relationship.ToOne("Organization", False)
     labels = Relationship.ToMany("Label", True)
+
     metadata = Relationship.ToMany("AssetMetadata", False, "metadata")
+    # attachments
+    attachment = Relationship.ToMany("AssetAttachment", False, "attachment")
 
     predictions = Relationship.ToMany("Prediction", False)
 
-    supported_meta_types = {
-        meta_type.value for meta_type in AssetMetadata.MetaType
+    supported_meta_types = supported_attachment_types = {
+        attachment_type.value for attachment_type in AssetAttachment.MetaType
     }
 
     @staticmethod
@@ -54,42 +60,66 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.metadata.supports_filtering = False
         self.metadata.supports_sorting = False
+        self.attachment.supports_filtering = False
+        self.attachment.supports_sorting = False
 
-    def create_metadata(self, meta_type, meta_value):
+    def create_attachment(self, attachment_type, attachment_value):
         """ Attaches asset metadata to a DataRow.
 
-            >>> datarow.create_metadata("TEXT", "This is a text message")
+            >>> datarow.create_attachment("TEXT", "This is a text message")
 
         Args:
-            meta_type (str): Asset metadata type, must be one of:
-                VIDEO, IMAGE, TEXT, IMAGE_OVERLAY (AssetMetadata.MetaType)
-            meta_value (str): Asset metadata value.
+            meta_type (str): Asset attachment type, must be one of:
+                VIDEO, IMAGE, TEXT, IMAGE_OVERLAY (AssetAttachment.AttachmentType)
+            meta_value (str): Asset attachment value.
         Returns:
-            `AssetMetadata` DB object.
+            `AssetAttachment` DB object.
         Raises:
-            ValueError: meta_type must be one of the supported types.
+            ValueError: asset_type must be one of the supported types.
         """
 
-        if meta_type not in self.supported_meta_types:
+        if attachment_type not in self.supported_attachment_types:
             raise ValueError(
-                f"meta_type must be one of {self.supported_meta_types}. Found {meta_type}"
+                f"meta_type must be one of {self.supported_attachment_types}. Found {attachment_type}"
             )
 
-        meta_type_param = "metaType"
-        meta_value_param = "metaValue"
+        attachment_type_param = "type"
+        attachment_value_param = "value"
         data_row_id_param = "dataRowId"
-        query_str = """mutation CreateAssetMetadataPyApi(
+        query_str = """mutation CreateDataRowAttachmentPyApi(
             $%s: AttachmentType!, $%s: String!, $%s: ID!) {
-            createAssetMetadata(data: {
-                metaType: $%s metaValue: $%s dataRowId: $%s}) {%s}} """ % (
-            meta_type_param, meta_value_param, data_row_id_param,
-            meta_type_param, meta_value_param, data_row_id_param,
+            createDataRowAttachment(data: {
+                type: $%s value: $%s dataRowId: $%s}) {%s}} """ % (
+            attachment_type_param, attachment_value_param, data_row_id_param,
+            attachment_type_param, attachment_value_param, data_row_id_param,
             query.results_query_part(Entity.AssetMetadata))
 
         res = self.client.execute(
             query_str, {
-                meta_type_param: meta_type,
-                meta_value_param: meta_value,
+                attachment_type_param: meta_type,
+                attachment_value_param: meta_value,
                 data_row_id_param: self.uid
             })
+        return Entity.AssetAttachment(self.client, res["createAssetMetadata"])
+
+
+createDataRowAttachment(data: DataRowAttachmentCreateInput!): DataRowAttachment!
+  deleteDataRowAttachment(where: WhereUniqueIdInput!): DataRowAttachment!
+  updateDataRowAttachment
+
+
+
+    def create_metadata(self, meta_type, meta_value):
+        """
+
+        This function is deprecated. Use create_attachment instead
+
+        Returns:
+            AssetMetadata
+        """
+        logger.warning(
+            "`create_metadata` is deprecated. Use `create_attachment` instead."
+        )
+
+        attachment = self.create_attachment(meta_type, meta_value)
         return Entity.AssetMetadata(self.client, res["createAssetMetadata"])

labelbox/schema/organization.py

@@ -103,10 +103,10 @@ def invite_limit(self) -> InviteLimit:
         """ Retrieve invite limits for the org
         This already accounts for users currently in the org
         Meaining that  `used = users + invites, remaining = limit - (users + invites)`
-       
+
         Returns:
             InviteLimit
-    
+
         """
         org_id_param = "organizationId"
         res = self.client.execute("""query InvitesLimitPyApi($%s: ID!) {