Merge pull request #304 from Labelbox/gj/fix-number-type

Metadata GA changes

Author: Gareth

examples/basics/data_row_metadata.ipynb

@@ -87,16 +87,14 @@
     "    DataRowMetadata,\n",
     "    DataRowMetadataField,\n",
     "    DeleteDataRowMetadata,\n",
-    "    DataRowMetadataKind\n",
     ")\n",
     "from sklearn.random_projection import GaussianRandomProjection\n",
+    "import tensorflow as tf\n",
     "import seaborn as sns\n",
-    "from datetime import datetime\n",
-    "from pprint import pprint\n",
     "import tensorflow_hub as hub\n",
+    "from datetime import datetime\n",
     "from tqdm.notebook import tqdm\n",
     "import requests\n",
-    "import tensorflow as tf\n",
     "from pprint import pprint"
    ]
   },
@@ -154,7 +152,7 @@
    "outputs": [],
    "source": [
     "# dictionary access with id\n",
-    "pprint(mdo.all_fields_id_index, indent=2)"
+    "pprint(mdo.fields_by_id, indent=2)"
    ]
   },
   {
@@ -167,7 +165,8 @@
    "outputs": [],
    "source": [
     "# access by name\n",
-    "split_field = mdo.reserved_name_index[\"split\"]"
+    "split_field = mdo.reserved_by_name[\"split\"]\n",
+    "train_field = mdo.reserved_by_name[\"split\"][\"train\"]"
    ]
   },
   {
@@ -191,7 +190,7 @@
    },
    "outputs": [],
    "source": [
-    "tag_field = mdo.reserved_name_index[\"tag\"]"
+    "tag_field = mdo.reserved_by_name[\"tag\"]"
    ]
   },
   {
@@ -286,7 +285,7 @@
    "outputs": [],
    "source": [
     "field = DataRowMetadataField(\n",
-    "    schema_id=mdo.reserved_name_index[\"captureDateTime\"].id,  # specify the schema id\n",
+    "    schema_id=mdo.reserved_by_name[\"captureDateTime\"].id,  # specify the schema id\n",
     "    value=datetime.now(), # typed inputs\n",
     ")\n",
     "# Completed object ready for upload\n",
@@ -356,11 +355,11 @@
     "    # assign datarows a split\n",
     "    rnd = random.random()\n",
     "    if rnd < test:\n",
-    "        split = \"cko8scbz70005h2dkastwhgqt\"\n",
+    "        split = mdo.reserved_by_name[\"split\"][\"test\"]\n",
     "    elif rnd < valid:\n",
-    "        split = \"cko8sc2yr0004h2dk69aj5x63\"\n",
+    "        split = mdo.reserved_by_name[\"split\"][\"valid\"]\n",
     "    else:\n",
-    "        split = \"cko8sbscr0003h2dk04w86hof\"\n",
+    "        split = mdo.reserved_by_name[\"split\"][\"train\"]\n",
     "    \n",
     "    embeddings.append(list(model(processor(response.content), training=False)[0].numpy()))\n",
     "    dt = datetime.utcnow() \n",
@@ -371,15 +370,15 @@
     "            data_row_id=datarow.uid,\n",
     "            fields=[\n",
     "                DataRowMetadataField(\n",
-    "                    schema_id=mdo.reserved_name_index[\"captureDateTime\"].id,\n",
+    "                    schema_id=mdo.reserved_by_name[\"captureDateTime\"].uid,\n",
     "                    value=dt,\n",
     "                ),\n",
     "                DataRowMetadataField(\n",
-    "                    schema_id=mdo.reserved_name_index[\"split\"].id,\n",
+    "                    schema_id=mdo.reserved_by_name[\"split\"].uid,\n",
     "                    value=split\n",
     "                ),\n",
     "                DataRowMetadataField(\n",
-    "                    schema_id=mdo.reserved_name_index[\"tag\"].id,\n",
+    "                    schema_id=mdo.reserved_by_name[\"tag\"].uid,\n",
     "                        value=message\n",
     "                ),\n",
     "            ]\n",
@@ -438,7 +437,7 @@
     "for md, embd in zip(uploads, projected):\n",
     "    md.fields.append(\n",
     "        DataRowMetadataField(\n",
-    "            schema_id=mdo.reserved_name_index[\"embedding\"].id,\n",
+    "            schema_id=mdo.reserved_by_name[\"embedding\"].uid,\n",
     "            value=embd.tolist(), # convert from numpy to list\n",
     "        ),\n",
     "    )"
@@ -568,7 +567,7 @@
     "fields = []\n",
     "# iterate through the fields you want to delete\n",
     "for field in md.fields:\n",
-    "    schema = mdo.all_fields_id_index[field.schema_id]\n",
+    "    schema = mdo.field_by_index[field.schema_id]\n",
     "    fields.append(field.schema_id)\n",
     "\n",
     "deletes = DeleteDataRowMetadata(\n",
@@ -650,4 +649,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

labelbox/schema/data_row_metadata.py

@@ -1,5 +1,6 @@
 # type: ignore
 import datetime
+import warnings
 from enum import Enum
 from itertools import chain
 from typing import List, Optional, Dict, Union, Callable, Type, Any, Generator
@@ -9,8 +10,11 @@
 from labelbox.schema.ontology import SchemaId
 from labelbox.utils import camel_case
 
+_MAX_METADATA_FIELDS = 5
+
 
 class DataRowMetadataKind(Enum):
+    number = "CustomMetadataNumber"
     datetime = "CustomMetadataDateTime"
     enum = "CustomMetadataEnum"
     string = "CustomMetadataString"
@@ -20,13 +24,18 @@ class DataRowMetadataKind(Enum):
 
 # Metadata schema
 class DataRowMetadataSchema(BaseModel):
-    id: SchemaId
+    uid: SchemaId
     name: constr(strip_whitespace=True, min_length=1, max_length=100)
     reserved: bool
     kind: DataRowMetadataKind
     options: Optional[List["DataRowMetadataSchema"]]
     parent: Optional[SchemaId]
 
+    @property
+    def id(self):
+        warnings.warn("`id` is being deprecated in favor of `uid`")
+        return self.uid
+
 
 DataRowMetadataSchema.update_forward_refs()
 
@@ -35,8 +44,9 @@ class DataRowMetadataSchema(BaseModel):
 DateTime: Type[datetime.datetime] = datetime.datetime  # must be in UTC
 String: Type[str] = constr(max_length=500)
 OptionId: Type[SchemaId] = SchemaId  # enum option
+Number: Type[float] = float
 
-DataRowMetadataValue = Union[Embedding, DateTime, String, OptionId]
+DataRowMetadataValue = Union[Embedding, DateTime, String, OptionId, Number]
 
 
 class _CamelCaseMixin(BaseModel):
@@ -106,44 +116,59 @@ class DataRowMetadataOntology:
     """
 
     def __init__(self, client):
-        self.client = client
-        self._batch_size = 50
 
-        # TODO: consider making these properties to stay in sync with server
+        self._client = client
+        self._batch_size = 50  # used for uploads and deletes
+
         self._raw_ontology = self._get_ontology()
+
         # all fields
-        self.all_fields = self._parse_ontology()
-        self.all_fields_id_index = self._make_id_index(self.all_fields)
+        self.fields = self._parse_ontology()
+        self.fields_by_id = self._make_id_index(self.fields)
+
         # reserved fields
         self.reserved_fields: List[DataRowMetadataSchema] = [
-            f for f in self.all_fields if f.reserved
+            f for f in self.fields if f.reserved
         ]
-        self.reserved_id_index = self._make_id_index(self.reserved_fields)
-        self.reserved_name_index: Dict[str, DataRowMetadataSchema] = {
+        self.reserved_by_id = self._make_id_index(self.reserved_fields)
+        self.reserved_by_name: Dict[str, DataRowMetadataSchema] = {
             f.name: f for f in self.reserved_fields
         }
+
         # custom fields
         self.custom_fields: List[DataRowMetadataSchema] = [
-            f for f in self.all_fields if not f.reserved
+            f for f in self.fields if not f.reserved
         ]
-        self.custom_id_index = self._make_id_index(self.custom_fields)
-        self.custom_name_index: Dict[str, DataRowMetadataSchema] = {
+        self.custom_by_id = self._make_id_index(self.custom_fields)
+        self.custom_by_name: Dict[str, DataRowMetadataSchema] = {
             f.name: f for f in self.custom_fields
         }
 
+    @staticmethod
+    def _make_name_index(fields: List[DataRowMetadataSchema]):
+        index = {}
+        for f in fields:
+            if f.options:
+                index[f.name] = {}
+                for o in f.options:
+                    index[o.name] = o
+            else:
+                index[f.name] = f
+        return index
+
     @staticmethod
     def _make_id_index(
         fields: List[DataRowMetadataSchema]
     ) -> Dict[SchemaId, DataRowMetadataSchema]:
         index = {}
         for f in fields:
-            index[f.id] = f
+            index[f.uid] = f
             if f.options:
                 for o in f.options:
-                    index[o.id] = o
+                    index[o.uid] = o
         return index
 
-    def _get_ontology(self) -> Dict[str, Any]:
+    def _get_ontology(self) -> List[Dict[str, Any]]:
         query = """query GetMetadataOntologyBetaPyApi {
         customMetadataOntology {
                 id
@@ -158,21 +183,24 @@ def _get_ontology(self) -> Dict[str, Any]:
                 }
         }}
         """
-        return self.client.execute(query)["customMetadataOntology"]
+        return self._client.execute(query)["customMetadataOntology"]
 
     def _parse_ontology(self) -> List[DataRowMetadataSchema]:
         fields = []
         for schema in self._raw_ontology:
+            schema["uid"] = schema.pop("id")
             options = None
             if schema.get("options"):
-                options = [
-                    DataRowMetadataSchema(**{
-                        **option,
-                        **{
-                            "parent": schema["id"]
-                        }
-                    }) for option in schema["options"]
-                ]
+                options = []
+                for option in schema["options"]:
+                    option["uid"] = option.pop("id")
+                    options.append(
+                        DataRowMetadataSchema(**{
+                            **option,
+                            **{
+                                "parent": schema["uid"]
+                            }
+                        }))
             schema["options"] = options
             fields.append(DataRowMetadataSchema(**schema))
 
@@ -184,7 +212,7 @@ def parse_metadata(
                                              Dict]]]]) -> List[DataRowMetadata]:
         """ Parse metadata responses
 
-        >>> mdo.parse_metadata([datarow.metadata])
+        >>> mdo.parse_metadata([metdata])
 
         Args:
             unparsed: An unparsed metadata export
@@ -200,14 +228,14 @@ def parse_metadata(
         for dr in unparsed:
             fields = []
             for f in dr["fields"]:
-                schema = self.all_fields_id_index[f["schemaId"]]
+                schema = self.fields_by_id[f["schemaId"]]
                 if schema.kind == DataRowMetadataKind.enum:
                     continue
                 elif schema.kind == DataRowMetadataKind.option:
                     field = DataRowMetadataField(schema_id=schema.parent,
-                                                 value=schema.id)
+                                                 value=schema.uid)
                 else:
-                    field = DataRowMetadataField(schema_id=schema.id,
+                    field = DataRowMetadataField(schema_id=schema.uid,
                                                  value=f["value"])
 
                 fields.append(field)
@@ -254,7 +282,7 @@ def _batch_upsert(
                     }
                 }
             }"""
-            res = self.client.execute(
+            res = self._client.execute(
                 query, {"metadata": upserts})['upsertDataRowCustomMetadata']
             return [
                 DataRowMetadataBatchResponse(data_row_id=r['dataRowId'],
@@ -265,6 +293,10 @@ def _batch_upsert(
 
         items = []
         for m in metadata:
+            if len(m.fields) > _MAX_METADATA_FIELDS:
+                raise ValueError(
+                    f"Cannot upload {len(m.fields)}, the max number is {_MAX_METADATA_FIELDS}"
+                )
             items.append(
                 _UpsertBatchDataRowMetadata(
                     data_row_id=m.data_row_id,
@@ -317,7 +349,7 @@ def _batch_delete(
                 }
             }
             """
-            res = self.client.execute(
+            res = self._client.execute(
                 query, {"deletes": deletes})['deleteDataRowCustomMetadata']
             failures = []
             for dr in res:
@@ -360,7 +392,7 @@ def _bulk_export(_data_row_ids: List[str]) -> List[DataRowMetadata]:
             }
             """
             return self.parse_metadata(
-                self.client.execute(
+                self._client.execute(
                     query,
                     {"dataRowIds": _data_row_ids})['dataRowCustomMetadata'])
 
@@ -373,11 +405,11 @@ def _parse_upsert(
     ) -> List[_UpsertDataRowMetadataInput]:
         """Format for metadata upserts to GQL"""
 
-        if metadatum.schema_id not in self.all_fields_id_index:
+        if metadatum.schema_id not in self.fields_by_id:
             raise ValueError(
                 f"Schema Id `{metadatum.schema_id}` not found in ontology")
 
-        schema = self.all_fields_id_index[metadatum.schema_id]
+        schema = self.fields_by_id[metadatum.schema_id]
 
         if schema.kind == DataRowMetadataKind.datetime:
             parsed = _validate_parse_datetime(metadatum)
@@ -388,7 +420,7 @@ def _parse_upsert(
         elif schema.kind == DataRowMetadataKind.enum:
             parsed = _validate_enum_parse(schema, metadatum)
         elif schema.kind == DataRowMetadataKind.option:
-            raise ValueError("An option id should not be as a schema id")
+            raise ValueError("An Option id should not be set as the Schema id")
         else:
             raise ValueError(f"Unknown type: {schema}")
 
@@ -400,16 +432,16 @@ def _validate_delete(self, delete: DeleteDataRowMetadata):
 
         deletes = set()
         for schema_id in delete.fields:
-            if schema_id not in self.all_fields_id_index:
+            if schema_id not in self.fields_by_id:
                 raise ValueError(
                     f"Schema Id `{schema_id}` not found in ontology")
 
-            schema = self.all_fields_id_index[schema_id]
+            schema = self.fields_by_id[schema_id]
             # handle users specifying enums by adding all option enums
             if schema.kind == DataRowMetadataKind.enum:
-                [deletes.add(o.id) for o in schema.options]
+                [deletes.add(o.uid) for o in schema.options]
 
-            deletes.add(schema.id)
+            deletes.add(schema.uid)
 
         return _DeleteBatchDataRowMetadata(
             data_row_id=delete.data_row_id,
@@ -458,7 +490,7 @@ def _validate_enum_parse(
         schema: DataRowMetadataSchema,
         field: DataRowMetadataField) -> List[Dict[str, Union[SchemaId, dict]]]:
     if schema.options:
-        if field.value not in {o.id for o in schema.options}:
+        if field.value not in {o.uid for o in schema.options}:
             raise ValueError(
                 f"Option `{field.value}` not found for {field.schema_id}")
     else: