scalekit-sdk-python 1.0.9__tar.gz → 2.0.0__tar.gz

{scalekit_sdk_python-1.0.9 → scalekit_sdk_python-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scalekit-sdk-python
-Version: 1.0.9
+Version: 2.0.0
 Summary: Scalekit official Python SDK
 Home-page: https://github.com/scalekit-inc/scalekit-sdk-python
 Author: Team Scalekit

{scalekit_sdk_python-1.0.9 → scalekit_sdk_python-2.0.0}/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}
@@ -135,11 +139,19 @@ class ScalekitClient:
             # Validate id_token
             claims = self.__validate_token(id_token, {"verify_aud": False})
             user = {}
+            connection_id = claims['amr'][0]
+            organization_id = claims['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
 
-            return {"user": user, "id_token": id_token, "access_token": access_token}
+            return {
+                "user": user,
+                "id_token": id_token,
+                "access_token": access_token,
+                "connection_id": connection_id,
+                "organization_id": organization_id
+            }
 
         except Exception as exp:
             raise exp
@@ -337,3 +349,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.0.9 → scalekit_sdk_python-2.0.0}/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.0.9 → scalekit_sdk_python-2.0.0}/scalekit/core.py

@@ -27,8 +27,8 @@ class WithCall(Protocol):
 class CoreClient:
     """Class definition for Core Client"""
 
-    sdk_version = "Scalekit-Python/1.0.9"
-    api_version = "20250417"
+    sdk_version = "Scalekit-Python/2.0.0"
+    api_version = "20250625"
     user_agent = f"{sdk_version} Python/{platform.python_version()} ({platform.system()}; {platform.architecture()}"
 
     def __init__(self, env_url, client_id, client_secret):
@@ -104,6 +104,8 @@ class CoreClient:
             data=json.loads(data),
             verify=True,
         )
+        if response.status_code != 200:
+            raise Exception(response.content)
         return response
 
     def get_jwks(self):

{scalekit_sdk_python-1.0.9 → scalekit_sdk_python-2.0.0}/scalekit/organization.py

@@ -24,7 +24,7 @@ class OrganizationClient:
 
     def list_organizations(
         self, page_size: int, page_token: Optional[str] = None
-    ) -> CreateOrganizationResponse:
+    ) -> ListOrganizationsResponse:
         """
         Method to list organizations
 

scalekit_sdk_python-2.0.0/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
+            ),
+        )
+
+