scalekit-sdk-python 2.5.0__tar.gz → 2.6.1__tar.gz

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/PKG-INFO

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

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/scalekit/_version.py

@@ -1,3 +1,3 @@
 # Single source of truth for the SDK version.
 # Import this in setup.py and scalekit/core.py — never hardcode the version elsewhere.
-__version__ = "2.5.0"
+__version__ = "2.6.1"

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/scalekit/actions/actions.py

@@ -641,7 +641,7 @@ class ActionClient:
         :type: str
         :param identifier: Connected account identifier (required)
         :type: str
-        :param authorization_details: Authorization details (OAuth token or static auth) (optional, empty auth will be used if not provided)
+        :param authorization_details: Authorization details (OAuth token or static auth) (optional)
         :type: Optional[Dict[str, Any]]
         :param organization_id: Organization ID (optional)
         :type: str
@@ -672,13 +672,10 @@ class ActionClient:
             
         except ScalekitNotFoundException:
             # Connected account doesn't exist, create a new one
-            # Use empty authorization details if none provided
-            auth_details = authorization_details if authorization_details is not None else {}
-            
             return self.create_connected_account(
                 connection_name=connection_name,
                 identifier=identifier,
-                authorization_details=auth_details,
+                authorization_details=authorization_details,
                 organization_id=organization_id,
                 user_id=user_id,
                 api_config=api_config

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/scalekit/actions/models/requests/create_connected_account_request.py

@@ -14,7 +14,7 @@ class CreateConnectedAccountRequest(BaseModel):
 
     connection_name: str = Field(..., description="Connector identifier")
     identifier: str = Field(..., description="Connected account identifier")
-    authorization_details: Dict[str, Any] = Field(default_factory=dict, description="Authorization details (OAuth token or static auth)")
+    authorization_details: Optional[Dict[str, Any]] = Field(None, description="Authorization details (OAuth token or static auth)")
     organization_id: Optional[str] = Field(None, description="Organization ID")
     user_id: Optional[str] = Field(None, description="User ID")
     api_config: Optional[Dict[str, Any]] = Field(None, description="Optional API configuration for the connected account")
@@ -45,15 +45,6 @@ class CreateConnectedAccountRequest(BaseModel):
             static_auth = StaticAuth(details=struct_details)
             auth_details = AuthorizationDetails(static_auth=static_auth)
         
-        elif not self.authorization_details:
-            # Create empty OAuth token for empty authorization details
-            oauth_token = OauthToken(
-                access_token="",
-                refresh_token="",
-                scopes=[]
-            )
-            auth_details = AuthorizationDetails(oauth_token=oauth_token)
-
         # Handle api_config if provided
         api_config_struct = None
         if self.api_config:

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/scalekit/client.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import json
 from math import floor
 from typing import Any, Optional, Dict
@@ -203,7 +204,7 @@ class ScalekitClient:
         except Exception:
             return False
 
-    def generate_client_token(self, client_id: str, client_secret: str) -> str:
+    def generate_client_token(self, client_id: str, client_secret: str, scopes: Optional[list[str]] = None) -> str:
         """
         Method to generate access token
 
@@ -211,22 +212,40 @@ class ScalekitClient:
         :type                           : ``` str ```
         :param client_secret : Client Secret for access token
         :type                            : ``` str ```
+        :param scopes        : Optional list of scopes to be requested in the token (e.g. ["read:users", "write:users"])
+        :type                            : ``` list[str] ```
         :returns:
             access token
         """
         try:
-            response = self.core_client.authenticate(
-                    {
-                        "grant_type": GrantType.ClientCredentials.value,
-                        "client_id": client_id,
-                        "client_secret": client_secret,
-                    }
-            )
+            payload = {
+                "grant_type": GrantType.ClientCredentials.value,
+                "client_id": client_id,
+                "client_secret": client_secret,
+                }
+            if scopes:
+                payload["scope"] = " ".join(scopes)
+
+            response = self.core_client.authenticate(payload)
             response = json.loads(response.content)
-            return response
+            return response['access_token']
         except Exception as exp:
             raise exp
 
+    def get_client_access_token(self) -> str:
+        """
+        Method to generate an access token using the stored client credentials.
+
+        Uses the client_id and client_secret supplied to the ScalekitClient constructor.
+
+        :returns:
+            access token string
+        """
+        return self.generate_client_token(
+            self.core_client.client_id,
+            self.core_client.client_secret,
+        )
+
     def validate_access_token_and_get_claims(self, token: str, options: Optional[TokenValidationOptions] = None, audience = None) -> Dict[str, Any]:
         """
         Method to validate access token and get claims

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/scalekit/core.py

@@ -28,7 +28,7 @@ class CoreClient:
     """Class definition for Core Client"""
 
     sdk_version = f"Scalekit-Python/{_sdk_version}"
-    api_version = "20260226"
+    api_version = "20260310"
     user_agent = f"{sdk_version} Python/{platform.python_version()} ({platform.system()}; {platform.architecture()}"
 
     def __init__(self, env_url, client_id, client_secret):

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/scalekit/directory.py

@@ -154,7 +154,7 @@ class DirectoryClient:
         :type                    :     ``` str ```
 
         :returns:
-             list of directory users
+             list of directory groups
         """
         response = self.core_client.grpc_exec(
             self.directory_service.ListDirectoryGroups.with_call,

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/scalekit/m2m_client.py

@@ -61,7 +61,7 @@ class M2MClient:
         :param client_id        : client id
         :type                  : ``` str ```
         :returns:
-            None
+            GetOrganizationClientResponse: The organization client details
         """
         return self.core_client.grpc_exec(
             self.client_service.GetOrganizationClient.with_call,

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/scalekit/organization.py

@@ -24,21 +24,28 @@ class OrganizationClient:
         )
 
     def list_organizations(
-        self, page_size: int, page_token: Optional[str] = None
+        self,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
     ) -> ListOrganizationsResponse:
         """
         Method to list organizations
 
-        :param page_size  : page size for org list fetch
+        :param page_size  : page size for org list fetch (optional, uses server default if not provided)
         :type             : ``` int ```
         :param page_token : page token for org list fetch
         :type             : ``` str ```
         :returns:
              list of organizations
         """
+        request = ListOrganizationsRequest()
+        if page_size is not None:
+            request.page_size = page_size
+        if page_token is not None:
+            request.page_token = page_token
         return self.core_client.grpc_exec(
             self.organization_service.ListOrganization.with_call,
-            ListOrganizationsRequest(page_size=page_size, page_token=page_token),
+            request,
         )
 
     def create_organization(

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/scalekit/role.py

@@ -42,9 +42,9 @@ class RoleClient:
 
     def get_role(self, role_name: str) -> GetRoleResponse:
         """
-        Method to get role by ID
+        Method to get role by name
 
-        :param role_id        : Role id to get role details
+        :param role_name      : Role name to get role details
         :type                 : ``` str ```
 
         :returns:
@@ -73,9 +73,9 @@ class RoleClient:
         role: UpdateRole
     ) -> UpdateRoleResponse:
         """
-        Method to update an existing role by ID
+        Method to update an existing role by name
 
-        :param role_id        : Role id to update
+        :param role_name      : Role name to update
         :type                 : ``` str ```
         :param role           : UpdateRole object with expected values for role update
         :type                 : ``` obj ```
@@ -97,9 +97,9 @@ class RoleClient:
         reassign_role_name: Optional[str] = None
     ):
         """
-        Method to delete role by ID
+        Method to delete role by name
 
-        :param role_id        : Role id to be deleted
+        :param role_name      : Role name to be deleted
         :type                 : ``` str ```
         :param reassign_role_name: Role name to reassign users to when deleting this role
         :type                 : ``` str ```
@@ -116,14 +116,32 @@ class RoleClient:
             request,
         )
 
+    def delete_role_base(
+        self,
+        role_name: str
+    ):
+        """
+        Method to delete the base inheritance relationship for an environment-level role
+
+        :param role_name      : Role name to remove base relationship for
+        :type                 : ``` str ```
+
+        :returns:
+            None
+        """
+        return self.core_client.grpc_exec(
+            self.role_service.DeleteRoleBase.with_call,
+            DeleteRoleBaseRequest(role_name=role_name),
+        )
+
     def get_role_users_count(
-        self, 
+        self,
         role_name: str
     ) -> GetRoleUsersCountResponse:
         """
         Method to get the count of users associated with a role
 
-        :param role_id        : Role id to get user count for
+        :param role_name      : Role name to get user count for
         :type                 : ``` str ```
 
         :returns:

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/scalekit_sdk_python.egg-info/PKG-INFO

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

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/tests/test_actions.py

@@ -640,6 +640,42 @@ class TestConnect(BaseTest):
         except Exception as e:
             raise e
 
+    def test_get_or_create_connected_account_no_auth_details(self):
+        """Method to test get_or_create_connected_account creates account without authorization_details (no empty token sent)"""
+        import uuid
+
+        test_id = f"test_no_auth_{uuid.uuid4().hex[:8]}"
+
+        try:
+            # Create with no authorization_details — should NOT send an empty OAuth token
+            result = self.scalekit_client.connect.get_or_create_connected_account(
+                connection_name="GMAIL",
+                identifier=test_id,
+            )
+
+            self.assertIsNotNone(result)
+            self.assertIsInstance(result, CreateConnectedAccountResponse)
+            self.assertIsNotNone(result.connected_account)
+            self.assertEqual(result.connected_account.identifier, test_id)
+
+            # Calling again should return the same account, not create a second one
+            result2 = self.scalekit_client.connect.get_or_create_connected_account(
+                connection_name="GMAIL",
+                identifier=test_id,
+            )
+
+            self.assertIsNotNone(result2)
+            self.assertEqual(result.connected_account.id, result2.connected_account.id)
+
+            # Clean up
+            self.scalekit_client.connect.delete_connected_account(
+                connection_name="GMAIL",
+                identifier=test_id,
+            )
+
+        except Exception as e:
+            raise e
+
     def test_get_or_create_connected_account_validation(self):
         """Method to test get_or_create_connected_account parameter validation"""
         # Test missing connection_name
@@ -715,18 +751,17 @@ class TestConnect(BaseTest):
         self.assertIsNotNone(proto)
         self.assertTrue(proto.authorization_details.HasField("oauth_token"))
 
-        # Test empty auth details
+        # Test no auth details — should not send any authorization_details in proto
         empty_request = CreateConnectedAccountRequest(
             connection_name="TEST",
             identifier="test_user"
         )
 
-        self.assertEqual(empty_request.authorization_details, {})
+        self.assertIsNone(empty_request.authorization_details)
 
         empty_proto = empty_request.to_proto()
         self.assertIsNotNone(empty_proto)
-        self.assertTrue(empty_proto.authorization_details.HasField("oauth_token"))
-        self.assertEqual(empty_proto.authorization_details.oauth_token.access_token, "")
+        self.assertFalse(empty_proto.HasField("authorization_details"))
 
     @unittest.skip
     def test_google_adk_get_tools(self):

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/tests/test_m2m_client.py

@@ -3,6 +3,7 @@ from faker import Faker
 
 from basetest import BaseTest
 from scalekit.common.exceptions import ScalekitNotFoundException, ScalekitBadRequestException
+from scalekit.common.scalekit import TokenValidationOptions
 from scalekit.v1.organizations.organizations_pb2 import CreateOrganization
 from scalekit.v1.clients.clients_pb2 import OrganizationClient
 
@@ -361,17 +362,23 @@ class TestM2MClient(BaseTest):
         client_id = create_response[0].client.client_id
         client_secret = create_response[0].plain_secret
 
-        token_response = self.scalekit_client.generate_client_token(
-           client_id=client_id, client_secret=client_secret
+        token = self.scalekit_client.generate_client_token(
+           client_id=client_id, client_secret=client_secret, scopes=["write", "read"]
         )
 
-        token = token_response["access_token"]
         return token, client_id, client_secret
 
+    def test_get_client_access_token(self):
+        """ Method to test get_client_access_token uses stored credentials """
+        token = self.scalekit_client.get_client_access_token()
+        self.assertIsNotNone(token)
+        self.assertIsInstance(token, str)
+        self.assertGreater(len(token), 0)
+
     def test_token_validation(self):
         """ Method to test token validation """
         token, client_id, client_secret = self.__generate_token_for_org()
-        claims = self.scalekit_client.validate_access_token_and_get_claims(token=token)
+        claims = self.scalekit_client.validate_access_token_and_get_claims(token=token, audience="my-own-api", options=TokenValidationOptions(required_scopes=["write", "read"]))
         self.assertIsNotNone(claims)
         self.assertIn("client_id", claims)
         self.assertIn("my-own-api", claims["aud"])
@@ -380,7 +387,7 @@ class TestM2MClient(BaseTest):
         self.assertIn("wksp_id", claims["custom_claims"])
 
         # with Audience check enforced 
-        claims = self.scalekit_client.validate_access_token_and_get_claims(token=token, audience="my-own-api")
+        claims = self.scalekit_client.validate_access_token_and_get_claims(token=token, audience="my-own-api", )
 
         self.assertIsNotNone(claims)
         self.assertIn("client_id", claims)

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/tests/test_organization.py

@@ -65,6 +65,13 @@ class TestOrganization(BaseTest):
         self.assertEqual(response[0].organizations[0].id, self.org_id)
         self.assertEqual(response[0].organizations[0].display_name, organization.display_name)
 
+    def test_list_organizations_no_params(self):
+        """ Method to test list organizations with no pagination params (both optional) """
+        response = self.scalekit_client.organization.list_organizations()
+        self.assertEqual(response[1].code().name, "OK")
+        self.assertTrue(response[0] is not None)
+        self.assertGreaterEqual(len(response[0].organizations), 0)
+
     def test_update_organization(self):
         """ Method to test update organization """
         organization = CreateOrganization(display_name=Faker().company(), external_id=Faker().uuid4())

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/tests/test_roles.py

@@ -309,6 +309,34 @@ class TestRoles(BaseTest):
             # Expected behavior - duplicate name error
             self.assertTrue(exp.message, 'duplicate key not allowed')
 
+    def test_delete_role_base(self):
+        """ Method to test deleting the base inheritance relationship for an environment-level role """
+        # Create a base role
+        base_role_name = f"test_base_role_{self.faker.unique.random_number()}"
+        base_role = CreateRole(
+            name=base_role_name,
+            display_name=f"Base Role {self.faker.unique.random_number()}",
+            description="Base role for inheritance testing"
+        )
+        self.scalekit_client.roles.create_role(role=base_role)
+
+        # Create a role that extends the base role
+        self.role_name = f"test_child_role_{self.faker.unique.random_number()}"
+        child_role = CreateRole(
+            name=self.role_name,
+            display_name=f"Child Role {self.faker.unique.random_number()}",
+            description="Child role extending base role",
+            extends=base_role_name
+        )
+        self.scalekit_client.roles.create_role(role=child_role)
+
+        # Delete the base relationship
+        response = self.scalekit_client.roles.delete_role_base(role_name=self.role_name)
+        self.assertEqual(response[1].code().name, "OK")
+
+        # Cleanup base role manually (tearDown handles child role via self.role_name)
+        self.scalekit_client.roles.delete_role(role_name=base_role_name)
+
     def test_get_role_users_count(self):
         """ Method to test get role users count """
         self.role_name = f"test_role_{self.faker.unique.random_number()}"

{scalekit_sdk_python-2.5.0 → scalekit_sdk_python-2.6.1}/tests/test_users.py

@@ -6,7 +6,7 @@ from scalekit.v1.users.users_pb2 import CreateUser, UpdateUser, CreateUserProfil
 from scalekit.v1.commons.commons_pb2 import Role
 from scalekit.v1.organizations.organizations_pb2 import CreateOrganization
 
-from scalekit.common.exceptions import ScalekitNotFoundException
+from scalekit.common.exceptions import ScalekitNotFoundException, ScalekitBadRequestException
 
 
 class TestUsers(BaseTest):
@@ -511,41 +511,47 @@ class TestUsers(BaseTest):
 
     def tearDown(self):
         """ Method to clean up """
+        errors = []
+
         if self.user_id:
             try:
-                # First try to delete membership if it exists
-                try:
-                    self.scalekit_client.users.delete_membership(
-                        organization_id=self.org_id,
-                        user_id=self.user_id
-                    )
-                except Exception:
-                    pass
-                
-                # Then try to delete the user
+                self.scalekit_client.users.delete_membership(
+                    organization_id=self.org_id,
+                    user_id=self.user_id
+                )
+            except ScalekitNotFoundException:
+                pass  # membership may not exist — expected
+            except Exception as exp:
+                errors.append(exp)
+
+            try:
                 self.scalekit_client.users.delete_user(user_id=self.user_id)
-            except Exception:
-                pass
-        
+            except Exception as exp:
+                errors.append(exp)
+
         if self.external_id:
             try:
-                # First try to delete membership if it exists
-                try:
-                    self.scalekit_client.users.delete_membership_by_external_id(
-                        organization_id=self.org_id,
-                        external_id=self.external_id
-                    )
-                except Exception:
-                    pass
-                
-                # Then try to delete the user
+                self.scalekit_client.users.delete_membership_by_external_id(
+                    organization_id=self.org_id,
+                    external_id=self.external_id
+                )
+            except (ScalekitNotFoundException, ScalekitBadRequestException):
+                pass  # membership may not exist or user already deleted — expected
+            except Exception as exp:
+                errors.append(exp)
+
+            try:
                 self.scalekit_client.users.delete_user_by_external_id(external_id=self.external_id)
-            except Exception:
-                pass
-        
-        # Clean up created organization
-        try:
-            if self.org_id:
+            except (ScalekitNotFoundException, ScalekitBadRequestException):
+                pass  # user may have been deleted by the test itself — expected
+            except Exception as exp:
+                errors.append(exp)
+
+        if self.org_id:
+            try:
                 self.scalekit_client.organization.delete_organization(organization_id=self.org_id)
-        except Exception as exp:
-            raise exp
+            except Exception as exp:
+                errors.append(exp)
+
+        if errors:
+            raise Exception(f"Errors during tearDown cleanup: {errors}")