consistent query format

Author: Matt Sokoloff

labelbox/client.py

@@ -126,7 +126,7 @@ def convert_value(value):
 
             if experimental:
                 endpoint = self.endpoint.replace('graphql', '_gql')
-                logger.warn(
+                logger.info(
                     "Experimental queries/mutations aren't guarenteed to maintain their interface."
                 )
 

labelbox/pagination.py

@@ -64,26 +64,23 @@ def get_next_cursor(self, results):
             results = results[path]
         return results
 
+    def get_query(self):
+        if self.cursor_path:
+            # Cursor Pagination
+            self.params.update({'from': self.next_cursor, 'first': _PAGE_SIZE})
+            return self.query
+
+        # Offset Pagination
+        return self.query % (self._fetched_pages * _PAGE_SIZE, _PAGE_SIZE)
+
     def __next__(self):
         if len(self._data) <= self._data_ind:
             if self._fetched_all:
                 raise StopIteration()
 
-            if self.cursor_path:
-                # Cursor Pagination
-                self.params.update({
-                    'from': self.next_cursor,
-                    'first': _PAGE_SIZE
-                })
-                query = self.query
-            else:
-                # Offset Pagination
-                query = self.query % (self._fetched_pages * _PAGE_SIZE,
-                                      _PAGE_SIZE)
-
             self._fetched_pages += 1
 
-            results = self.client.execute(query,
+            results = self.client.execute(self.get_query(),
                                           self.params,
                                           experimental=self.experimental)
             page_data = self.get_page_data(results)

labelbox/schema/organization.py

@@ -72,8 +72,10 @@ def _assign_user_role(self, email: str, role: Role,
         if self.client.get_user().email == email:
             raise ValueError("Cannot update your own role")
 
-        query_str = """mutation createInvitesPyApi($data: [CreateInviteInput!]){
-                    createInvites(data: $data){  invite { id createdAt organizationRoleName inviteeEmail}}}"""
+        data_param = "data"
+        query_str = """mutation createInvitesPyApi($%s: [CreateInviteInput!]){
+                    createInvites(data: $%s){  invite { id createdAt organizationRoleName inviteeEmail}}}""" % (
+            data_param, data_param)
 
         projects = [{
             "projectId": x.project.uid,
@@ -82,7 +84,7 @@ def _assign_user_role(self, email: str, role: Role,
 
         res = self.client.execute(
             query_str, {
-                'data': [{
+                data_param: [{
                     "inviterId": self.client.get_user().uid,
                     "inviteeEmail": email,
                     "organizationId": self.uid,
@@ -168,12 +170,11 @@ def invite_limit(self) -> InviteLimit:
             InviteLimit
     
         """
-
-        res = self.client.execute(
-            """query InvitesLimitPyApi($organizationId: ID!) {
-            invitesLimit(where: {id: $organizationId}) { used limit remaining }
-        }""", {"organizationId": self.uid},
-            experimental=True)
+        org_id_param = "organizationId"
+        res = self.client.execute("""query InvitesLimitPyApi($%s: ID!) {
+            invitesLimit(where: {id: $%s}) { used limit remaining }
+        }""" % (org_id_param, org_id_param), {org_id_param: self.uid},
+                                  experimental=True)
         return InviteLimit(
             **{utils.snake_case(k): v for k, v in res['invitesLimit'].items()})
 
@@ -188,7 +189,8 @@ def remove_user(self, user: User):
         if not isinstance(user, User):
             raise TypeError(f"Expected user to be of type User, found {user}")
 
+        user_id_param = "userId"
         self.client.execute(
-            """mutation DeleteMemberPyApi($id: ID!) {
-            updateUser(where: {id: $id}, data: {deleted: true}) { id deleted }
-        }""", {'id': user.uid})
+            """mutation DeleteMemberPyApi($%s: ID!) {
+            updateUser(where: {id: $%s}, data: {deleted: true}) { id deleted }
+        }""" % (user_id_param, user_id_param), {user_id_param: user.uid})

labelbox/schema/project.py

@@ -86,15 +86,16 @@ def invites(self):
             A `PaginatedCollection` of `ProjectInvite`s.
 
         """
-
-        query_str = """query GetProjectInvitationsPyApi($from: ID, $first: PageSize, $projectId: ID!) {
-                project(where: {id: $projectId}) {id
-                invites(from: $from, first: $first) { nodes { id createdAt organizationRoleName inviteeEmail
+        id_param = "projectId"
+        query_str = """query GetProjectInvitationsPyApi($from: ID, $first: PageSize, $%s: ID!) {
+                project(where: {id: $%s}) {id
+                invites(from: $from, first: $first) { nodes { %s
                 projectInvites { projectId projectRoleName } } nextCursor}}}
-        """
+        """ % (id_param, id_param, query.results_query_part(Entity.Invite))
+
         return PaginatedCollection(
             self.client,
-            query_str, {"projectId": self.uid}, ['project', 'invites', 'nodes'],
+            query_str, {id_param: self.uid}, ['project', 'invites', 'nodes'],
             Invite,
             cursor_path=['project', 'invites', 'nextCursor'],
             experimental=True)

labelbox/schema/user.py

@@ -50,13 +50,16 @@ def update_org_role(self, role: Role):
             role (Role): The role that you want to set for this user.
 
         """
+        user_id_param = "userId"
+        role_id_param = "roleId"
+        query_str = """mutation SetOrganizationRolePyApi($%s: ID!, $%s: ID!) { 
+            setOrganizationRole(data: {userId: $userId, roleId: $roleId}) { id name }}
+        """ % (user_id_param, role_id_param)
 
-        self.client.execute(
-            """mutation SetOrganizationRolePyApi($userId: ID!, $roleId: ID!) { setOrganizationRole(data: {userId: $userId, roleId: $roleId}) { id name }}""",
-            {
-                "userId": self.uid,
-                "roleId": role.uid
-            })
+        self.client.execute(query_str, {
+            user_id_param: self.uid,
+            role_id_param: role.uid
+        })
 
     def remove_from_project(self, project: Project):
         """ Removes a User from a project. Only used for project based users.
@@ -87,11 +90,17 @@ def upsert_project_role(self, project: Project, role: Role):
         if not isinstance(project, Project):
             raise TypeError(f"Must provide a `Project` object. Found {project}")
 
+        project_id_param = "projectId"
+        user_id_param = "userId"
+        role_id_param = "roleId"
+        query_str = """mutation SetProjectMembershipPyApi($%s: ID!, $%s: ID!, $%s: ID!) {
+                setProjectMembership(data: {%s: $userId, roleId: $%s, projectId: $%s}) {id}}
+        """ % (user_id_param, role_id_param, project_id_param, user_id_param,
+               role_id_param, project_id_param)
+
         self.client.execute(
-            """mutation SetProjectMembershipPyApi($projectId: ID!, $userId: ID!, $roleId: ID!) {
-                setProjectMembership(data: {userId: $userId, roleId: $roleId, projectId: $projectId}) {id}}
-        """, {
-                "projectId": project.uid,
-                "roleId": role.uid,
-                "userId": self.uid
+            query_str, {
+                project_id_param: project.uid,
+                user_id_param: self.uid,
+                role_id_param: role.uid
             })