removed queries that aren't ready

Matt Sokoloff · Matt Sokoloff · commit 215d73fe7cae · 2021-04-14T18:45:17.000-04:00
diff --git a/examples/basics/user_management.ipynb b/examples/basics/user_management.ipynb
diff --git a/labelbox/__init__.py b/labelbox/__init__.py
@@ -17,4 +17,4 @@
 from labelbox.schema.prediction import Prediction, PredictionModel
 from labelbox.schema.ontology import Ontology
 from labelbox.schema.role import Role, ProjectRole
-from labelbox.schema.invite import Invite, InviteLimit, UserLimit
+from labelbox.schema.invite import Invite, InviteLimit
diff --git a/labelbox/client.py b/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_beta=False):
         """ Creates and initializes a Labelbox Client.
 
         Logging is defaulted to level WARNING. To receive more verbose
@@ -62,11 +62,10 @@ def __init__(self,
                     "Labelbox API key not provided")
             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")
-        
 
         logger.info("Initializing Labelbox client at '%s'", endpoint)
         self.endpoint = endpoint
@@ -76,11 +75,10 @@ def __init__(self,
             'Authorization': 'Bearer %s' % api_key,
             'X-User-Agent': f'python-sdk {SDK_VERSION}'
         }
-    
 
     @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, beta=False):
         """ Sends a request to the server for the execution of the
         given query.
 
diff --git a/labelbox/orm/db_object.py b/labelbox/orm/db_object.py
@@ -47,10 +47,11 @@ def __init__(self, client, field_values):
         self._set_field_values(field_values)
 
         for relationship in self.relationships():
-            value =   field_values.get(relationship.name)
+            value = field_values.get(relationship.name)
             if relationship.precompute and value is None:
-                raise KeyError(f"Expected field  values for {relationship.name}")
-            
+                raise KeyError(
+                    f"Expected field  values for {relationship.name}")
+
             setattr(self, relationship.name,
                     RelationshipManager(self, relationship, value))
 
@@ -258,22 +259,25 @@ def delete(self):
 
 
 def beta(fn):
+
     def wrapper(self, *args, **kwargs):
         if not isinstance(self, DbObject):
-            raise TypeError("Cannot decorate functions that are not functions of `DbOjects` with `beta` decorator")
+            raise TypeError(
+                "Cannot decorate functions that are not functions of `DbOjects` with `beta` decorator"
+            )
         if not self.client.enable_beta:
             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 these functions.")
-        execute_fn = self.client.execute            
+                " Set `enable_beta=True` in the client to enable use of these functions."
+            )
+        execute_fn = self.client.execute
         try:
-            self.client.execute = partial(execute_fn, beta = True)
+            self.client.execute = partial(execute_fn, beta=True)
             result = fn(self, *args, **kwargs)
             if isinstance(result, PaginatedCollection):
                 result.beta = True
             return result
         finally:
             self.client.execute = execute_fn
-    return wrapper
-    
 
+    return wrapper
diff --git a/labelbox/pagination.py b/labelbox/pagination.py
@@ -17,8 +17,7 @@ def __init__(self,
                  params,
                  dereferencing,
                  obj_class,
-                 cursor_path=None
-                 ):
+                 cursor_path=None):
         """ Creates a PaginatedCollection.
 
         Args:
diff --git a/labelbox/schema/invite.py b/labelbox/schema/invite.py
@@ -20,21 +20,9 @@ class InviteLimit:
     limit: int
 
 
-@dataclass
-class UserLimit(InviteLimit):
-    """
-    remaining(int): Remaining number of users that an org is allowed to have
-    used (int): Total number of users in the org
-    limit (int): Maximum number of users available to the org
-    date_limit_was_reached (date): Date that `limit` was equal to `used`
-    """
-    date_limit_was_reached: Optional[datetime]
-
-
 class Invite(DbObject):
     """
     An object representing a user invite
-
     """
     created_at = Field.DateTime("created_at")
     organization_role_name = Field.String("organization_role_name")
@@ -49,13 +37,3 @@ def __init__(self, client, invite_response):
                         role=client.get_roles()[r['projectRoleName']])
             for r in project_roles
         ]
-
-    @beta
-    def revoke(self):
-        """ Makes the invitation invalid.
-        """
-        query_str = """mutation CancelInvitePyApi($where: WhereUniqueIdInput!) {
-               cancelInvite(where: $where) {id}}"""
-        self.client.execute(query_str, {'where': {
-            'id': self.uid
-        }})
diff --git a/labelbox/schema/organization.py b/labelbox/schema/organization.py
@@ -5,13 +5,14 @@
 from labelbox.pagination import PaginatedCollection
 from labelbox.orm.db_object import DbObject, beta
 from labelbox.orm.model import Field, Relationship
-from labelbox.schema.invite import Invite, InviteLimit, UserLimit, ProjectRole
+from labelbox.schema.invite import Invite, InviteLimit, ProjectRole
 from labelbox.schema.user import User
 from labelbox.schema.role import Role
 import logging
 
 logger = logging.getLogger(__name__)
 
+
 class Organization(DbObject):
     """ An Organization is a group of Users.
 
@@ -45,61 +46,6 @@ def __init__(self, *args, **kwargs):
     projects = Relationship.ToMany("Project", True)
     webhooks = Relationship.ToMany("Webhook", False)
 
-    @beta
-    def invites(self) -> PaginatedCollection:
-        """ List all current invitees
-        
-        Returns:
-            A PaginatedCollection of Invite objects
-
-        """
-        query_str = """query GetOrgInvitationsPyApi($from: ID, $first: PageSize) {
-                organization { id invites(from: $from, first: $first) { 
-                    nodes { id createdAt organizationRoleName inviteeEmail } nextCursor }}}"""
-        return PaginatedCollection(
-            self.client,
-            query_str, {}, ['organization', 'invites', 'nodes'],
-            Invite,
-            cursor_path=['organization', 'invites', 'nextCursor'])
-
-    def _assign_user_role(self, email: str, role: Role,
-                          project_roles: List[ProjectRole]) -> Dict[str, Any]:
-        """
-        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
-        """
-        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)
-
-        projects = [{
-            "projectId": project_role.project.uid,
-            "projectRoleId": project_role.role.uid
-        } for project_role in project_roles]
-
-        res = self.client.execute(
-            query_str, {
-                data_param: [{
-                    "inviterId": self.client.get_user().uid,
-                    "inviteeEmail": email,
-                    "organizationId": self.uid,
-                    "organizationRoleId": role.uid,
-                    "projects": projects
-                }]
-            },
-            ) 
-        # We prob want to return an invite
-        # Could support bulk ops in the future
-        invite_info = res['createInvites'][0]['invite']
-        return invite_info
-
     @beta
     def invite_user(
             self,
@@ -117,18 +63,18 @@ 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
         """
         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."
             )
-        for invite in self.invites():
-            if invite.email == email:
-                raise ValueError(
-                    f"Invite already exists for {email}. Please revoke the invite if you want to update the role or resend."
-                )
 
         if not isinstance(role, Role):
             raise TypeError(f"role must be Role type. Found {role}")
@@ -145,26 +91,35 @@ def invite_user(
                     f"project_roles must be a list of `ProjectRole`s. Found {project_role}"
                 )
 
-        invite_response = self._assign_user_role(email, role, _project_roles)
-        return Invite(self.client, invite_response)
+        if self.client.get_user().email == email:
+            raise ValueError("Cannot update your own role")
 
-    @beta
-    def user_limit(self) -> UserLimit:
-        """ Retrieve user limits for the org
+        data_param = "data"
+        query_str = """mutation createInvitesPyApi($%s: [CreateInviteInput!]){
+                    createInvites(data: $%s){  invite { id createdAt organizationRoleName inviteeEmail}}}""" % (
+            data_param, data_param)
 
-        Returns:
-            UserLimit
-    
-        """
-        query_str = """query UsersLimitPyApi { 
-            organization {id account { id usersLimit { dateLimitWasReached remaining used limit }}}}
-        """
-        res = self.client.execute(query_str)
-        return UserLimit(
-            **{
-                utils.snake_case(k): v for k, v in res['organization']
-                ['account']['usersLimit'].items()
-            })
+        projects = [{
+            "projectId": project_role.project.uid,
+            "projectRoleId": project_role.role.uid
+        } for project_role in _project_roles]
+
+        res = self.client.execute(
+            query_str,
+            {
+                data_param: [{
+                    "inviterId": self.client.get_user().uid,
+                    "inviteeEmail": email,
+                    "organizationId": self.uid,
+                    "organizationRoleId": role.uid,
+                    "projects": projects
+                }]
+            },
+        )
+        # We prob want to return an invite
+        # Could support bulk ops in the future
+        invite_response = res['createInvites'][0]['invite']
+        return Invite(self.client, invite_response)
 
     @beta
     def invite_limit(self) -> InviteLimit:
@@ -177,13 +132,13 @@ def invite_limit(self) -> InviteLimit:
     
         """
         org_id_param = "organizationId"
-        res = self.client.execute("""query InvitesLimitPyApi($%s: ID!) {
+        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})
         return InviteLimit(
             **{utils.snake_case(k): v for k, v in res['invitesLimit'].items()})
 
-    @beta
     def remove_user(self, user: User):
         """
         Deletes a user from the organization. This cannot be undone without sending another invite.
diff --git a/labelbox/schema/project.py b/labelbox/schema/project.py
@@ -79,27 +79,6 @@ class Project(DbObject, Updateable, Deletable):
     predictions = Relationship.ToMany("Prediction", False)
     ontology = Relationship.ToOne("Ontology", True)
 
-    @beta
-    def invites(self):
-        """ Fetch all current invites for this project
-        
-        Returns:
-            A `PaginatedCollection` of `ProjectInvite`s.
-
-        """
-        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, {id_param: self.uid}, ['project', 'invites', 'nodes'],
-            Invite,
-            cursor_path=['project', 'invites', 'nextCursor'])
-
     def members(self):
         """ Fetch all current members for this project
 
diff --git a/labelbox/utils.py b/labelbox/utils.py
@@ -24,7 +24,3 @@ def title_case(s):
 def snake_case(s):
     """ Converts a string in [snake|camel|title]case to snake_case. """
     return _convert(s, "_", lambda i: False)
-
-
-
-    
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
diff --git a/tests/integration/test_user_management.py b/tests/integration/test_user_management.py
