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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scalekit-sdk-python
-Version: 1.0.3
+Version: 1.0.4
 Summary: Scalekit official Python SDK
 Home-page: https://github.com/scalekit-inc/scalekit-sdk-python
 Author: Team Scalekit
@@ -11,16 +11,16 @@ 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.3 → 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.3 → scalekit_sdk_python-1.0.4}/scalekit/client.py

@@ -1,12 +1,19 @@
-from typing import Any, Dict, Optional
+
 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,
@@ -16,10 +23,16 @@ from scalekit.common.scalekit import (
 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):
         """
@@ -31,7 +44,8 @@ class ScalekitClient:
         :type                 : ``` str ```
         :param client_secret  : Client Secret
         :type                 : ``` str ```
-        :returns
+
+        :returns:
             None
         """
         try:
@@ -41,6 +55,7 @@ class ScalekitClient:
             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
 
@@ -52,9 +67,10 @@ class ScalekitClient:
 
         :param redirect_uri   : Redirect URI for SAML SSO
         :type                 : ``` str ```
-        :param options        : ``` Auth URL options object```
+        :param options        : Auth URL options object
         :type                 : ``` obj ```
-        :returns
+
+        :returns:
             Authorization URL
         """
         try:
@@ -92,8 +108,9 @@ class ScalekitClient:
         :type                 : ``` str ```
         :param redirect_uri   : Redirect URI
         :type                 : ``` str ```
-        :param options        : ``` CodeAuthenticationOptions Object ```
+        :param options        : CodeAuthenticationOptions Object
         :type                 : ``` obj ```
+
         :returns:
             dict with user, id token & access token
         """
@@ -131,7 +148,8 @@ class ScalekitClient:
 
         :param token : access token
         :type        : ``` str ```
-        :returns
+
+        :returns:
             bool
         """
         try:
@@ -146,7 +164,8 @@ class ScalekitClient:
 
         :param idp_initiated_login_token : IDP initiated login token
         :type        : ``` str ```
-        :returns
+
+        :returns:
             ``` IdpInitiatedLoginClaims ```
         """
         try:
@@ -163,7 +182,8 @@ class ScalekitClient:
 
         :param token : token
         :type        : ``` str ```
-        :returns
+
+        :returns:
             payload
         """
         self.core_client.get_jwks()
@@ -171,3 +191,101 @@ class ScalekitClient:
         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.3 → scalekit_sdk_python-1.0.4}/scalekit/core.py

@@ -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.3 → 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})
+        )

scalekit_sdk_python-1.0.4/scalekit/utils/directory.py

@@ -0,0 +1,81 @@
+
+from google.protobuf import message as _message
+from google.protobuf import timestamp_pb2 as _timestamp_pb2
+from google.protobuf.internal import containers as _containers
+from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, \
+    Union as _Union
+
+from scalekit.v1.directories.directories_pb2 import DirectoryGroup
+
+
+class DirUser(_message.Message):
+    """ """
+    __slots__ = ("id", "email", "preferred_username", "given_name", "family_name", "updated_at", "emails", "groups", "user_detail")
+    ID_FIELD_NUMBER: _ClassVar[int]
+    EMAIL_FIELD_NUMBER: _ClassVar[int]
+    PREFERRED_USERNAME_FIELD_NUMBER: _ClassVar[int]
+    GIVEN_NAME_FIELD_NUMBER: _ClassVar[int]
+    FAMILY_NAME_FIELD_NUMBER: _ClassVar[int]
+    UPDATED_AT_FIELD_NUMBER: _ClassVar[int]
+    EMAILS_FIELD_NUMBER: _ClassVar[int]
+    GROUPS_FIELD_NUMBER: _ClassVar[int]
+    USER_DETAIL_FIELD_NUMBER: _ClassVar[int]
+    id: str | None
+    email: str | None
+    preferred_username: str | None
+    given_name: str | None
+    family_name: str | None
+    updated_at: _timestamp_pb2.Timestamp | None
+    emails: _containers.RepeatedScalarFieldContainer[str] | None
+    groups: _containers.RepeatedCompositeFieldContainer[DirectoryGroup] | None
+    user_detail: str | None
+
+    def __init__(self): ...
+
+
+class DirGroup(_message.Message):
+    """ """
+    __slots__ = ("id", "display_name", "total_users", "updated_at", "group_detail")
+    ID_FIELD_NUMBER: _ClassVar[int]
+    DISPLAY_NAME_FIELD_NUMBER: _ClassVar[int]
+    TOTAL_USERS_FIELD_NUMBER: _ClassVar[int]
+    UPDATED_AT_FIELD_NUMBER: _ClassVar[int]
+    GROUP_DETAIL_FIELD_NUMBER: _ClassVar[int]
+    id: str | None
+    display_name: str | None
+    total_users: int | None
+    updated_at: _timestamp_pb2.Timestamp | None
+    group_detail: str | None
+    def __init__(self): ...
+
+
+class ListDirUsersResponse(_message.Message):
+    __slots__ = ("users", "total_size", "next_page_token", "prev_page_token")
+    USERS_FIELD_NUMBER: _ClassVar[int]
+    TOTAL_SIZE_FIELD_NUMBER: _ClassVar[int]
+    NEXT_PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    PREV_PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    users: _containers.RepeatedCompositeFieldContainer[DirUser]
+    total_size: int
+    next_page_token: str
+    prev_page_token: str
+
+    def __init__(self, users: _Optional[_Iterable[_Union[DirUser, _Mapping]]] = ...,
+                 total_size: _Optional[int] = ..., next_page_token: _Optional[str] = ...,
+                 prev_page_token: _Optional[str] = ...) -> None: ...
+
+
+class ListDirGroupsResponse(_message.Message):
+    __slots__ = ("groups", "total_size", "next_page_token", "prev_page_token")
+    GROUPS_FIELD_NUMBER: _ClassVar[int]
+    TOTAL_SIZE_FIELD_NUMBER: _ClassVar[int]
+    NEXT_PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    PREV_PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    groups: _containers.RepeatedCompositeFieldContainer[DirGroup]
+    total_size: int
+    next_page_token: str
+    prev_page_token: str
+
+    def __init__(self, groups: _Optional[_Iterable[_Union[DirGroup, _Mapping]]] = ...,
+                 total_size: _Optional[int] = ..., next_page_token: _Optional[str] = ...,
+                 prev_page_token: _Optional[str] = ...) -> None: ...