scalekit-sdk-python 2.3.3__tar.gz → 2.4.1__tar.gz

{scalekit_sdk_python-2.3.3/scalekit_sdk_python.egg-info → scalekit_sdk_python-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scalekit-sdk-python
-Version: 2.3.3
+Version: 2.4.1
 Summary: Scalekit official Python SDK
 Home-page: https://github.com/scalekit-inc/scalekit-sdk-python
 Author: Team Scalekit
@@ -17,15 +17,16 @@ Requires-Dist: google>=3.0
 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: cryptography==45.0.6
 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
 Requires-Dist: deprecation>=2.1.0
-Requires-Dist: python-dotenv~=1.0.1
+Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: Faker~=25.8.0
 Requires-Dist: pydantic~=2.10.6
+Requires-Dist: langchain-core<0.4,>=0.3.36
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{scalekit_sdk_python-2.3.3 → scalekit_sdk_python-2.4.1}/scalekit/connect/connect.py

@@ -1,13 +1,18 @@
-from typing import Optional, Dict, Any, List
+from typing import Optional, Any, List, Dict
 from scalekit.v1.mcp.mcp_pb2 import Mcp
 from scalekit.v1.mcp.mcp_pb2 import ToolMapping as ProtoToolMapping
 
 from scalekit.connect.models.tool_mapping import ToolMapping
-from scalekit.connect.types import ToolRequest,ExecuteToolResponse,MagicLinkResponse,ListConnectedAccountsResponse,DeleteConnectedAccountResponse,GetConnectedAccountAuthResponse,ToolInput,ToolOutput,McpRequest,CreateMcpResponse,GetMcpResponse
+from scalekit.connect.types import ToolRequest,ExecuteToolResponse,MagicLinkResponse,ListConnectedAccountsResponse,DeleteConnectedAccountResponse,GetConnectedAccountAuthResponse,ToolInput, \
+    McpRequest,CreateMcpResponse,GetMcpResponse
+from scalekit.connect.models.responses.create_connected_account_response import CreateConnectedAccountResponse
+from scalekit.connect.models.requests.create_connected_account_request import CreateConnectedAccountRequest
 from scalekit.connect.modifier import (
     Modifier, ModifierType, ToolNames,
     apply_pre_modifiers, apply_post_modifiers
 )
+from scalekit.connect.frameworks.langchain import LangChain
+from scalekit.common.exceptions import ScalekitNotFoundException
 
 
 
@@ -34,6 +39,9 @@ class ConnectClient:
         self.connected_accounts = connected_accounts_client
         self.mcp = mcp_client
         self._modifiers: List[Modifier] = []
+        
+        # Initialize LangChain with tools client and execute callback
+        self.langchain = LangChain(tools_client, execute_callback=self.execute_tool)
 
     def execute_tool(
         self,
@@ -59,8 +67,6 @@ class ConnectClient:
             ExecuteToolResponse containing execution results
         """
         # Validate required parameters
-        if not tool_input:
-            raise ValueError("tool_input is required")
         if not tool_name:
             raise ValueError("tool_name is required")
         
@@ -358,4 +364,121 @@ class ConnectClient:
         proto_response = result_tuple[0]
         
         # Convert proto to our CreateMcpResponse class
-        return CreateMcpResponse.from_proto(proto_response)
+        return CreateMcpResponse.from_proto(proto_response)
+
+    def create_connected_account(
+        self,
+        connection_name: str,
+        identifier: str, 
+        authorization_details: Dict[str, Any],
+        organization_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        **kwargs
+    ) -> CreateConnectedAccountResponse:
+        """
+        Create a new connected account
+        
+        :param connection_name: Connector identifier (required)
+        :type: str
+        :param identifier: Connected account identifier (required)
+        :type: str
+        :param authorization_details: Authorization details (OAuth token or static auth) (required)
+        :type: Dict[str, Any]
+        :param organization_id: Organization ID (optional)
+        :type: str
+        :param user_id: User ID (optional)
+        :type: str
+        
+        :returns:
+            CreateConnectedAccountResponse containing created connected account details
+        """
+        # Validate required parameters
+        if not connection_name:
+            raise ValueError("connection_name is required")
+        if not identifier:
+            raise ValueError("identifier is required")
+        if not authorization_details:
+            raise ValueError("authorization_details is required")
+        
+        # Create request model
+        request = CreateConnectedAccountRequest(
+            connection_name=connection_name,
+            identifier=identifier,
+            authorization_details=authorization_details,
+            organization_id=organization_id,
+            user_id=user_id
+        )
+        
+        # Convert to protobuf
+        connected_account_proto = request.to_proto()
+        
+        # Call the existing connected_accounts method which returns (response, metadata) tuple
+        result_tuple = self.connected_accounts.create_connected_account(
+            connector=connection_name,
+            identifier=identifier,
+            connected_account=connected_account_proto,
+            organization_id=organization_id,
+            user_id=user_id
+        )
+        
+        # Extract the response[0] (the actual CreateConnectedAccountResponse proto object)
+        proto_response = result_tuple[0]
+        
+        # Convert proto to our CreateConnectedAccountResponse class
+        return CreateConnectedAccountResponse.from_proto(proto_response)
+
+    def get_or_create_connected_account(
+        self,
+        connection_name: str,
+        identifier: str,
+        authorization_details: Optional[Dict[str, Any]] = None,
+        organization_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        **kwargs
+    ) -> CreateConnectedAccountResponse:
+        """
+        Get an existing connected account or create a new one if it doesn't exist
+        
+        :param connection_name: Connector identifier (required)
+        :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)
+        :type: Optional[Dict[str, Any]]
+        :param organization_id: Organization ID (optional)
+        :type: str
+        :param user_id: User ID (optional)
+        :type: str
+        
+        :returns:
+            CreateConnectedAccountResponse containing connected account details (either existing or newly created)
+        """
+        if not connection_name:
+            raise ValueError("connection_name is required")
+        if not identifier:
+            raise ValueError("identifier is required")
+
+        try:
+            # First, try to get the existing connected account
+            existing_response = self.get_connected_account(
+                connection_name=connection_name,
+                identifier=identifier,
+                organization_id=organization_id,
+                user_id=user_id
+            )
+            
+            # If we found it, convert the GetConnectedAccountAuthResponse to CreateConnectedAccountResponse format
+            return CreateConnectedAccountResponse(connected_account=existing_response.connected_account)
+            
+        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,
+                organization_id=organization_id,
+                user_id=user_id
+            )

scalekit_sdk_python-2.4.1/scalekit/connect/frameworks/langchain.py

@@ -0,0 +1,125 @@
+from typing import Optional, Any, Dict, List, Callable
+from langchain_core.tools import StructuredTool
+from scalekit.tools import ToolsClient
+from scalekit.v1.tools.tools_pb2 import Filter, ScopedToolFilter
+
+
+class LangChain:
+    def __init__(self, tools_client: ToolsClient, execute_callback: Callable):
+        if not execute_callback:
+            raise ValueError("execute_callback is required. LangChain must be initialized with ConnectClient's execute_tool method.")
+        
+        self.tools = tools_client
+        self.execute_callback = execute_callback
+    
+    def get_tools(
+        self,
+        identifier: str,
+        providers: Optional[List[str]] = None,
+        tool_names: Optional[List[str]] = None,
+        connection_names: Optional[List[str]] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None
+    ) -> List[StructuredTool]:
+        """
+        Get scoped tools from Scalekit and convert them to LangChain StructuredTools
+        
+        :param identifier: Identifier to scope the tools list
+        :param providers: List of provider names to filter by
+        :param tool_names: List of tool names to filter by
+        :param connection_names: List of connection names to filter by
+        :param page_size: Maximum number of tools to return per page  
+        :param page_token: Token from a previous response for pagination
+        :returns: List of LangChain StructuredTools
+        """
+        if identifier is None or identifier == "":
+            raise ValueError("Identifier must be provided to get tools")
+
+        # Create ScopedToolFilter if any filter parameters are provided
+        scoped_filter = None
+        if providers or tool_names or connection_names:
+            scoped_filter = ScopedToolFilter(
+                providers=providers or [],
+                tool_names=tool_names or [],
+                connection_names=connection_names or []
+            )
+
+        # Call list_scoped_tools which returns (response, metadata) tuple
+        result_tuple = self.tools.list_scoped_tools(identifier, scoped_filter, page_size, page_token)
+        
+        # Extract the response[0] (the actual ListScopedToolsResponse proto object)
+        response = result_tuple[0]
+        
+        structured_tools = []
+        for scoped_tool in response.tools:
+            structured_tool = self._convert_tool_to_structured_tool(
+                scoped_tool.tool,
+                scoped_tool.connected_account_id
+            )
+            structured_tools.append(structured_tool)
+            
+        return structured_tools
+    
+    def _convert_tool_to_structured_tool(self, tool, connected_account_id: str) -> StructuredTool:
+        """Convert a Scalekit Tool to LangChain StructuredTool"""
+        
+
+        definition_dict = self._struct_to_dict(tool.definition) if hasattr(tool, 'definition') and tool.definition else {}
+        
+
+        tool_name = definition_dict.get('name', getattr(tool, 'provider', 'unknown') + '_tool')
+        tool_description = definition_dict.get('description', 'Scalekit tool')
+        
+
+        args_schema = definition_dict.get("input_schema", {})
+        
+
+        def _call(**arguments: Dict[str, Any]) -> str:
+            try:
+                # Import here to avoid circular imports
+                from scalekit.connect.types import ToolInput
+
+                
+                # Call connect.execute_tool via callback (includes modifiers and enhanced handling)
+                response = self.execute_callback(
+                    tool_input=arguments,
+                    tool_name=tool_name,
+                    connected_account_id=connected_account_id
+                )
+
+
+                result_data = response.data if hasattr(response, 'data') else {}
+
+                execution_id = response.execution_id if hasattr(response, 'execution_id') else None
+                
+                # Format the response
+                result_dict = dict(result_data) if result_data else {}
+                if execution_id:
+                    result_dict['execution_id'] = execution_id
+                
+                return str(result_dict) if result_dict else f"Tool {tool_name} executed successfully"
+                
+            except Exception as e:
+                return f"Error executing tool {tool_name}: {str(e)}"
+        
+        # Sync wrapper
+        def call_tool_sync(**arguments: Dict[str, Any]) -> str:
+            return _call(**arguments)
+        
+        # Async wrapper
+        async def call_tool_async(**arguments: Dict[str, Any]) -> str:
+            return _call(**arguments)
+
+        # TODO add metadata to the tool if available
+        return StructuredTool(
+            name=tool_name,
+            description=tool_description,
+            args_schema=args_schema,
+            func=call_tool_sync,
+            coroutine=call_tool_async,
+        )
+    
+    def _struct_to_dict(self, struct) -> Dict[str, Any]:
+        """Convert protobuf Struct to Python dict"""
+        from google.protobuf.json_format import MessageToDict
+        return MessageToDict(struct)

scalekit_sdk_python-2.4.1/scalekit/connect/models/requests/create_connected_account_request.py

@@ -0,0 +1,60 @@
+from typing import Optional, Dict, Any, List
+from pydantic import BaseModel, Field
+from scalekit.v1.connected_accounts.connected_accounts_pb2 import (
+    CreateConnectedAccount,
+    AuthorizationDetails,
+    OauthToken,
+    StaticAuth
+)
+from google.protobuf import struct_pb2
+
+
+class CreateConnectedAccountRequest(BaseModel):
+    """Create connected account request model"""
+    
+    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)")
+    organization_id: Optional[str] = Field(None, description="Organization ID")
+    user_id: Optional[str] = Field(None, description="User ID")
+
+    def to_proto(self) -> CreateConnectedAccount:
+        """
+        Convert to protobuf CreateConnectedAccount object
+        
+        :returns:
+            CreateConnectedAccount protobuf object
+        """
+        auth_details = None
+        
+        if self.authorization_details and "oauth_token" in self.authorization_details:
+            oauth_data = self.authorization_details["oauth_token"]
+            oauth_token = OauthToken(
+                access_token=oauth_data.get("access_token", ""),
+                refresh_token=oauth_data.get("refresh_token", ""),
+                scopes=oauth_data.get("scopes", [])
+            )
+            auth_details = AuthorizationDetails(oauth_token=oauth_token)
+            
+        elif self.authorization_details and "static_auth" in self.authorization_details:
+            static_data = self.authorization_details["static_auth"]
+            # Convert dict to protobuf Struct
+            struct_details = struct_pb2.Struct()
+            struct_details.update(static_data)
+            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)
+        
+        return CreateConnectedAccount(authorization_details=auth_details)
+
+    class Config:
+        """Pydantic configuration"""
+        validate_assignment = True

scalekit_sdk_python-2.4.1/scalekit/connect/models/responses/create_connected_account_response.py

@@ -0,0 +1,48 @@
+from typing import Optional
+from datetime import datetime
+from pydantic import BaseModel, Field
+from .get_connected_account_auth_response import ConnectedAccount
+
+
+class CreateConnectedAccountResponse(BaseModel):
+    """Create connected account response with one-to-one mapping to proto CreateConnectedAccountResponse"""
+    
+    connected_account: Optional[ConnectedAccount] = Field(
+        None,
+        description="Created connected account details"
+    )
+
+    @classmethod
+    def from_proto(cls, proto_response) -> 'CreateConnectedAccountResponse':
+        """
+        Create CreateConnectedAccountResponse from protobuf CreateConnectedAccountResponse
+        
+        :param proto_response: The protobuf CreateConnectedAccountResponse object
+        :type proto_response: CreateConnectedAccountResponse (from connected_accounts_pb2)
+        
+        :returns:
+            CreateConnectedAccountResponse instance
+        """
+        connected_account = None
+        if proto_response.connected_account:
+            connected_account = ConnectedAccount.from_proto(proto_response.connected_account)
+            
+        return cls(connected_account=connected_account)
+
+    def to_dict(self) -> dict:
+        """
+        Convert to dictionary representation
+        
+        :returns:
+            Dictionary representation of the response
+        """
+        return {
+            "connected_account": self.connected_account.model_dump() if self.connected_account else None
+        }
+
+    class Config:
+        """Pydantic configuration"""
+        validate_assignment = True
+        json_encoders = {
+            datetime: lambda v: v.isoformat() if v else None
+        }

{scalekit_sdk_python-2.3.3 → scalekit_sdk_python-2.4.1}/scalekit/connect/models/responses/get_connected_account_auth_response.py

@@ -1,10 +1,10 @@
 from typing import Optional, Dict, Any
 from datetime import datetime
 from pydantic import BaseModel, Field
-from scalekit.v1.connected_accounts.connected_accounts_pb2 import ConnectedAccount, ConnectorStatus, ConnectorType
+from scalekit.v1.connected_accounts.connected_accounts_pb2 import ConnectedAccount as ProtoConnectedAccount, ConnectorStatus, ConnectorType
 
 
-class ConnectedAccountInfo(BaseModel):
+class ConnectedAccount(BaseModel):
     """Connected account information"""
     
     id: Optional[str] = Field(None, description="Unique connected account ID")
@@ -19,15 +19,15 @@ class ConnectedAccountInfo(BaseModel):
     last_used_at: Optional[datetime] = Field(None, description="Last used time")
 
     @classmethod
-    def from_proto(cls, proto_account: ConnectedAccount) -> 'ConnectedAccountInfo':
+    def from_proto(cls, proto_account: ProtoConnectedAccount) -> 'ConnectedAccount':
         """
-        Create ConnectedAccountInfo from protobuf ConnectedAccount
+        Create ConnectedAccount from protobuf ConnectedAccount
         
         :param proto_account: The protobuf ConnectedAccount object
-        :type proto_account: ConnectedAccount
+        :type proto_account: ProtoConnectedAccount
         
         :returns:
-            ConnectedAccountInfo instance
+            ConnectedAccount instance
         """
         # Convert protobuf timestamps to datetime
         token_expires_at = None
@@ -46,14 +46,14 @@ class ConnectedAccountInfo(BaseModel):
         authorization_details = None
         if proto_account.authorization_details:
             authorization_details = {}
-            if proto_account.authorization_details.oauth_token:
+            if proto_account.authorization_type == ConnectorType.OAUTH :
                 oauth_token = proto_account.authorization_details.oauth_token
                 authorization_details["oauth_token"] = {
                     "access_token": oauth_token.access_token,
                     "refresh_token": oauth_token.refresh_token,
                     "scopes": list(oauth_token.scopes)
                 }
-            elif proto_account.authorization_details.static_auth:
+            else:
                 static_auth = proto_account.authorization_details.static_auth
                 # Convert protobuf Struct to dict
                 from google.protobuf.json_format import MessageToDict
@@ -76,7 +76,7 @@ class ConnectedAccountInfo(BaseModel):
 class GetConnectedAccountAuthResponse(BaseModel):
     """Get connected account auth response with one-to-one mapping to proto GetConnectedAccountByIdentifierResponse"""
     
-    connected_account: Optional[ConnectedAccountInfo] = Field(
+    connected_account: Optional[ConnectedAccount] = Field(
         None,
         description="Connected account details"
     )
@@ -94,7 +94,7 @@ class GetConnectedAccountAuthResponse(BaseModel):
         """
         connected_account = None
         if proto_response.connected_account:
-            connected_account = ConnectedAccountInfo.from_proto(proto_response.connected_account)
+            connected_account = ConnectedAccount.from_proto(proto_response.connected_account)
             
         return cls(connected_account=connected_account)
 

{scalekit_sdk_python-2.3.3 → scalekit_sdk_python-2.4.1}/scalekit/connect/types.py

@@ -1,10 +1,12 @@
 from .models.requests.tool_request import ToolRequest
 from .models.requests.mcp_request import McpRequest
+from .models.requests.create_connected_account_request import CreateConnectedAccountRequest
 from .models.responses.execute_tool_response import ExecuteToolResponse
 from .models.responses.magic_link_response import MagicLinkResponse
 from .models.responses.list_connected_accounts_response import ListConnectedAccountsResponse
 from .models.responses.delete_connected_account_response import DeleteConnectedAccountResponse
 from .models.responses.get_connected_account_auth_response import GetConnectedAccountAuthResponse
+from .models.responses.create_connected_account_response import CreateConnectedAccountResponse
 from .models.responses.create_mcp_response import CreateMcpResponse
 from .models.responses.get_mcp_response import GetMcpResponse
 from .models.tool_input_output import ToolInput, ToolOutput
@@ -14,11 +16,13 @@ from .models.tool_mapping import ToolMapping
 __all__ = [
     'ToolRequest',
     'McpRequest',
+    'CreateConnectedAccountRequest',
     'ExecuteToolResponse',
     'MagicLinkResponse',
     'ListConnectedAccountsResponse',
     'DeleteConnectedAccountResponse',
     'GetConnectedAccountAuthResponse',
+    'CreateConnectedAccountResponse',
     'CreateMcpResponse',
     'GetMcpResponse',
     'ToolInput',

{scalekit_sdk_python-2.3.3 → scalekit_sdk_python-2.4.1}/scalekit/core.py

@@ -26,8 +26,8 @@ class WithCall(Protocol):
 class CoreClient:
     """Class definition for Core Client"""
 
-    sdk_version = "Scalekit-Python/2.3.2"
-    api_version = "20250718"
+    sdk_version = "Scalekit-Python/2.4.1"
+    api_version = "20250901"
     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.3.3 → scalekit_sdk_python-2.4.1}/scalekit/domain.py

@@ -1,9 +1,31 @@
 
+from typing import Optional, Union
+
 from scalekit.core import CoreClient
 from scalekit.v1.domains.domains_pb2 import *
 from scalekit.v1.domains.domains_pb2_grpc import DomainServiceStub
 
 
+# String to enum mapping for domain types
+_DOMAIN_TYPE_MAP = {
+    "UNSPECIFIED": DomainType.DOMAIN_TYPE_UNSPECIFIED,
+    "ALLOWED_EMAIL_DOMAIN": DomainType.ALLOWED_EMAIL_DOMAIN,
+    "ORGANIZATION_DOMAIN": DomainType.ORGANIZATION_DOMAIN,
+}
+
+def _convert_domain_type(domain_type: Union[str, "DomainType", None]) -> Optional["DomainType"]:
+    """Convert string or enum to DomainType enum"""
+    if domain_type is None:
+        return None
+    if isinstance(domain_type, str):
+        domain_type_upper = domain_type.upper()
+        if domain_type_upper in _DOMAIN_TYPE_MAP:
+            return _DOMAIN_TYPE_MAP[domain_type_upper]
+        else:
+            raise ValueError(f"Invalid domain type: {domain_type}. Valid options are: {list(_DOMAIN_TYPE_MAP.keys())}")
+    return domain_type
+
+
 class DomainClient:
     """Class definition for Domain Client"""
 
@@ -22,7 +44,7 @@ class DomainClient:
         )
 
     def create_domain(
-        self, organization_id: str, domain_name: str
+        self, organization_id: str, domain_name: str, domain_type: Optional[Union[str, "DomainType"]] = None
     ) -> CreateDomainResponse:
         """
         Method to create domain
@@ -31,14 +53,23 @@ class DomainClient:
         :type                   : ``` str ```
         :param domain_name      : Domain name for new creation
         :type                   : ``` str ```
+        :param domain_type      : Type of domain ("ALLOWED_EMAIL_DOMAIN", "ORGANIZATION_DOMAIN", or "UNSPECIFIED")
+        :type                   : ``` str or DomainType ```
+
         :returns
             Domain Response
         """
+        # Convert domain_type string to enum if needed
+        domain_type_enum = _convert_domain_type(domain_type)
+        
         return self.core_client.grpc_exec(
             self.domain_service.CreateDomain.with_call,
             CreateDomainRequest(
                 organization_id=organization_id,
-                domain=CreateDomain(domain=domain_name),
+                domain=CreateDomain(
+                    domain=domain_name,
+                    domain_type=domain_type_enum
+                ),
             ),
         )
 
@@ -71,3 +102,19 @@ class DomainClient:
             self.domain_service.GetDomain.with_call,
             GetDomainRequest(organization_id=organization_id, id=domain_id),
         )
+    
+    def delete_domain(self, organization_id: str, domain_id: str): 
+        """
+        Method to delete domain
+
+        :param organization_id  : Organization id to delete domain for
+        :type                   : ``` str ```
+        :param domain_id        : Domain id to delete
+        :type                   : ``` str ```
+        :returns
+            None
+        """
+        return self.core_client.grpc_exec(
+            self.domain_service.DeleteDomain.with_call,
+            DeleteDomainRequest(organization_id=organization_id, id=domain_id),
+        )

{scalekit_sdk_python-2.3.3 → scalekit_sdk_python-2.4.1}/scalekit/passwordless.py

@@ -13,7 +13,7 @@ _TEMPLATE_TYPE_MAP = {
     "SIGNUP": TemplateType.SIGNUP,
 }
 
-def _convert_template_type(template: Union[str, TemplateType, None]) -> Optional[TemplateType]:
+def _convert_template_type(template: Union[str, "TemplateType", None]) -> Optional["TemplateType"]:
     """Convert string or enum to TemplateType enum"""
     if template is None:
         return None
@@ -46,7 +46,7 @@ class PasswordlessClient:
     def send_passwordless_email(
         self,
         email: str,
-        template: Optional[Union[str, TemplateType]] = None,
+        template: Optional[Union[str, "TemplateType"]] = None,
         magiclink_auth_uri: Optional[str] = None,
         state: Optional[str] = None,
         expires_in: Optional[int] = None,

{scalekit_sdk_python-2.3.3 → scalekit_sdk_python-2.4.1}/scalekit/tools.py

@@ -57,6 +57,38 @@ class ToolsClient:
 
 
 
+    def list_scoped_tools(
+        self,
+        identifier: str,
+        filter: Optional[ScopedToolFilter] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None
+    ) -> ListScopedToolsResponse:
+        """
+        Method to list scoped tools for a specific identifier
+
+        :param identifier       : Identifier to scope the tools list
+        :type                   : ``` str ```
+        :param filter           : Filter parameters for scoped tools
+        :type                   : ``` ScopedToolFilter ```
+        :param page_size        : Maximum number of tools to return per page
+        :type                   : ``` int ```
+        :param page_token       : Token from a previous response for pagination
+        :type                   : ``` str ```
+
+        :returns:
+            List Scoped Tools Response
+        """
+        return self.core_client.grpc_exec(
+            self.tool_service.ListScopedTools.with_call,
+            ListScopedToolsRequest(
+                identifier=identifier,
+                filter=filter,
+                page_size=page_size,
+                page_token=page_token
+            ),
+        )
+
     def execute_tool(
         self,
         tool_name: str,