scalekit-sdk-python 1.1.0__tar.gz → 2.0.1__tar.gz

{scalekit_sdk_python-1.1.0 → scalekit_sdk_python-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scalekit-sdk-python
-Version: 1.1.0
+Version: 2.0.1
 Summary: Scalekit official Python SDK
 Home-page: https://github.com/scalekit-inc/scalekit-sdk-python
 Author: Team Scalekit
@@ -18,7 +18,7 @@ Requires-Dist: requests>=2.32.3
 Requires-Dist: PyJWT<2.10,>=2.8
 Requires-Dist: cffi>=1.15.1
 Requires-Dist: cryptography==44.0.1
-Requires-Dist: setuptools~=70.3
+Requires-Dist: setuptools>=78.1.1
 Requires-Dist: grpcio-status<1.67,>=1.64
 Requires-Dist: protoc-gen-openapiv2>=0.0.1
 Requires-Dist: googleapis-common-protos<1.66.0,>=1.56.1

{scalekit_sdk_python-1.1.0 → scalekit_sdk_python-2.0.1}/scalekit/client.py

@@ -1,4 +1,3 @@
-
 import json
 from math import floor
 from typing import Any, Optional, Dict
@@ -15,15 +14,18 @@ from scalekit.connection import ConnectionClient
 from scalekit.m2m_client import M2MClient
 from scalekit.organization import OrganizationClient
 from scalekit.directory import DirectoryClient
+from scalekit.users import UserClient
 from scalekit.common.scalekit import (
     AuthorizationUrlOptions,
     CodeAuthenticationOptions,
     GrantType,
     IdpInitiatedLoginClaims,
+    LogoutUrlOptions,
 )
 from scalekit.constants.user import id_token_claim_to_user_map
 
 AUTHORIZE_ENDPOINT = "oauth/authorize"
+LOGOUT_ENDPOINT = "end_session" 
 webhook_tolerance_in_seconds = timedelta(minutes=5)
 webhook_signature_version = "v1"
 
@@ -58,6 +60,7 @@ class ScalekitClient:
             self.organization = OrganizationClient(self.core_client)
             self.directory = DirectoryClient(self.core_client)
             self.m2m_client = M2MClient(self.core_client)
+            self.users = UserClient(self.core_client)
         except Exception as exp:
             raise exp
 
@@ -91,6 +94,7 @@ class ScalekitClient:
                 "connection_id": options.connection_id,
                 "organization_id": options.organization_id,
                 "provider": options.provider,
+                "prompt": options.prompt,  
             }
 
             valid_auth_params = {k: v for k, v in url_params_dict.items() if v}
@@ -114,7 +118,7 @@ class ScalekitClient:
         :type                 : ``` obj ```
 
         :returns:
-            dict with user, id token & access token
+            dict with user, id token, optionally access token & refresh token
         """
         try:
             response = self.core_client.authenticate(
@@ -132,11 +136,13 @@ class ScalekitClient:
             response = json.loads(response.content)
             id_token = response["id_token"]
             access_token = response["access_token"]
+            refresh_token = response.get("refresh_token")
             # Validate id_token
             claims = self.__validate_token(id_token, {"verify_aud": False})
             user = {}
-            connection_id = claims['amr'][0]
-            organization_id = claims['oid']
+            amr_claims = claims.get('amr', [])
+            connection_id = amr_claims[0] if amr_claims else None
+            organization_id = claims.get('oid')
             for k, v in claims.items():
                 if id_token_claim_to_user_map.get(k, None):
                     user[id_token_claim_to_user_map[k]] = v
@@ -145,6 +151,7 @@ class ScalekitClient:
                 "user": user,
                 "id_token": id_token,
                 "access_token": access_token,
+                "refresh_token": refresh_token,
                 "connection_id": connection_id,
                 "organization_id": organization_id
             }
@@ -152,7 +159,7 @@ class ScalekitClient:
         except Exception as exp:
             raise exp
 
-    def validate_access_token(self, token: str) -> bool:
+    def validate_access_token(self, token: str, options: Optional[Dict] = None, audience = None) -> bool:
         """
         Method to validate access token
 
@@ -162,8 +169,10 @@ class ScalekitClient:
         :returns:
             bool
         """
+        options = options if options else {}
+        options["verify_aud"] = False if not audience else True
         try:
-            self.__validate_token(token)
+            self.__validate_token(token, options=options, audience=audience)
             return True
         except jwt.exceptions.InvalidTokenError:
             return False
@@ -345,3 +354,57 @@ class ScalekitClient:
         """
         signature = hmac.new(secret, data.encode(), hashlib.sha256).digest()
         return f"v1, {base64.b64encode(signature).decode('utf-8')}"
+
+    def refresh_access_token(self, refresh_token: str):
+        """
+        Method to refresh access token using refresh token
+
+        :param refresh_token  : Refresh token to get new access token
+        :type                 : ``` str ```
+
+        :returns:
+            dict with access token & refresh token
+        """
+        try:
+            response = self.core_client.authenticate(
+                json.dumps(
+                    {
+                        "refresh_token": refresh_token,
+                        "grant_type": GrantType.RefreshToken.value,
+                        "client_id": self.core_client.client_id,
+                        "client_secret": self.core_client.client_secret,
+                    }
+                )
+            )
+            response = json.loads(response.content)
+            return {
+                "access_token": response["access_token"],
+                "refresh_token": response["refresh_token"]
+            }
+
+        except Exception as exp:
+            raise exp
+
+    def get_logout_url(self, options: LogoutUrlOptions) -> str:
+        """
+        Method to get logout URL
+
+        :param options        : Logout URL options object
+        :type                 : ``` LogoutUrlOptions ```
+
+        :returns:
+            str: The logout URL
+        """
+        try:
+            url_params_dict = {
+                "id_token_hint": options.id_token_hint,
+                "post_logout_redirect_uri": options.post_logout_redirect_uri,
+                "state": options.state
+            }
+
+            valid_params = {k: v for k, v in url_params_dict.items() if v is not None}
+            query_string = urlencode(valid_params)
+
+            return f"{self.core_client.env_url}/{LOGOUT_ENDPOINT}?{query_string}"
+        except Exception as exp:
+            raise exp

{scalekit_sdk_python-1.1.0 → scalekit_sdk_python-2.0.1}/scalekit/common/scalekit.py

@@ -23,6 +23,7 @@ class AuthorizationUrlOptions:
         self.domain_hint: Optional[str] = None
         self.login_hint: Optional[str] = None
         self.provider: Optional[str] = None
+        self.prompt: Optional[str] = None
 
 
 class CodeAuthenticationOptions:
@@ -57,4 +58,17 @@ class IdpInitiatedLoginClaims:
         self.connection_id: str
         self.organization_id: str
         self.login_hint: str
-        self.relay_state: Optional[str] = None
+        self.relay_state: Optional[str] = None
+
+
+class LogoutUrlOptions:
+    """Options for logout URL generation"""
+    def __init__(
+        self,
+        id_token_hint: Optional[str] = None,
+        post_logout_redirect_uri: Optional[str] = None,
+        state: Optional[str] = None
+    ):
+        self.id_token_hint = id_token_hint
+        self.post_logout_redirect_uri = post_logout_redirect_uri
+        self.state = state

{scalekit_sdk_python-1.1.0 → scalekit_sdk_python-2.0.1}/scalekit/core.py

@@ -27,7 +27,7 @@ class WithCall(Protocol):
 class CoreClient:
     """Class definition for Core Client"""
 
-    sdk_version = "Scalekit-Python/1.1.0"
+    sdk_version = "Scalekit-Python/2.0.1"
     api_version = "20250417"
     user_agent = f"{sdk_version} Python/{platform.python_version()} ({platform.system()}; {platform.architecture()}"
 

scalekit_sdk_python-2.0.1/scalekit/users.py

@@ -0,0 +1,367 @@
+from typing import Optional
+
+from scalekit.core import CoreClient
+from scalekit.v1.users.users_pb2 import *
+from scalekit.v1.users.users_pb2_grpc import UserServiceStub
+
+
+class UserClient:
+    """Class definition for User Client"""
+
+    def __init__(self, core_client: CoreClient):
+        """
+        Initializer for User Client
+
+        :param core_client    : CoreClient Object
+        :type                 : ``` obj ```
+        :returns
+            None
+        """
+        self.core_client = core_client
+        self.user_service = UserServiceStub(
+            self.core_client.grpc_secure_channel
+        )
+
+    def create_user_and_membership(
+        self, 
+        organization_id: str, 
+        user: CreateUser, 
+        send_invitation_email: bool = True
+    ) -> CreateUserAndMembershipResponse:
+        """
+        Method to create a new user and add them to an organization
+
+        :param organization_id      : Organization id to create user for
+        :type                       : ``` str ```
+        :param user                : CreateUser object with expected values for user creation
+        :type                       : ``` obj ```
+        :param send_invitation_email: Whether to send activation email to the user
+        :type                       : ``` bool ```
+
+        :returns:
+            Create User And Membership Response
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.CreateUserAndMembership.with_call,
+            CreateUserAndMembershipRequest(
+                organization_id=organization_id,
+                user=user,
+                send_invitation_email=send_invitation_email
+            ),
+        )
+
+    def get_user(self, user_id: str) -> GetUserResponse:
+        """
+        Method to get user by ID
+
+        :param user_id         : User id to get user details
+        :type                  : ``` str ```
+
+        :returns:
+            Get User Response
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.GetUser.with_call,
+            GetUserRequest(id=user_id),
+        )
+
+    def get_user_by_external_id(self, external_id: str) -> GetUserResponse:
+        """
+        Method to get user by external ID
+
+        :param external_id     : External id to get user details
+        :type                  : ``` str ```
+
+        :returns:
+            Get User Response
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.GetUser.with_call,
+            GetUserRequest(external_id=external_id),
+        )
+
+    def list_users(
+        self,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None
+    ) -> ListUsersResponse:
+        """
+        Method to list all users in environment
+
+        :param page_size       : Page size for pagination
+        :type                  : ``` int ```
+        :param page_token      : Page token for pagination
+        :type                  : ``` str ```
+
+        :returns:
+            List Users Response
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.ListUsers.with_call,
+            ListUsersRequest(
+                page_size=page_size,
+                page_token=page_token
+            ),
+        )
+
+    def list_organization_users(
+        self,
+        organization_id: str,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None
+    ) -> ListOrganizationUsersResponse:
+        """
+        Method to list users for given organization id
+
+        :param organization_id  : Organization id to list users for
+        :type                   : ``` str ```
+        :param page_size       : Page size for pagination
+        :type                   : ``` int ```
+        :param page_token      : Page token for pagination
+        :type                   : ``` str ```
+
+        :returns:
+            List Organization Users Response
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.ListOrganizationUsers.with_call,
+            ListOrganizationUsersRequest(
+                organization_id=organization_id,
+                page_size=page_size,
+                page_token=page_token
+            ),
+        )
+
+    def update_user(self, user_id: str, user: UpdateUser) -> UpdateUserResponse:
+        """
+        Method to update an existing user by ID
+
+        :param user_id         : User id to update
+        :type                  : ``` str ```
+        :param user            : UpdateUser object with expected values for user update
+        :type                  : ``` obj ```
+
+        :returns:
+            Update User Response
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.UpdateUser.with_call,
+            UpdateUserRequest(id=user_id, user=user),
+        )
+
+    def update_user_by_external_id(self, external_id: str, user: UpdateUser) -> UpdateUserResponse:
+        """
+        Method to update an existing user by external ID
+
+        :param external_id     : External id to update
+        :type                  : ``` str ```
+        :param user            : UpdateUser object with expected values for user update
+        :type                  : ``` obj ```
+
+        :returns:
+            Update User Response
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.UpdateUser.with_call,
+            UpdateUserRequest(external_id=external_id, user=user),
+        )
+
+    def delete_user(self, user_id: str):
+        """
+        Method to delete user by ID
+
+        :param user_id         : User id to be deleted
+        :type                  : ``` str ```
+
+        :returns:
+            None
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.DeleteUser.with_call,
+            DeleteUserRequest(id=user_id),
+        )
+
+    def delete_user_by_external_id(self, external_id: str):
+        """
+        Method to delete user by external ID
+
+        :param external_id     : External id to be deleted
+        :type                  : ``` str ```
+
+        :returns:
+            None
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.DeleteUser.with_call,
+            DeleteUserRequest(external_id=external_id),
+        )
+
+    def create_membership(
+        self,
+        organization_id: str,
+        user_id: str,
+        membership: CreateMembership,
+        send_invitation_email: bool = True
+    ) -> CreateMembershipResponse:
+        """
+        Method to create a membership for a user by user ID
+
+        :param organization_id  : Organization id
+        :type                   : ``` str ```
+        :param user_id          : User id
+        :type                   : ``` str ```
+        :param membership       : CreateMembership object
+        :type                   : ``` obj ```
+        :param send_invitation_email: Whether to send activation email to the user
+        :type                       : ``` bool ```
+
+        :returns:
+            Create Membership Response
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.CreateMembership.with_call,
+            CreateMembershipRequest(
+                organization_id=organization_id,
+                id=user_id,
+                membership=membership,
+                send_invitation_email=send_invitation_email
+            ),
+        )
+
+    def create_membership_by_external_id(
+        self,
+        organization_id: str,
+        external_id: str,
+        membership: CreateMembership,
+        send_invitation_email: bool = True
+    ) -> CreateMembershipResponse:
+        """
+        Method to create a membership for a user by external ID
+
+        :param organization_id  : Organization id
+        :type                   : ``` str ```
+        :param external_id      : External id
+        :type                   : ``` str ```
+        :param membership       : CreateMembership object
+        :type                   : ``` obj ```
+        :param send_invitation_email: Whether to send activation email to the user
+        :type                       : ``` bool ```
+
+        :returns:
+            Create Membership Response
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.CreateMembership.with_call,
+            CreateMembershipRequest(
+                organization_id=organization_id,
+                external_id=external_id,
+                membership=membership,
+                send_invitation_email=send_invitation_email
+            ),
+        )
+
+    def update_membership(
+        self,
+        organization_id: str,
+        user_id: str,
+        membership: UpdateMembership
+    ) -> UpdateMembershipResponse:
+        """
+        Method to update a membership for a user by user ID
+
+        :param organization_id  : Organization id
+        :type                   : ``` str ```
+        :param user_id          : User id
+        :type                   : ``` str ```
+        :param membership       : UpdateMembership object
+        :type                   : ``` obj ```
+
+        :returns:
+            Update Membership Response
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.UpdateMembership.with_call,
+            UpdateMembershipRequest(
+                organization_id=organization_id,
+                id=user_id,
+                membership=membership
+            ),
+        )
+
+    def update_membership_by_external_id(
+        self,
+        organization_id: str,
+        external_id: str,
+        membership: UpdateMembership
+    ) -> UpdateMembershipResponse:
+        """
+        Method to update a membership for a user by external ID
+
+        :param organization_id  : Organization id
+        :type                   : ``` str ```
+        :param external_id      : External id
+        :type                   : ``` str ```
+        :param membership       : UpdateMembership object
+        :type                   : ``` obj ```
+
+        :returns:
+            Update Membership Response
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.UpdateMembership.with_call,
+            UpdateMembershipRequest(
+                organization_id=organization_id,
+                external_id=external_id,
+                membership=membership
+            ),
+        )
+
+    def delete_membership(
+        self,
+        organization_id: str,
+        user_id: str
+    ):
+        """
+        Method to delete a membership for a user by user ID
+
+        :param organization_id  : Organization id
+        :type                   : ``` str ```
+        :param user_id          : User id
+        :type                   : ``` str ```
+
+        :returns:
+            None
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.DeleteMembership.with_call,
+            DeleteMembershipRequest(
+                organization_id=organization_id,
+                id=user_id
+            ),
+        )
+
+    def delete_membership_by_external_id(
+        self,
+        organization_id: str,
+        external_id: str
+    ):
+        """
+        Method to delete a membership for a user by external ID
+
+        :param organization_id  : Organization id
+        :type                   : ``` str ```
+        :param external_id      : External id
+        :type                   : ``` str ```
+
+        :returns:
+            None
+        """
+        return self.core_client.grpc_exec(
+            self.user_service.DeleteMembership.with_call,
+            DeleteMembershipRequest(
+                organization_id=organization_id,
+                external_id=external_id
+            ),
+        )
+
+