kinde-python-sdk 2.1.0__tar.gz → 2.2.0__tar.gz

{kinde_python_sdk-2.1.0/kinde_python_sdk.egg-info → kinde_python_sdk-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinde-python-sdk
-Version: 2.1.0
+Version: 2.2.0
 Summary: Connect your app to the Kinde platform
 Author-email: Kinde Engineering <engineering@kinde.com>
 Project-URL: Homepage, https://github.com/kinde-oss/kinde-python-sdk

{kinde_python_sdk-2.1.0 → kinde_python_sdk-2.2.0/kinde_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinde-python-sdk
-Version: 2.1.0
+Version: 2.2.0
 Summary: Connect your app to the Kinde platform
 Author-email: Kinde Engineering <engineering@kinde.com>
 Project-URL: Homepage, https://github.com/kinde-oss/kinde-python-sdk

{kinde_python_sdk-2.1.0 → kinde_python_sdk-2.2.0}/kinde_python_sdk.egg-info/SOURCES.txt

@@ -42,6 +42,7 @@ pyproject.toml
 ./kinde_sdk/core/__init__.py
 ./kinde_sdk/core/exceptions.py
 ./kinde_sdk/core/helpers.py
+./kinde_sdk/core/session_management.py
 ./kinde_sdk/core/framework/__init__.py
 ./kinde_sdk/core/framework/framework_context.py
 ./kinde_sdk/core/framework/framework_factory.py
@@ -501,6 +502,7 @@ kinde_sdk/auth/user_session.py
 kinde_sdk/core/__init__.py
 kinde_sdk/core/exceptions.py
 kinde_sdk/core/helpers.py
+kinde_sdk/core/session_management.py
 kinde_sdk/core/framework/__init__.py
 kinde_sdk/core/framework/framework_context.py
 kinde_sdk/core/framework/framework_factory.py

{kinde_python_sdk-2.1.0 → kinde_python_sdk-2.2.0}/kinde_sdk/__init__.py

@@ -23,8 +23,9 @@ from kinde_sdk.core.storage.storage_factory import StorageFactory
 from kinde_sdk.core.framework.framework_factory import FrameworkFactory
 from kinde_sdk.core.framework.framework_interface import FrameworkInterface
 from kinde_sdk.core.framework.null_framework import NullFramework
+from kinde_sdk.core.session_management import KindeSessionManagement
 
-__version__ = "2.1.0"
+__version__ = "2.2.0"
 
 __all__ = [
     "OAuth",
@@ -42,4 +43,5 @@ __all__ = [
     "FrameworkFactory",
     "FrameworkInterface",
     "NullFramework",
+    "KindeSessionManagement",
 ]

{kinde_python_sdk-2.1.0 → kinde_python_sdk-2.2.0}/kinde_sdk/auth/__init__.py

@@ -4,9 +4,10 @@ from .user_session import UserSession
 from .api_options import ApiOptions
 from .permissions import permissions
 from .claims import claims
+from .async_claims import async_claims
 from .feature_flags import feature_flags
 from .portals import portals
 from .tokens import tokens
 from .roles import roles
 
-__all__ = ["OAuth", "TokenManager", "UserSession", "permissions", "ApiOptions", "claims", "feature_flags", "portals", "tokens", "roles"]
+__all__ = ["OAuth", "TokenManager", "UserSession", "permissions", "ApiOptions", "claims", "async_claims", "feature_flags", "portals", "tokens", "roles"]

{kinde_python_sdk-2.1.0 → kinde_python_sdk-2.2.0}/kinde_sdk/auth/oauth.py

@@ -80,9 +80,8 @@ class OAuth:
         if framework:
             self._initialize_framework()
         else:
-            # Use configuration-based storage if no framework specified
-            self._storage = StorageFactory.create_storage(storage_config)
-            self._storage_manager.initialize(config=storage_config, storage=self._storage)
+            # Use null framework for standalone usage
+            self._initialize_null_framework(storage_config)
 
         self._session_manager = UserSession()
 
@@ -124,6 +123,33 @@ class OAuth:
         # Initialize storage manager with the framework-specific storage
         self._storage_manager.initialize(config={"type": self.framework, "device_id": self._framework.get_name()}, storage=self._storage)
 
+    def _initialize_null_framework(self, storage_config: Dict[str, Any]) -> None:
+        """
+        Initialize the null framework for standalone usage.
+        This sets up the null framework and its associated storage.
+        """
+        from kinde_sdk.core.framework.null_framework import NullFramework
+        
+        # Create null framework instance (singleton)
+        self._framework = NullFramework()
+        
+        # Set the OAuth instance in the framework
+        self._framework.set_oauth(self)
+        
+        # Start the framework (no-op for null framework)
+        self._framework.start()
+        
+        # Create storage using provided config (defaulting to memory)
+        storage_type = (storage_config or {}).get("type", "memory") if isinstance(storage_config, dict) else "memory"
+        self._storage = StorageFactory.create_storage({**({"type": storage_type}), **(storage_config or {})})
+
+        # Initialize storage manager with explicit device_id
+        self._storage_manager.initialize(
+            config={"type": storage_type},
+            device_id=self._framework.get_name(),
+            storage=self._storage,
+        )
+
     def is_authenticated(self) -> bool:
         """
         Check if the user is authenticated using the session manager.
@@ -365,9 +391,6 @@ class OAuth:
         Returns:
             Login URL
         """
-        if not self.framework:
-            raise KindeConfigurationException("Framework must be selected")
-        
         if login_options is None:
             login_options = {}
 
@@ -407,9 +430,6 @@ class OAuth:
         Returns:
             Registration URL
         """
-        if not self.framework:
-            raise KindeConfigurationException("Framework must be selected")
-
         if login_options is None:
             login_options = {}
 
@@ -440,9 +460,6 @@ class OAuth:
         Returns:
             Logout URL
         """
-        if not self.framework:
-            raise KindeConfigurationException("Framework must be selected")
-
         if logout_options is None:
             logout_options = {}
         

{kinde_python_sdk-2.1.0 → kinde_python_sdk-2.2.0}/kinde_sdk/core/__init__.py

@@ -1,6 +1,7 @@
 # Import helpers for easier access from outside the package
 from .storage import StorageInterface, StorageFactory, StorageManager
 from .framework import FrameworkInterface, FrameworkFactory, NullFramework
+from .session_management import KindeSessionManagement
 
 __all__ = [
     'StorageInterface',
@@ -9,4 +10,5 @@ __all__ = [
     'FrameworkInterface',
     'FrameworkFactory',
     'NullFramework',
+    'KindeSessionManagement',
 ]

kinde_python_sdk-2.2.0/kinde_sdk/core/framework/null_framework.py

@@ -0,0 +1,128 @@
+from typing import Optional, Any, TYPE_CHECKING
+import threading
+import contextvars
+
+if TYPE_CHECKING:
+    from kinde_sdk.auth.oauth import OAuth
+
+from .framework_interface import FrameworkInterface
+
+class NullFramework(FrameworkInterface):
+    """
+    A null implementation of the FrameworkInterface.
+    This implementation provides session management for standalone usage without a web framework.
+    Uses a singleton pattern to allow external applications to set the current user session.
+    """
+    
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        """Implement singleton pattern."""
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(NullFramework, cls).__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        """Initialize the null framework."""
+        if not hasattr(self, '_initialized'):
+            self._oauth = None
+            # Use context variables for user_id to avoid race conditions in both threads and async
+            self._current_user_id_context = contextvars.ContextVar('current_user_id', default=None)
+            self._initialized = True
+    
+    def get_name(self) -> str:
+        """
+        Get the name of the framework.
+        
+        Returns:
+            str: The name of the null framework
+        """
+        return "null"
+    
+    def get_description(self) -> str:
+        """
+        Get a description of the framework.
+        
+        Returns:
+            str: A description of the null framework
+        """
+        return "A null framework implementation that provides session management for standalone usage without a web framework."
+    
+    def start(self) -> None:
+        """
+        Start the framework.
+        This is a no-op in the null implementation.
+        """
+        pass
+    
+    def stop(self) -> None:
+        """
+        Stop the framework.
+        This is a no-op in the null implementation.
+        """
+        pass
+        
+    def get_app(self) -> Any:
+        """
+        Get the framework application instance.
+        
+        Returns:
+            Any: None in the null implementation
+        """
+        return None
+        
+    def get_request(self) -> Optional[Any]:
+        """
+        Get the current request object.
+        
+        Returns:
+            Optional[Any]: None in the null implementation
+        """
+        return None
+        
+    def get_user_id(self) -> Optional[str]:
+        """
+        Get the current user ID from the session.
+        
+        Returns:
+            Optional[str]: The current user ID, or None if not set
+        """
+        return self._current_user_id_context.get()
+    
+    def set_user_id(self, user_id: str) -> None:
+        """
+        Set the current user ID for the session.
+        This method allows external applications (like simple HTTP servers) 
+        to set the current user session.
+        
+        Args:
+            user_id (str): The user ID to set as current
+        """
+        self._current_user_id_context.set(user_id)
+    
+    def clear_user_id(self) -> None:
+        """
+        Clear the current user ID from the session.
+        """
+        self._current_user_id_context.set(None)
+    
+    def set_oauth(self, oauth: 'OAuth') -> None:
+        """
+        Set the OAuth instance for this framework.
+        
+        Args:
+            oauth (OAuth): The OAuth instance
+        """
+        self._oauth = oauth
+    
+    def can_auto_detect(self) -> bool:
+        """
+        Check if this framework can be auto-detected.
+        
+        Returns:
+            bool: False - null framework is not auto-detected
+        """
+        return False 

kinde_python_sdk-2.2.0/kinde_sdk/core/session_management.py

@@ -0,0 +1,177 @@
+"""
+Kinde Session Management
+
+This module provides a user-friendly interface for session management when using
+the Kinde SDK in standalone mode (without a web framework). It wraps access to
+the NullFramework behind a more intuitive API.
+"""
+
+from typing import Optional, TYPE_CHECKING
+import logging
+
+if TYPE_CHECKING:
+    from kinde_sdk.core.framework.null_framework import NullFramework
+
+logger = logging.getLogger(__name__)
+
+
+class KindeSessionManagement:
+    """
+    A user-friendly interface for session management in standalone Kinde SDK usage.
+    
+    This class provides a clean API for managing user sessions when using the Kinde SDK
+    without a web framework. It wraps the NullFramework functionality behind a more
+    intuitive interface.
+    
+    Note: This class can only be used when the SDK is running in standalone mode
+    (without a web framework). If a framework like FastAPI or Flask is being used,
+    this class will raise an exception to prevent misuse.
+    """
+    
+    def __init__(self):
+        """
+        Initialize the Kinde session management.
+        
+        Raises:
+            RuntimeError: If the SDK is not running in standalone mode (NullFramework not active)
+        """
+        self._logger = logging.getLogger(__name__)
+        self._null_framework = self._get_null_framework()
+        
+        if not self._null_framework:
+            raise RuntimeError(
+                "KindeSessionManagement can only be used in standalone mode. "
+                "When using a web framework (FastAPI, Flask, etc.), session management "
+                "is handled automatically by the framework. Please use the framework's "
+                "built-in session management instead."
+            )
+    
+    def _get_null_framework(self) -> Optional['NullFramework']:
+        """
+        Get the current NullFramework instance if it's active.
+        
+        Returns:
+            Optional[NullFramework]: The NullFramework instance if active, None otherwise
+        """
+        try:
+            from kinde_sdk.core.framework.null_framework import NullFramework
+            from kinde_sdk.core.framework.framework_factory import FrameworkFactory
+            
+            # First, try to get the framework instance from FrameworkFactory
+            current_framework = FrameworkFactory.get_framework_instance()
+            
+            # Check if it's a NullFramework instance
+            if current_framework and isinstance(current_framework, NullFramework):
+                return current_framework
+            
+            # If not found in FrameworkFactory, try to get it from the NullFramework singleton
+            # This handles the case where OAuth creates NullFramework directly
+            try:
+                null_framework = NullFramework()
+                # Check if this is actually being used (has been initialized)
+                if hasattr(null_framework, '_initialized') and null_framework._initialized:
+                    return null_framework
+            except Exception:
+                pass
+            
+            return None
+            
+        except Exception as e:
+            self._logger.debug(f"Could not get NullFramework: {e}")
+            return None
+    
+    def get_user_id(self) -> Optional[str]:
+        """
+        Get the current user ID from the session.
+        
+        Returns:
+            Optional[str]: The current user ID, or None if not set
+        """
+        if not self._null_framework:
+            raise RuntimeError("Session management is not available in this context")
+        
+        return self._null_framework.get_user_id()
+    
+    def set_user_id(self, user_id: str) -> None:
+        """
+        Set the current user ID for the session.
+        
+        This method allows you to set the current user session, which is useful
+        for applications that need to manage multiple user sessions or when
+        integrating with custom session management systems.
+        
+        Args:
+            user_id (str): The user ID to set as current
+            
+        Raises:
+            RuntimeError: If session management is not available in this context
+            ValueError: If user_id is empty or None
+        """
+        if not self._null_framework:
+            raise RuntimeError("Session management is not available in this context")
+        
+        if not user_id or not user_id.strip():
+            raise ValueError("user_id cannot be empty or None")
+        
+        self._null_framework.set_user_id(user_id)
+        self._logger.debug(f"Set user ID: {user_id}")
+    
+    def clear_user_id(self) -> None:
+        """
+        Clear the current user ID from the session.
+        
+        This method removes the current user session, effectively logging out
+        the user from the current context.
+        
+        Raises:
+            RuntimeError: If session management is not available in this context
+        """
+        if not self._null_framework:
+            raise RuntimeError("Session management is not available in this context")
+        
+        self._null_framework.clear_user_id()
+        self._logger.debug("Cleared user ID from session")
+    
+    def is_user_logged_in(self) -> bool:
+        """
+        Check if a user is currently logged in.
+        
+        Returns:
+            bool: True if a user is logged in, False otherwise
+        """
+        if not self._null_framework:
+            raise RuntimeError("Session management is not available in this context")
+        
+        user_id = self._null_framework.get_user_id()
+        return user_id is not None and user_id.strip() != ""
+    
+    def get_session_info(self) -> dict:
+        """
+        Get information about the current session.
+        
+        Returns:
+            dict: A dictionary containing session information
+            
+        Raises:
+            RuntimeError: If session management is not available in this context
+        """
+        if not self._null_framework:
+            raise RuntimeError("Session management is not available in this context")
+        
+        user_id = self._null_framework.get_user_id()
+        
+        return {
+            "user_id": user_id,
+            "is_logged_in": user_id is not None and user_id.strip() != "",
+            "framework": "standalone",
+            "session_type": "null_framework"
+        }
+    
+    def __repr__(self) -> str:
+        """Return a string representation of the session management object."""
+        if not self._null_framework:
+            return "KindeSessionManagement(unavailable - not in standalone mode)"
+        
+        user_id = self._null_framework.get_user_id()
+        status = "logged_in" if user_id else "not_logged_in"
+        return f"KindeSessionManagement(user_id={user_id}, status={status})"

{kinde_python_sdk-2.1.0 → kinde_python_sdk-2.2.0}/kinde_sdk/management/management_client.py

@@ -28,10 +28,10 @@ class ManagementClient:
         # Users API
         'users': {
             'list': ('GET', '/api/v1/users'),
-            'get': ('GET', '/api/v1/users/{user_id}'),
+            'get': ('GET', '/api/v1/user'),
             'create': ('POST', '/api/v1/user'),
-            'update': ('PATCH', '/api/v1/users/{user_id}'),
-            'delete': ('DELETE', '/api/v1/users/{user_id}'),
+            'update': ('PATCH', '/api/v1/user', ['id']),
+            'delete': ('DELETE', '/api/v1/user'),
         },
         
         # Organizations API
@@ -393,7 +393,13 @@ class ManagementClient:
             else:
                 resource_singular = resource[:-1] if resource.endswith('s') else resource
             
-            for action, (method, path) in endpoints.items():
+            for action, endpoint in endpoints.items():
+                if len(endpoint) == 3:
+                    method, path, query_keys = endpoint
+                else:
+                    method, path = endpoint
+                    query_keys = ()
+
                 # Create method name based on action and resource
                 if action == 'list':
                     method_name = f"get_{resource}"
@@ -403,12 +409,12 @@ class ManagementClient:
                     method_name = f"{action}_{resource_singular}"
                 
                 # Create the method
-                api_method = self._create_api_method(method, path, resource, action)
+                api_method = self._create_api_method(method, path, resource, action, query_keys)
                 
                 # Set the method on the class
                 setattr(self, method_name, api_method)
     
-    def _create_api_method(self, http_method: str, path: str, resource: str, action: str) -> Callable:
+    def _create_api_method(self, http_method: str, path: str, resource: str, action: str, query_keys=()) -> Callable:
         """
         Create a dynamic method for an API endpoint.
         
@@ -438,15 +444,17 @@ class ManagementClient:
                     if start_idx >= 0 and end_idx >= 0:
                         formatted_path = formatted_path[:start_idx] + str(param_values.pop(0)) + formatted_path[end_idx + 1:]
             
-            # Handle query params or body data based on HTTP method
-            query_params = None
-            body = None
-            
+            # Handle query/body split
             if http_method in ('GET', 'DELETE'):
                 query_params = {k: v for k, v in kwargs.items() if v is not None}
+                payload = None
             else:
-                body = {k: v for k, v in kwargs.items() if v is not None}
-            
+                # Lift ONLY declared query_keys into the query string
+                qset = set(query_keys or ())
+                query_params = {k: kwargs.pop(k) for k in list(kwargs) if k in qset and kwargs[k] is not None}
+                # Remaining kwargs go to JSON body
+                payload = {k: v for k, v in kwargs.items() if v is not None}
+
             # FIXED: Use param_serialize to properly construct the full URL with host
             # Handle query parameters by appending them to the path
             final_path = formatted_path
@@ -460,28 +468,33 @@ class ManagementClient:
             # Remove /api/v1 prefix from resource_path since host already includes it
             resource_path_for_serialize = formatted_path.replace('/api/v1', '', 1)
             
-            method, url, header_params, body, post_params = self.api_client.param_serialize(
+            method, url, header_params, serialized_body, post_params = self.api_client.param_serialize(
                 method=http_method,
                 resource_path=resource_path_for_serialize,  # Use path without /api/v1 prefix
-                query_params=query_params if http_method in ('GET', 'DELETE') else None,
+                query_params=query_params or None,
                 header_params={},
-                body=body if http_method not in ('GET', 'DELETE') else None
+                body=payload if http_method not in ('GET', 'DELETE') else None
             )
-            
+
+            # Ensure required headers for PATCH/POST/PUT
+            if http_method not in ('GET', 'DELETE'):
+                header_params.setdefault('Content-Type', 'application/json')
+                header_params.setdefault('Accept', 'application/json')
+
             # Add the authorization token to headers
             token = self.token_manager.get_access_token()
             header_params['Authorization'] = f"Bearer {token}"
-            
+
             # Call the REST client directly with the constructed URL
             response = self.api_client.rest_client.request(
                 method=http_method,
                 url=url,
                 headers=header_params,
-                body=body if http_method not in ('GET', 'DELETE') else None,
+                body=serialized_body if http_method not in ('GET', 'DELETE') else None,
                 post_params=post_params,
                 _request_timeout=None
             )
-            
+
             # Use the API client's response_deserialize to properly handle the response
             # First read the response data
             response.read()

{kinde_python_sdk-2.1.0 → kinde_python_sdk-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kinde-python-sdk"
-version = "2.1.0"
+version = "2.2.0"
 authors = [
     { name = "Kinde Engineering", email = "engineering@kinde.com" },
 ]

kinde_python_sdk-2.1.0/kinde_sdk/core/framework/null_framework.py

@@ -1,75 +0,0 @@
-from typing import Optional, Any, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from kinde_sdk.auth.oauth import OAuth
-
-from .framework_interface import FrameworkInterface
-
-class NullFramework(FrameworkInterface):
-    """
-    A null implementation of the FrameworkInterface.
-    This implementation does nothing and is used when no framework is detected or specified.
-    """
-    
-    def __init__(self):
-        """Initialize the null framework."""
-        self._oauth = None
-    
-    def get_name(self) -> str:
-        """
-        Get the name of the framework.
-        
-        Returns:
-            str: The name of the null framework
-        """
-        return "null"
-    
-    def get_description(self) -> str:
-        """
-        Get a description of the framework.
-        
-        Returns:
-            str: A description of the null framework
-        """
-        return "A null framework implementation that does nothing. Used when no framework is detected or specified."
-    
-    def start(self) -> None:
-        """
-        Start the framework.
-        This is a no-op in the null implementation.
-        """
-        pass
-    
-    def stop(self) -> None:
-        """
-        Stop the framework.
-        This is a no-op in the null implementation.
-        """
-        pass
-        
-    def get_app(self) -> Any:
-        """
-        Get the framework application instance.
-        
-        Returns:
-            Any: None in the null implementation
-        """
-        return None
-        
-    def get_request(self) -> Optional[Any]:
-        """
-        Get the current request object.
-        
-        Returns:
-            Optional[Any]: None in the null implementation
-        """
-        return None
-        
-    def set_oauth(self, oauth: 'OAuth') -> None:
-        """
-        Set the OAuth instance for this framework.
-        
-        Args:
-            oauth (OAuth): The OAuth instance
-        """
-        self._oauth = oauth