scalekit-sdk-python 1.0.2__tar.gz → 1.0.4__tar.gz

{scalekit_sdk_python-1.0.2/scalekit_sdk_python.egg-info → scalekit_sdk_python-1.0.4}/PKG-INFO

@@ -1,26 +1,26 @@
 Metadata-Version: 2.1
 Name: scalekit-sdk-python
-Version: 1.0.2
+Version: 1.0.4
 Summary: Scalekit official Python SDK
 Home-page: https://github.com/scalekit-inc/scalekit-sdk-python
 Author: Team Scalekit
-Author-email: support@grpc.com
+Author-email: support@scalekit.com
 License: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: grpcio==1.64.1
-Requires-Dist: protobuf==5.27.0
-Requires-Dist: google==3.0.0
-Requires-Dist: requests==2.32.3
-Requires-Dist: PyJWT==2.8.0
-Requires-Dist: cryptography==42.0.8
-Requires-Dist: setuptools==70.3.0
-Requires-Dist: grpcio-status==1.64.0
-Requires-Dist: protoc-gen-openapiv2==0.0.1
-Requires-Dist: googleapis-common-protos==1.56.1
+Requires-Dist: grpcio>=1.64.1
+Requires-Dist: protobuf>=5.27.0
+Requires-Dist: google>=3.0.0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: PyJWT>=2.8.0
+Requires-Dist: cryptography>=43.0.3
+Requires-Dist: setuptools>=70.3.0
+Requires-Dist: grpcio-status>=1.64.0
+Requires-Dist: protoc-gen-openapiv2>=0.0.1
+Requires-Dist: googleapis-common-protos>=1.56.1
 
 <p align="left">
   <a href="https://scalekit.com" target="_blank" rel="noopener noreferrer">

{scalekit_sdk_python-1.0.2 → scalekit_sdk_python-1.0.4}/scalekit/__init__.py

@@ -1,4 +1,5 @@
+
 from scalekit.client import ScalekitClient
-from scalekit.common.scalekit import AuthorizationUrlOptions, CodeAuthenticationOptions
+from scalekit.common.scalekit import CodeAuthenticationOptions, AuthorizationUrlOptions
 
 __all__ = ['ScalekitClient', 'AuthorizationUrlOptions', 'CodeAuthenticationOptions']

scalekit_sdk_python-1.0.4/scalekit/client.py

@@ -0,0 +1,291 @@
+
+import json
+from math import floor
+from typing import Any, Optional, Dict
+from urllib.parse import urlencode
+
+import jwt
+import hmac
+import hashlib
+import base64
+from datetime import datetime, timedelta, timezone
+from scalekit.core import CoreClient
+from scalekit.domain import DomainClient
+from scalekit.connection import ConnectionClient
+from scalekit.organization import OrganizationClient
+from scalekit.directory import DirectoryClient
+from scalekit.common.scalekit import (
+    AuthorizationUrlOptions,
+    CodeAuthenticationOptions,
+    GrantType,
+    IdpInitiatedLoginClaims,
+)
+from scalekit.constants.user import id_token_claim_to_user_map
+
+AUTHORIZE_ENDPOINT = "oauth/authorize"
+webhook_tolerance_in_seconds = timedelta(minutes=5)
+webhook_signature_version = "v1"
+
+
+class WebhookVerificationError(Exception):
+    pass
+
+
+class ScalekitClient:
+    """ Class definition for scalekit client """
+
+    def __init__(self, env_url: str, client_id: str, client_secret: str):
+        """
+        Initializer for Scalekit base class
+
+        :param env_url        : Environment URL
+        :type                 : ``` str ```
+        :param client_id      : Client ID
+        :type                 : ``` str ```
+        :param client_secret  : Client Secret
+        :type                 : ``` str ```
+
+        :returns:
+            None
+        """
+        try:
+            self.core_client = CoreClient(
+                env_url=env_url, client_id=client_id, client_secret=client_secret
+            )
+            self.domain = DomainClient(self.core_client)
+            self.connection = ConnectionClient(self.core_client)
+            self.organization = OrganizationClient(self.core_client)
+            self.directory = DirectoryClient(self.core_client)
+        except Exception as exp:
+            raise exp
+
+    def get_authorization_url(
+        self, redirect_uri: str, options: AuthorizationUrlOptions | None
+    ):
+        """
+        Method to get authorization URL
+
+        :param redirect_uri   : Redirect URI for SAML SSO
+        :type                 : ``` str ```
+        :param options        : Auth URL options object
+        :type                 : ``` obj ```
+
+        :returns:
+            Authorization URL
+        """
+        try:
+            scopes = (
+                options.scopes if options.scopes else ["openid", "profile", "email"]
+            )
+            url_params_dict = {
+                "response_type": "code",
+                "client_id": self.core_client.client_id,
+                "redirect_uri": redirect_uri,
+                "scope": " ".join(scopes),
+                "state": options.state,
+                "nonce": options.nonce,
+                "login_hint": options.login_hint,
+                "domain_hint": options.domain_hint,
+                "connection_id": options.connection_id,
+                "organization_id": options.organization_id,
+                "provider": options.provider,
+            }
+
+            valid_auth_params = {k: v for k, v in url_params_dict.items() if v}
+            query_string = urlencode(valid_auth_params)
+
+            return f"{self.core_client.env_url}/{AUTHORIZE_ENDPOINT}?{query_string}"
+        except Exception as exp:
+            raise exp
+
+    def authenticate_with_code(
+        self, code, redirect_uri, options: CodeAuthenticationOptions
+    ):
+        """
+        Method to authenticate with code options
+
+        :param code           : authorization_code
+        :type                 : ``` str ```
+        :param redirect_uri   : Redirect URI
+        :type                 : ``` str ```
+        :param options        : CodeAuthenticationOptions Object
+        :type                 : ``` obj ```
+
+        :returns:
+            dict with user, id token & access token
+        """
+        try:
+            response = self.core_client.authenticate(
+                json.dumps(
+                    {
+                        "code": code,
+                        "redirect_uri": redirect_uri,
+                        "grant_type": GrantType.AuthorizationCode.value,
+                        "client_id": self.core_client.client_id,
+                        "client_secret": self.core_client.client_secret,
+                        "code_verifier": options.code_verifier,
+                    }
+                )
+            )
+            response = json.loads(response.content)
+            id_token = response["id_token"]
+            access_token = response["access_token"]
+            # Validate id_token
+            claims = self.__validate_token(id_token, {"verify_aud": False})
+            user = {}
+            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}
+
+        except Exception as exp:
+            raise exp
+
+    def validate_access_token(self, token: str) -> bool:
+        """
+        Method to validate access token
+
+        :param token : access token
+        :type        : ``` str ```
+
+        :returns:
+            bool
+        """
+        try:
+            self.__validate_token(token)
+            return True
+        except jwt.exceptions.InvalidTokenError:
+            return False
+
+    def get_idp_initiated_login_claims(self, idp_initiated_login_token: str) -> IdpInitiatedLoginClaims:
+        """
+        Method to get IDP initiated login claims
+
+        :param idp_initiated_login_token : IDP initiated login token
+        :type        : ``` str ```
+
+        :returns:
+            ``` IdpInitiatedLoginClaims ```
+        """
+        try:
+            claims = self.__validate_token(idp_initiated_login_token, {"verify_aud": False})
+            return claims
+        except Exception as exp:
+            raise exp
+
+    def __validate_token(
+        self, token: str, options: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        """
+        Method to validate token
+
+        :param token : token
+        :type        : ``` str ```
+
+        :returns:
+            payload
+        """
+        self.core_client.get_jwks()
+        kid = jwt.get_unverified_header(token)["kid"]
+        key = self.core_client.keys[kid]
+
+        return jwt.decode(token, key=key, algorithms="RS256", options=options)
+
+    def verify_webhook_payload(self, secret: str, headers: Dict[str, str], payload: [str | bytes]) -> bool:
+        """
+        Method to verify webhook payload
+
+        :param secret      :     Secret for webhook verification
+        :type              :     ``` str ```
+        :param headers     :     Webhook request headers
+        :type              :     ``` dict[str, str] ```
+        :param payload     :     Webhook payload in str or bytes
+        :type              :     ``` str | bytes ```
+
+        :returns:
+            bool
+        """
+        payload = payload if isinstance(payload, str) else payload.decode()
+        webhook_id = headers.get("webhook-id")
+        webhook_timestamp = headers.get("webhook-timestamp")
+        webhook_signature = headers.get("webhook-signature")
+
+        if not all([webhook_id, webhook_timestamp, webhook_signature]):
+            raise WebhookVerificationError("Missing required headers")
+
+        secret_parts = secret.split("_")
+        if len(secret_parts) < 2:
+            raise WebhookVerificationError("Invalid secret")
+
+        try:
+            secret_bytes = base64.b64decode(secret_parts[1])
+        except Exception as exp:
+            raise exp
+
+        try:
+            timestamp = self.__verify_timestamp(webhook_timestamp)
+        except Exception as exp:
+            raise exp
+
+        timestamp_str = str(floor(timestamp.replace(tzinfo=timezone.utc).timestamp()))
+        data = f"{webhook_id}.{timestamp_str}.{payload}"
+        computed_signature = base64.b64decode(self.__compute_signature(secret_bytes, data).split(',')[1])
+
+        received_signatures = webhook_signature.split(" ")
+        for versioned_signature in received_signatures:
+            signature_parts = versioned_signature.split(",")
+            if len(signature_parts) < 2:
+                continue
+
+            version = signature_parts[0]
+            signature = base64.b64decode(signature_parts[1])
+
+            if version != webhook_signature_version:
+                continue
+
+            if hmac.compare_digest(signature, computed_signature):
+                return True
+
+        raise WebhookVerificationError("Invalid signature")
+
+    @staticmethod
+    def __verify_timestamp(timestamp_str: str):
+        """
+        Method to verify time stamp
+
+        :param timestamp_str   :     Timestamp for verification
+        :type                  :     ``` str ```
+
+        :returns:
+            None
+        """
+        now = datetime.now(tz=timezone.utc)
+        try:
+            timestamp = datetime.fromtimestamp(float(timestamp_str), tz=timezone.utc)
+        except Exception:
+            raise WebhookVerificationError("Invalid Signature Headers")
+
+        if timestamp < (now - webhook_tolerance_in_seconds):
+            raise Exception("Message timestamp too old")
+
+        if timestamp > (now + webhook_tolerance_in_seconds):
+            raise Exception("Message timestamp too new")
+
+        return timestamp
+
+    @staticmethod
+    def __compute_signature(secret: bytes, data: str) -> str:
+        """
+        Method to compute signature
+
+        :param secret   :     secret for signature
+        :type           :     ``` bytes ```
+        :param data     :     data for signature
+        :type           :     ``` str ```
+
+        :returns:
+            None
+        """
+        signature = hmac.new(secret, data.encode(), hashlib.sha256).digest()
+        return f"v1, {base64.b64encode(signature).decode('utf-8')}"

{scalekit_sdk_python-1.0.2 → scalekit_sdk_python-1.0.4}/scalekit/common/scalekit.py

@@ -48,3 +48,13 @@ class AuthenticationOptions:
     def __init__(self):
         """ """
         self.refresh_token: Optional[str] = None
+
+
+class IdpInitiatedLoginClaims:
+    """Class definition for IDP Initiated Login Claims"""
+
+    def __init__(self) -> None:
+        self.connection_id: str
+        self.organization_id: str
+        self.login_hint: str
+        self.relay_state: Optional[str] = None

{scalekit_sdk_python-1.0.2 → scalekit_sdk_python-1.0.4}/scalekit/core.py

@@ -25,7 +25,7 @@ class WithCall(Protocol):
 class CoreClient:
     """Class definition for Core Client"""
 
-    sdk_version = "Scalekit-Python/1.0.2"
+    sdk_version = "Scalekit-Python/1.0.3"
     api_version = "20240430"
     user_agent = f"{sdk_version} Python/{platform.python_version()} ({platform.system()}; {platform.architecture()}"
 
@@ -83,6 +83,8 @@ class CoreClient:
         }
 
         response = self.authenticate(data=json.dumps(params))
+        if response.status_code != 200:
+            raise Exception(response.content)
         response = json.loads(response.content)
         self.access_token = response["access_token"]
 

scalekit_sdk_python-1.0.4/scalekit/directory.py

@@ -0,0 +1,243 @@
+from typing import Optional, Any
+from google.protobuf.json_format import MessageToJson
+
+from scalekit.core import CoreClient
+from scalekit.utils.directory import DirUser, ListDirUsersResponse, DirGroup, ListDirGroupsResponse
+
+from scalekit.v1.directories.directories_pb2 import *
+from scalekit.v1.directories.directories_pb2_grpc import DirectoryServiceStub
+
+
+class DirectoryClient:
+    """ Class definition for Directory Client """
+
+    def __init__(self, core_client: CoreClient):
+        """
+        Initializer for Directory Client
+
+        :param core_client    : CoreClient Object
+        :type                 : ``` obj ```
+
+        :returns
+            None
+        """
+        self.core_client = core_client
+        self.directory_service = DirectoryServiceStub(
+            self.core_client.grpc_secure_channel
+        )
+
+    def get_directory(
+            self,
+            organization_id: str,
+            directory_id: str,
+    ) -> GetDirectoryResponse:
+        """
+        Method to get directory based on given organization and directory id
+
+        :param organization_id   :     Organization id
+        :type                    :     ``` str ```
+        :param directory_id      :     directory id
+        :type                    :     ``` str ```
+
+        :returns:
+            Get Directory Response
+        """
+        return self.core_client.grpc_exec(
+            self.directory_service.GetDirectory.with_call,
+            GetDirectoryRequest(
+                id=directory_id,
+                organization_id=organization_id,
+            ),
+        )
+
+    def list_directories(self, organization_id) -> ListDirectoriesResponse:
+        """
+        Method to list directories for given organization id
+
+        :param organization_id  : org id to fetch directory list
+        :type                   : ``` str ```
+
+        :returns:
+             list of directories
+        """
+        return self.core_client.grpc_exec(
+            self.directory_service.ListDirectories.with_call,
+            ListDirectoriesRequest(organization_id=organization_id),
+        )
+
+    def list_directory_users(
+            self,
+            organization_id: str,
+            directory_id: str,
+            page_size: Optional[int] = None,
+            page_token: Optional[str] = None,
+            include_detail: Optional[bool] = None,
+            updated_after: Optional[str] = None
+    ) -> tuple[ListDirUsersResponse, Any]:
+        """
+        Method to fetch list of directory users based on given organization and directory id
+
+        :param organization_id   :     Organization id
+        :type                    :     ``` str ```
+        :param directory_id      :     directory id
+        :type                    :     ``` str ```
+        :param page_size         :     page size for org list fetch
+        :type                    :     ``` int ```
+        :param page_token        :     page token for org list fetch
+        :type                    :     ``` str ```
+        :param include_detail     :     param to include detailed data
+        :type                    :     ``` bool ```
+        :param updated_after      :     param to get updated after detail
+        :type                    :     ``` str ```
+
+        :returns:
+             list of directory users
+        """
+        response = self.core_client.grpc_exec(
+            self.directory_service.ListDirectoryUsers.with_call,
+            ListDirectoryUsersRequest(
+                organization_id=organization_id,
+                directory_id=directory_id,
+                page_size=page_size,
+                page_token=page_token,
+                include_detail=include_detail,
+                updated_after=updated_after
+            ),
+        )
+
+        user_response = (ListDirUsersResponse(), response[1])
+        for user in response[0].users:
+            dir_user = DirUser()
+            dir_user.id = user.id
+            dir_user.email = user.email
+            dir_user.preferred_username = user.preferred_username
+            dir_user.given_name = user.given_name
+            dir_user.family_name = user.family_name
+            dir_user.updated_at = user.updated_at
+            dir_user.emails = user.emails
+            dir_user.groups = user.groups
+            dir_user.user_detail = MessageToJson(user.user_detail)
+
+            if not hasattr(user_response[0], 'users'):
+                user_response[0].users = [dir_user]
+            else:
+                user_response[0].users.append(dir_user)
+            user_response[0].total_size = response[0].total_size
+            user_response[0].next_page_token = response[0].next_page_token
+            user_response[0].prev_page_token = response[0].prev_page_token
+
+        return user_response
+
+    def list_directory_groups(
+            self,
+            organization_id: str,
+            directory_id: str,
+            page_size: Optional[int] = None,
+            page_token: Optional[str] = None,
+            include_detail: Optional[bool] = None,
+            updated_after: Optional[str] = None
+    ) -> tuple[ListDirGroupsResponse, Any]:
+        """
+        Method to fetch list of directory groups based on given organization and directory id
+
+        :param organization_id   :     Organization id
+        :type                    :     ``` str ```
+        :param directory_id      :     directory id
+        :type                    :     ``` str ```
+        :param page_size         :     page size for org list fetch
+        :type                    :     ``` int ```
+        :param page_token        :     page token for org list fetch
+        :type                    :     ``` str ```
+        :param include_detail     :     param to include detailed data
+        :type                    :     ``` bool ```
+        :param updated_after      :     param to get updated after detail
+        :type                    :     ``` str ```
+
+        :returns:
+             list of directory users
+        """
+        response = self.core_client.grpc_exec(
+            self.directory_service.ListDirectoryGroups.with_call,
+            ListDirectoryGroupsRequest(
+                organization_id=organization_id,
+                directory_id=directory_id,
+                page_size=page_size,
+                page_token=page_token,
+                include_detail=include_detail,
+                updated_after=updated_after
+            ),
+        )
+
+        group_response = (ListDirGroupsResponse(), response[1])
+        for group in response[0].groups:
+            dir_group = DirGroup()
+            dir_group.id = group.id
+            dir_group.display_name = group.display_name
+            dir_group.total_users = group.total_users
+            dir_group.updated_at = group.updated_at
+            dir_group.group_detail = MessageToJson(group.group_detail)
+
+            if not hasattr(group_response, 'users'):
+                group_response[0].groups = [dir_group]
+            else:
+                group_response[0].groups.append(dir_group)
+
+            group_response[0].total_size = response[0].total_size
+            group_response[0].next_page_token = response[0].next_page_token
+            group_response[0].prev_page_token = response[0].prev_page_token
+
+        return group_response
+
+    def enable_directory(self, organization_id: str, directory_id: str) -> ToggleDirectoryResponse:
+        """
+        Method to enable directory based on given organization and directory id
+
+        :param organization_id   :     Organization id
+        :type                    :     ``` str ```
+        :param directory_id      :     directory id
+        :type                    :     ``` str ```
+
+        :returns:
+             Toggle Directory Response
+        """
+        return self.core_client.grpc_exec(
+            self.directory_service.EnableDirectory.with_call,
+            ToggleDirectoryRequest(organization_id=organization_id, id=directory_id),
+        )
+
+    def disable_directory(self, organization_id: str, directory_id: str) -> ToggleDirectoryResponse:
+        """
+        Method to disable directory based on given organization and directory id
+
+        :param organization_id   :     Organization id
+        :type                    :     ``` str ```
+        :param directory_id      :     directory id
+        :type                    :     ``` str ```
+
+        :returns:
+             Toggle Directory Response
+        """
+        return self.core_client.grpc_exec(
+            self.directory_service.DisableDirectory.with_call,
+            ToggleDirectoryRequest(organization_id=organization_id, id=directory_id),
+        )
+
+    def get_primary_directory_by_organization_id(self, organization_id: str):
+        """
+        Method to get primary directory based on given organization id
+
+        :param organization_id   :     Organization id
+        :type                    :     ``` str ```
+
+        :returns:
+            Primary directory
+        """
+        response = self.core_client.grpc_exec(
+            self.directory_service.ListDirectories.with_call,
+            ListDirectoriesRequest(organization_id=organization_id),
+        )
+
+        if response[0].directories:
+            return response[0].directories[0]
+        else:
+            raise Exception("Directory does not exist for given Organization Id.")

{scalekit_sdk_python-1.0.2 → scalekit_sdk_python-1.0.4}/scalekit/organization.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, List, Dict
 
 from scalekit.core import CoreClient
 from scalekit.v1.organizations.organizations_pb2 import *
@@ -172,6 +172,7 @@ class OrganizationClient:
 
         :param organization_id       : Organization id to delete portal link for
         :type               : ``` str ```
+
         :returns:
             None
         """
@@ -179,3 +180,21 @@ class OrganizationClient:
             self.organization_service.DeletePortalLink.with_call,
             DeletePortalLinkRequest(id=organization_id),
         )
+
+    def update_organization_settings(self, organization_id: str, settings: List[Dict[str, bool]]):
+        """
+        Method to update organization settings
+
+        :param organization_id    : Organization id for org update
+        :type                     : ``` str ```
+        :param settings           : Organization settings
+        :type                     : ``` list[dict[str, bool]] ```
+
+        :returns:
+            None
+        """
+        self.core_client.grpc_exec(
+            self.organization_service.UpdateOrganizationSettings.with_call,
+            UpdateOrganizationSettingsRequest(
+                id=organization_id, settings={'features': settings})
+        )