recommended changes

Author: Matt Sokoloff

labelbox/client.py

@@ -37,7 +37,7 @@ class Client:
     def __init__(self,
                  api_key=None,
                  endpoint='https://api.labelbox.com/graphql',
-                 enable_beta=False):
+                 enable_experimental=False):
         """ Creates and initializes a Labelbox Client.
 
         Logging is defaulted to level WARNING. To receive more verbose
@@ -50,7 +50,7 @@ def __init__(self,
         Args:
             api_key (str): API key. If None, the key is obtained from the "LABELBOX_API_KEY" environment variable.
             endpoint (str): URL of the Labelbox server to connect to.
-            enable_beta (bool): Indicated whether or not to use beta features
+            enable_experimental (bool): Indicated whether or not to use experimental features
         Raises:
             labelbox.exceptions.AuthenticationError: If no `api_key`
                 is provided as an argument or via the environment
@@ -63,9 +63,9 @@ def __init__(self,
             api_key = os.environ[_LABELBOX_API_KEY]
         self.api_key = api_key
 
-        self.enable_beta = True
-        if enable_beta:
-            logger.info("Beta features have been enabled")
+        self.enable_experimental = enable_experimental
+        if enable_experimental:
+            logger.info("Experimental features have been enabled")
 
         logger.info("Initializing Labelbox client at '%s'", endpoint)
         self.endpoint = endpoint
@@ -78,7 +78,7 @@ def __init__(self,
 
     @retry.Retry(predicate=retry.if_exception_type(
         labelbox.exceptions.InternalServerError))
-    def execute(self, query, params=None, timeout=30.0, beta=False):
+    def execute(self, query, params=None, timeout=30.0, experimental=False):
         """ Sends a request to the server for the execution of the
         given query.
 
@@ -125,7 +125,7 @@ def convert_value(value):
 
         try:
             response = requests.post(self.endpoint.replace('/graphql', '/_gql')
-                                     if beta else self.endpoint,
+                                     if experimental else self.endpoint,
                                      data=data,
                                      headers=self.headers,
                                      timeout=timeout)
@@ -213,9 +213,9 @@ def check_errors(keywords, *path):
         if internal_server_error is not None:
             message = internal_server_error.get("message")
 
-            if message.startswith("Syntax Error"):
+            if message.startswith("Syntax Error") or message.startswith(
+                    "Invite(s) cannot be sent"):
                 raise labelbox.exceptions.InvalidQueryError(message)
-
             else:
                 raise labelbox.exceptions.InternalServerError(message)
 

labelbox/orm/db_object.py

@@ -256,14 +256,14 @@ def delete(self):
         type(self).bulk_delete([self])
 
 
-def beta(fn):
+def experimental(fn):
 
     @wraps(fn)
     def wrapper(self, *args, **kwargs):
-        if not self.client.enable_beta:
+        if not self.client.enable_experimental:
             raise Exception(
-                f"This function {fn.__name__} relies on a beta feature in the api. This means that the interface could change."
-                " Set `enable_beta=True` in the client to enable use of beta functions."
+                f"This function {fn.__name__} relies on a experimental feature in the api. This means that the interface could change."
+                " Set `enable_experimental=True` in the client to enable use of experimental functions."
             )
         return fn(self, *args, **kwargs)
 

labelbox/pagination.py

@@ -1,6 +1,6 @@
 # Size of a single page in a paginated query.
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type
 
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
@@ -24,9 +24,9 @@ def __init__(self,
                  query: str,
                  params: Dict[str, str],
                  dereferencing: Dict[str, Any],
-                 obj_class: "DbObject",
+                 obj_class: Type["DbObject"],
                  cursor_path: Optional[Dict[str, Any]] = None,
-                 beta: bool = False):
+                 experimental: bool = False):
         """ Creates a PaginatedCollection.
 
         Args:
@@ -43,98 +43,117 @@ def __init__(self,
             cursor_path: If not None, this is used to find the cursor
             experimental: Used to call experimental endpoints
         """
-        self.client = client
-        self.query = query
-        self.params = params
-        self.dereferencing = dereferencing
-        self.obj_class = obj_class
-        self.cursor_path = cursor_path
-        self.beta = beta
-
         self._fetched_all = False
         self._data: List[Dict[str, Any]] = []
         self._data_ind = 0
 
+        pagination_kwargs = {
+            'client': client,
+            'obj_class': obj_class,
+            'dereferencing': dereferencing,
+            'experimental': experimental,
+            'query': query,
+            'params': params
+        }
+
         self.paginator = _CursorPagination(
-            client, cursor_path) if cursor_path else _OffsetPagination(client)
+            cursor_path, **
+            pagination_kwargs) if cursor_path else _OffsetPagination(
+                **pagination_kwargs)
 
     def __iter__(self):
         self._data_ind = 0
         return self
 
-    def get_page_data(self, results):
-        for deref in self.dereferencing:
-            results = results[deref]
-        return [self.obj_class(self.client, result) for result in results]
-
     def __next__(self):
         if len(self._data) <= self._data_ind:
             if self._fetched_all:
                 raise StopIteration()
 
-            results = self.paginator.fetch_results(self.query, self.params,
-                                                   self.beta)
-            page_data = self.get_page_data(results)
+            page_data, self._fetched_all = self.paginator.get_next_page()
             self._data.extend(page_data)
-            n_items = len(page_data)
-
-            if n_items == 0:
+            if len(page_data) == 0:
                 raise StopIteration()
 
-            self._fetched_all = self.paginator.fetched_all(n_items, results)
-
         rval = self._data[self._data_ind]
         self._data_ind += 1
         return rval
 
 
 class _Pagination(ABC):
 
-    @abstractmethod
-    def fetched_all(self, n_items: int, results: List[Dict[str, Any]]) -> bool:
-        ...
+    def __init__(self, client: "Client", obj_class: Type["DbObject"],
+                 dereferencing: Dict[str, Any], query: str,
+                 params: Dict[str, Any], experimental: bool):
+        self.client = client
+        self.obj_class = obj_class
+        self.dereferencing = dereferencing
+        self.experimental = experimental
+        self.query = query
+        self.params = params
+
+    def get_page_data(self, results: Dict[str, Any]) -> List["DbObject"]:
+        for deref in self.dereferencing:
+            results = results[deref]
+        return [self.obj_class(self.client, result) for result in results]
 
     @abstractmethod
-    def fetch_results(self, query: str, params: Dict[str, Any],
-                      beta: bool) -> Dict[str, Any]:
+    def get_next_page(self) -> Tuple[Dict[str, Any], bool]:
         ...
 
 
 class _CursorPagination(_Pagination):
 
-    def __init__(self, client: "Client", cursor_path: Dict[str, Any]):
-        self.client = client
+    def __init__(self, cursor_path: Dict[str, Any], *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self.cursor_path = cursor_path
-        self.next_cursor: Optional[str] = None
+        self.next_cursor: Optional[Any] = None
 
-    def get_next_cursor(self, results) -> Optional[str]:
+    def increment_page(self, results: Dict[str, Any]):
         for path in self.cursor_path:
             results = results[path]
-        return results
+        self.next_cursor = results
 
-    def fetched_all(self, n_items: int, results: List[Dict[str, Any]]) -> bool:
-        self.next_cursor = self.get_next_cursor(results)
-        return bool(self.next_cursor is None)
+    def fetched_all(self) -> bool:
+        return bool(self.next_cursor)
 
-    def fetch_results(self, query: str, params: Dict[str, Any],
-                      beta: bool) -> Dict[str, Any]:
-        params.update({'from': self.next_cursor, 'first': _PAGE_SIZE})
-        return self.client.execute(query, params, beta=beta)
+    def fetch_results(self) -> Dict[str, Any]:
+        self.params.update({'from': self.next_cursor, 'first': _PAGE_SIZE})
+        return self.client.execute(self.query,
+                                   self.params,
+                                   experimental=self.experimental)
+
+    def get_next_page(self):
+        results = self.fetch_results()
+        page_data = self.get_page_data(results)
+        self.increment_page(results)
+        done = self.fetched_all()
+        return page_data, done
 
 
 class _OffsetPagination(_Pagination):
 
-    def __init__(self, client: "Client"):
-        self.client = client
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self._fetched_pages = 0
 
-    def fetched_all(self, n_items: int, results: List[Dict[str, Any]]) -> bool:
+    def increment_page(self):
         self._fetched_pages += 1
+
+    def fetched_all(self, n_items: int) -> bool:
         if n_items < _PAGE_SIZE:
             return True
         return False
 
-    def fetch_results(self, query: str, params: Dict[str, Any],
-                      beta: bool) -> Dict[str, Any]:
-        query = query % (self._fetched_pages * _PAGE_SIZE, _PAGE_SIZE)
-        return self.client.execute(query, params, beta=beta)
+    def fetch_results(self) -> Dict[str, Any]:
+        query = self.query % (self._fetched_pages * _PAGE_SIZE, _PAGE_SIZE)
+        return self.client.execute(query,
+                                   self.params,
+                                   experimental=self.experimental)
+
+    def get_next_page(self):
+        results = self.fetch_results()
+        page_data = self.get_page_data(results)
+        self.increment_page()
+        done = self.fetched_all(len(page_data))
+        return page_data, done

labelbox/schema/invite.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 
-from labelbox.orm.db_object import DbObject, beta
+from labelbox.orm.db_object import DbObject
 from labelbox.orm.model import Field
 from labelbox.schema.role import ProjectRole
 
@@ -27,6 +27,7 @@ class Invite(DbObject):
     email = Field.String("email", "inviteeEmail")
 
     def __init__(self, client, invite_response):
+        #invite_response.get('inviter')
         project_roles = invite_response.pop("projectInvites", [])
         super().__init__(client, invite_response)
 

labelbox/schema/organization.py

@@ -2,7 +2,7 @@
 
 from labelbox.exceptions import LabelboxError
 from labelbox import utils
-from labelbox.orm.db_object import DbObject, beta
+from labelbox.orm.db_object import DbObject, experimental, query
 from labelbox.orm.model import Field, Relationship
 from labelbox.schema.invite import Invite, InviteLimit, ProjectRole
 from labelbox.schema.user import User
@@ -45,7 +45,7 @@ def __init__(self, *args, **kwargs):
     projects = Relationship.ToMany("Project", True)
     webhooks = Relationship.ToMany("Webhook", False)
 
-    @beta
+    @experimental
     def invite_user(
             self,
             email: str,
@@ -62,46 +62,29 @@ def invite_user(
         Returns:
             Invite for the user
 
-        Creates or updates users. This function shouldn't directly be called. 
-        Use `Organization.invite_user`
-
-        Note: that there is a really unclear foreign key error if you use an unsupported role.
-        - This means that the `Roles` object is not getting the right ids
+        Notes:
+            This function is currently experimental and has a few limitations that will be resolved in future releases
+            1. There is a really unclear foreign key error if you use an unsupported role.
+                - This means that the `Roles` object is not getting the right ids
+            2. Multiple invites can be sent for the same email. This can only be resolved in the UI for now.
+                - Future releases of the SDK will support the ability to query and revoke invites to solve this problem (and/or checking on the backend)
+            3. Some server side response are unclear (e.g. if the user invites themself `None` is returned which the SDK raises as a `LabelboxError` )
         """
-        remaining_invites = self.invite_limit().remaining
-        if remaining_invites == 0:
-            raise LabelboxError(
-                "Invite(s) cannot be sent because you do not have enough available seats in your organization. "
-                "Please upgrade your account, revoke pending invitations or remove other users."
-            )
-
-        if not isinstance(role, Role):
-            raise TypeError(f"role must be Role type. Found {role}")
 
         if project_roles and role.name != "NONE":
             raise ValueError(
                 "Project roles cannot be set for a user with organization level permissions. Found role name `{role.name}`, expected `NONE`"
             )
 
-        _project_roles = [] if project_roles is None else project_roles
-        for project_role in _project_roles:
-            if not isinstance(project_role, ProjectRole):
-                raise TypeError(
-                    f"project_roles must be a list of `ProjectRole`s. Found {project_role}"
-                )
-
-        if self.client.get_user().email == email:
-            raise ValueError("Cannot update your own role")
-
         data_param = "data"
         query_str = """mutation createInvitesPyApi($%s: [CreateInviteInput!]){
-                    createInvites(data: $%s){  invite { id createdAt organizationRoleName inviteeEmail}}}""" % (
-            data_param, data_param)
+                    createInvites(data: $%s){  invite { id createdAt organizationRoleName inviteeEmail inviter { %s } }}}""" % (
+            data_param, data_param, query.results_query_part(User))
 
         projects = [{
             "projectId": project_role.project.uid,
             "projectRoleId": project_role.role.uid
-        } for project_role in _project_roles]
+        } for project_role in project_roles or []]
 
         res = self.client.execute(query_str, {
             data_param: [{
@@ -112,11 +95,13 @@ def invite_user(
                 "projects": projects
             }]
         },
-                                  beta=True)
+                                  experimental=True)
         invite_response = res['createInvites'][0]['invite']
+        if not invite_response:
+            raise LabelboxError(f"Unable to send invite for email {email}")
         return Invite(self.client, invite_response)
 
-    @beta
+    @experimental
     def invite_limit(self) -> InviteLimit:
         """ Retrieve invite limits for the org
         This already accounts for users currently in the org
@@ -130,7 +115,7 @@ def invite_limit(self) -> InviteLimit:
         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},
-                                  beta=True)
+                                  experimental=True)
         return InviteLimit(
             **{utils.snake_case(k): v for k, v in res['invitesLimit'].items()})
 
@@ -142,9 +127,6 @@ def remove_user(self, user: User):
             user (User): The user to delete from the org
         """
 
-        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($%s: ID!) {