Merge pull request #430 from Labelbox/mani/resource-tags

get_resource_tags and create_project_resource_tags

Author: manibox

labelbox/__init__.py

@@ -23,3 +23,5 @@
 from labelbox.schema.model_run import ModelRun
 from labelbox.schema.benchmark import Benchmark
 from labelbox.schema.iam_integration import IAMIntegration
+from labelbox.schema.resource_tag import ResourceTag
+from labelbox.schema.project_resource_tag import ProjectResourceTag

labelbox/schema/organization.py

@@ -1,10 +1,12 @@
+import json
 from typing import TYPE_CHECKING, List, Optional
 
 from labelbox.exceptions import LabelboxError
 from labelbox import utils
 from labelbox.orm.db_object import DbObject, query, Entity
 from labelbox.orm.model import Field, Relationship
 from labelbox.schema.invite import InviteLimit
+from labelbox.schema.resource_tag import ResourceTag
 
 if TYPE_CHECKING:
     from labelbox import Role, User, ProjectRole, Invite, InviteLimit, IAMIntegration
@@ -42,6 +44,7 @@ def __init__(self, *args, **kwargs):
     users = Relationship.ToMany("User", False)
     projects = Relationship.ToMany("Project", True)
     webhooks = Relationship.ToMany("Webhook", False)
+    resource_tags = Relationship.ToMany("ResourceTags", False)
 
     def invite_user(
             self,
@@ -126,6 +129,43 @@ def remove_user(self, user: "User") -> None:
             updateUser(where: {id: $%s}, data: {deleted: true}) { id deleted }
         }""" % (user_id_param, user_id_param), {user_id_param: user.uid})
 
+    def create_resource_tag(self, tag=None) -> ResourceTag:
+        """
+        Creates a resource tag.
+            >>> tag = {'text': 'tag-1',  'color': 'ffffff'}
+
+        Args:
+            tag (dict): A resource tag {'text': 'tag-1', 'color': 'fffff'}
+        Returns:
+            The created resource tag.
+        """
+        tag_text_param = "text"
+        tag_color_param = "color"
+
+        query_str = """mutation CreateResourceTagPyApi($text:String!,$color:String!) {
+                createResourceTag(input:{text:$%s,color:$%s}) {%s}}
+        """ % (tag_text_param, tag_color_param,
+               query.results_query_part(ResourceTag))
+
+        params = {
+            tag_text_param: tag.get("text", ""),
+            tag_color_param: tag.get("color", "")
+        }
+        res = self.client.execute(query_str, params)
+        return ResourceTag(self.client, res['createResourceTag'])
+
+    def get_resource_tags(self) -> List[ResourceTag]:
+        """
+        Returns all resource tags for an organization
+        """
+        query_str = """query GetOrganizationResourceTagsPyApi{organization{resourceTag{%s}}}""" % (
+            query.results_query_part(ResourceTag))
+
+        return [
+            ResourceTag(self.client, tag) for tag in self.client.execute(
+                query_str)['organization']['resourceTag']
+        ]
+
     def get_iam_integrations(self) -> List["IAMIntegration"]:
         """
         Returns all IAM Integrations for an organization

labelbox/schema/project.py

@@ -18,6 +18,7 @@
 from labelbox.orm.db_object import DbObject, Updateable, Deletable
 from labelbox.orm.model import Entity, Field, Relationship
 from labelbox.pagination import PaginatedCollection
+from labelbox.schema.resource_tag import ResourceTag
 
 if TYPE_CHECKING:
     from labelbox import BulkImportRequest
@@ -121,6 +122,33 @@ def members(self) -> PaginatedCollection:
                                    {id_param: str(self.uid)},
                                    ["project", "members"], ProjectMember)
 
+    def update_project_resource_tags(
+            self, resource_tag_ids: List[str]) -> List[ResourceTag]:
+        """ Creates project resource tags
+
+        Args:
+            resource_tag_ids
+        Returns:
+            a list of ResourceTag ids that was created.
+        """
+        project_id_param = "projectId"
+        tag_ids_param = "resourceTagIds"
+
+        query_str = """mutation UpdateProjectResourceTagsPyApi($%s:ID!,$%s:[String!]) {
+            project(where:{id:$%s}){updateProjectResourceTags(input:{%s:$%s}){%s}}}""" % (
+            project_id_param, tag_ids_param, project_id_param, tag_ids_param,
+            tag_ids_param, query.results_query_part(ResourceTag))
+
+        res = self.client.execute(query_str, {
+            project_id_param: self.uid,
+            tag_ids_param: resource_tag_ids
+        })
+
+        return [
+            ResourceTag(self.client, tag)
+            for tag in res["project"]["updateProjectResourceTags"]
+        ]
+
     def labels(self, datasets=None, order_by=None) -> PaginatedCollection:
         """ Custom relationship expansion method to support limited filtering.
 

labelbox/schema/project_resource_tag.py

@@ -0,0 +1,16 @@
+from labelbox.orm.db_object import DbObject, Updateable
+from labelbox.orm.model import Field, Relationship
+
+
+class ProjectResourceTag(DbObject, Updateable):
+    """ Project resource tag to associate ProjectResourceTag to Project.
+
+    Attributes:
+        resourceTagId (str)
+        projectId (str)
+
+        resource_tag (Relationship): `ToOne` relationship to ResourceTag
+    """
+
+    resource_tag_id = Field.ID("resource_tag_id")
+    project_id = Field.ID("project_id")

labelbox/schema/resource_tag.py

@@ -0,0 +1,16 @@
+from labelbox.orm.db_object import DbObject, Updateable
+from labelbox.orm.model import Field, Relationship
+
+
+class ResourceTag(DbObject, Updateable):
+    """ Resource tag to label and identify your labelbox resources easier.
+
+    Attributes:
+        text (str)
+        color (str)
+
+        project_resource_tag (Relationship): `ToMany` relationship to ProjectResourceTag
+    """
+
+    text = Field.String("text")
+    color = Field.String("color")

tests/integration/test_project.py

@@ -42,8 +42,50 @@ def test_project(client, rand_gen):
     assert project not in final
     assert set(final) == set(before)
 
-    # TODO this should raise ResourceNotFoundError, but it doesn't
-    project = client.get_project(project.uid)
+
+def test_update_project_resource_tags(client, rand_gen):
+    before = list(client.get_projects())
+    for o in before:
+        assert isinstance(o, Project)
+
+    org = client.get_organization()
+    assert org.uid is not None
+
+    project_name = rand_gen(str)
+    p1 = client.create_project(name=project_name)
+    assert p1.uid is not None
+
+    colorA = "#ffffff"
+    textA = rand_gen(str)
+    tag = {"text": textA, "color": colorA}
+
+    colorB = colorA
+    textB = rand_gen(str)
+    tagB = {"text": textB, "color": colorB}
+
+    tagA = client.get_organization().create_resource_tag(tag)
+    assert tagA.text == textA
+    assert '#' + tagA.color == colorA
+    assert tagA.uid is not None
+
+    tags = org.get_resource_tags()
+    lenA = len(tags)
+    assert lenA > 0
+
+    tagB = client.get_organization().create_resource_tag(tagB)
+    assert tagB.text == textB
+    assert '#' + tagB.color == colorB
+    assert tagB.uid is not None
+
+    tags = client.get_organization().get_resource_tags()
+    lenB = len(tags)
+    assert lenB > 0
+    assert lenB > lenA
+
+    project_resource_tag = client.get_project(
+        p1.uid).update_project_resource_tags([str(tagA.uid)])
+    assert len(project_resource_tag) == 1
+    assert project_resource_tag[0].uid == tagA.uid
 
 
 def test_project_filtering(client, rand_gen):