kinde-python-sdk 2.0.0b10__tar.gz → 2.0.0b11__tar.gz

{kinde_python_sdk-2.0.0b10/kinde_python_sdk.egg-info → kinde_python_sdk-2.0.0b11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinde-python-sdk
-Version: 2.0.0b10
+Version: 2.0.0b11
 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
@@ -705,6 +705,27 @@ def main():
 if __name__ == "__main__":
     main()
 ```
+# Version Tracking And Framework detection
+
+The implementation generates headers in the exact format specified:
+
+No Framework: Python/2.0.0
+
+With Framework: Python-Flask/2.0.0/3.11.0/python
+
+
+## Framework Detection
+
+Auto-detects these frameworks:
+
+Django, Flask, FastAPI (more frameworks can be added)
+
+## Version Detection
+
+SDK Version: Automatically detected from package metadata
+Python Version: Detected from  ```sys.version_info```          
+Fallback: Uses "2.0.0-dev" during development
+
 
 ## Publishing
 

{kinde_python_sdk-2.0.0b10 → kinde_python_sdk-2.0.0b11}/README.md

@@ -664,6 +664,27 @@ def main():
 if __name__ == "__main__":
     main()
 ```
+# Version Tracking And Framework detection
+
+The implementation generates headers in the exact format specified:
+
+No Framework: Python/2.0.0
+
+With Framework: Python-Flask/2.0.0/3.11.0/python
+
+
+## Framework Detection
+
+Auto-detects these frameworks:
+
+Django, Flask, FastAPI (more frameworks can be added)
+
+## Version Detection
+
+SDK Version: Automatically detected from package metadata
+Python Version: Detected from  ```sys.version_info```          
+Fallback: Uses "2.0.0-dev" during development
+
 
 ## Publishing
 

{kinde_python_sdk-2.0.0b10 → kinde_python_sdk-2.0.0b11/kinde_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinde-python-sdk
-Version: 2.0.0b10
+Version: 2.0.0b11
 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
@@ -705,6 +705,27 @@ def main():
 if __name__ == "__main__":
     main()
 ```
+# Version Tracking And Framework detection
+
+The implementation generates headers in the exact format specified:
+
+No Framework: Python/2.0.0
+
+With Framework: Python-Flask/2.0.0/3.11.0/python
+
+
+## Framework Detection
+
+Auto-detects these frameworks:
+
+Django, Flask, FastAPI (more frameworks can be added)
+
+## Version Detection
+
+SDK Version: Automatically detected from package metadata
+Python Version: Detected from  ```sys.version_info```          
+Fallback: Uses "2.0.0-dev" during development
+
 
 ## Publishing
 

kinde_python_sdk-2.0.0b11/kinde_sdk/management/management_token_manager.py

@@ -0,0 +1,303 @@
+"""
+Token manager for the Kinde Management API.
+
+This module provides token management for the Kinde Management API using client credentials flow.
+"""
+
+import time
+import requests
+import threading
+from typing import Any, Dict, Optional
+import importlib.metadata
+import sys
+
+class SDKTracker:
+    """Handles SDK tracking header generation for Kinde Python SDK."""
+    
+    # SDK Package name for version detection
+    SDK_PACKAGE_NAME = "kinde-python-sdk"
+    
+    # Framework detection mapping
+    FRAMEWORK_DETECTION = {
+        'django': 'Django',
+        'flask': 'Flask', 
+        'fastapi': 'FastAPI',
+        'starlette': 'Starlette',
+        'tornado': 'Tornado',
+        'pyramid': 'Pyramid',
+        'bottle': 'Bottle',
+        'cherrypy': 'CherryPy',
+        'falcon': 'Falcon',
+        'sanic': 'Sanic',
+        'quart': 'Quart',
+        'aiohttp': 'aiohttp'
+    }
+    
+    @classmethod
+    def get_sdk_version(cls) -> str:
+        """Get the installed SDK version."""
+        try:
+            return importlib.metadata.version(cls.SDK_PACKAGE_NAME)
+        except importlib.metadata.PackageNotFoundError:
+            # Fallback for development/testing
+            return "2.0.0-dev"
+    
+    @classmethod
+    def get_python_version(cls) -> str:
+        """Get the Python version in format: major.minor.micro"""
+        version_info = sys.version_info
+        return f"{version_info.major}.{version_info.minor}.{version_info.micro}"
+    
+    @classmethod
+    def detect_framework(cls) -> Optional[str]:
+        """
+        Detect the web framework being used.
+        
+        Returns:
+            str: Framework name if detected, None otherwise
+        """
+        for module_name, framework_name in cls.FRAMEWORK_DETECTION.items():
+            try:
+                importlib.import_module(module_name)
+                return framework_name
+            except ImportError:
+                continue
+        return None
+    
+    @classmethod
+    def generate_tracking_header(cls, framework: Optional[str] = None) -> str:
+        """
+        Generate the Kinde-SDK tracking header value.
+        
+        Args:
+            framework: Optional framework name to override auto-detection
+            
+        Returns:
+            str: Header value in format: Python-[framework]/[SDK_VERSION]/[PYTHON_VERSION]/python
+                 or Python/[SDK_VERSION] if no framework detected
+        """
+        sdk_version = cls.get_sdk_version()
+        python_version = cls.get_python_version()
+        
+        # Use provided framework or auto-detect
+        detected_framework = framework or cls.detect_framework()
+        
+        if detected_framework:
+            # Format: Python-[framework]/[SDK_VERSION]/[PYTHON_VERSION]/python
+            return f"Python-{detected_framework}/{sdk_version}/{python_version}/python"
+        else:
+            # Format: Python/[SDK_VERSION] (when no framework detected)
+            return f"Python/{sdk_version}"
+    
+    @classmethod
+    def get_tracking_headers(cls, framework: Optional[str] = None) -> Dict[str, str]:
+        """
+        Get the complete headers dict including tracking header.
+        
+        Args:
+            framework: Optional framework name to override auto-detection
+            
+        Returns:
+            dict: Headers dictionary with Kinde-SDK header
+        """
+        return {
+            "Kinde-SDK": cls.generate_tracking_header(framework)
+        }
+
+
+class ManagementTokenManager:
+    """
+    Token manager for the Kinde Management API.
+    Uses client credentials grant type to obtain access tokens.
+    """
+    _instances = {}
+    _lock = threading.RLock()  # Add a lock for thread safety
+
+    # SDK tracking configuration
+    SDK_PACKAGE_NAME = "kinde-python-sdk"
+    FRAMEWORK_DETECTION = {
+        'django': 'Django',
+        'flask': 'Flask', 
+        'fastapi': 'FastAPI'
+    }
+
+    @classmethod
+    def reset_instances(cls):
+        """Reset all management token manager instances - useful for testing"""
+        with cls._lock:
+            cls._instances = {}
+
+    def __new__(cls, domain, *args, **kwargs):
+        """
+        Ensure only one instance per domain and client_id combination.
+        FIXED: Restore original signature to match the original design
+        """
+        with cls._lock:
+            # Extract client_id from args or kwargs
+            client_id = args[0] if args else kwargs.get('client_id', '')
+            instance_key = f"{domain}-{client_id}"
+            if instance_key not in cls._instances:
+                cls._instances[instance_key] = super(ManagementTokenManager, cls).__new__(cls)
+            return cls._instances[instance_key]
+
+    def __init__(self, domain, client_id, client_secret):
+        # Skip initialization if already initialized
+        if hasattr(self, "initialized") and self.initialized:
+            return
+            
+        self.domain = domain
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.token_url = f"https://{domain}/oauth2/token"
+        self.tokens = {}  # Store tokens
+        self.lock = threading.RLock()  # Add a lock for thread safety
+        self.initialized = True
+
+    def _get_sdk_version(self) -> str:
+        """Get the installed SDK version."""
+        try:
+            return importlib.metadata.version(self.SDK_PACKAGE_NAME)
+        except importlib.metadata.PackageNotFoundError:
+            # Fallback for development/testing
+            return "2.0.0-dev"
+
+    def _get_python_version(self) -> str:
+        """Get the Python version in format: major.minor.micro"""
+        version_info = sys.version_info
+        return f"{version_info.major}.{version_info.minor}.{version_info.micro}"
+
+    def _detect_framework(self) -> Optional[str]:
+        """
+        Detect the web framework being used.
+        
+        Returns:
+            str: Framework name if detected, None otherwise
+        """
+        for module_name, framework_name in self.FRAMEWORK_DETECTION.items():
+            try:
+                importlib.import_module(module_name)
+                return framework_name
+            except ImportError:
+                continue
+        return None
+
+    def _generate_tracking_header(self, framework: Optional[str] = None) -> str:
+        """
+        Generate the Kinde-SDK tracking header value.
+        
+        Args:
+            framework: Optional framework name to override auto-detection
+            
+        Returns:
+            str: Header value in format as per specification
+        """
+        sdk_version = self._get_sdk_version()
+        python_version = self._get_python_version()
+        
+        # Use provided framework or auto-detect
+        detected_framework = framework or self._detect_framework()
+        
+        if detected_framework:
+            # Format: Python-[framework]/[SDK_VERSION]/[PYTHON_VERSION]/python
+            return f"Python-{detected_framework}/{sdk_version}/{python_version}/python"
+        else:
+            # Format: Python/[SDK_VERSION] (when no framework detected)
+            return f"Python/{sdk_version}"
+
+    def set_tokens(self, token_data: Dict[str, Any]):
+        """ Store tokens with expiration. """
+        with self.lock:
+            # Handle None values by using default
+            expires_in = token_data.get("expires_in") or 3600
+            token_type = token_data.get("token_type") or "Bearer"
+            self.tokens = {
+            "access_token": token_data.get("access_token"),
+            "expires_at": time.time() + expires_in,
+            "token_type": token_type
+            }
+
+    def get_access_token(self):
+        """ Get a valid access token. Request new if expired. """
+        with self.lock:
+            # Check if token exists and is not expired
+            if self.tokens and "access_token" in self.tokens and time.time() < self.tokens.get("expires_at", 0) - 60:
+                return self.tokens["access_token"]
+                
+            # Need to get a new token
+            return self.request_new_token()
+
+    # def request_new_token(self):
+    #     """Use client credentials to get a new access token."""
+    #     data = {
+    #         "grant_type": "client_credentials",
+    #         "client_id": self.client_id,
+    #         "client_secret": self.client_secret,
+    #         "audience": f"https://{self.domain}/api"
+    #     }
+            
+    #     headers = {
+    #         "Content-Type": "application/x-www-form-urlencoded"
+    #     }
+        
+    #     # CHANGE 3: Add timeout to prevent hanging on network issues
+    #     try:
+    #         response = requests.post(
+    #             self.token_url, 
+    #             data=data, 
+    #             headers=headers,
+    #             timeout=30  # 30-second timeout
+    #         )
+    #         response.raise_for_status()
+    #         token_data = response.json()
+            
+    #         # This call now works because we use RLock
+    #         self.set_tokens(token_data)
+    #         return self.tokens["access_token"]
+            
+    #     except requests.exceptions.Timeout:
+    #         raise Exception(f"Token request timed out after 30 seconds for domain {self.domain}")
+    #     except requests.exceptions.RequestException as e:
+    #         raise Exception(f"Token request failed for domain {self.domain}: {str(e)}")
+
+    def request_new_token(self):
+        """Use client credentials to get a new access token with tracking headers."""
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "audience": f"https://{self.domain}/api"
+        }
+            
+        # Base headers
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded"
+        }
+        
+        # Add SDK tracking header as per specification
+        # This is required for analytics and support purposes
+        headers["Kinde-SDK"] = self._generate_tracking_header()
+        
+        # Add timeout to prevent hanging on network issues
+        try:
+            response = requests.post(
+                self.token_url, 
+                data=data, 
+                headers=headers,  # Now includes tracking headers
+                timeout=30  # 30-second timeout
+            )
+            response.raise_for_status()
+            token_data = response.json()
+            
+            # This call now works because we use RLock
+            self.set_tokens(token_data)
+            return self.tokens["access_token"]
+            
+        except requests.exceptions.Timeout:
+            raise Exception(f"Token request timed out after 30 seconds for domain {self.domain}")
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Token request failed for domain {self.domain}: {str(e)}")
+
+    def clear_tokens(self):
+        """ Clear stored tokens. """
+        with self.lock:
+            self.tokens = {}

{kinde_python_sdk-2.0.0b10 → kinde_python_sdk-2.0.0b11}/pyproject.toml

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

kinde_python_sdk-2.0.0b10/kinde_sdk/management/management_token_manager.py

@@ -1,110 +0,0 @@
-"""
-Token manager for the Kinde Management API.
-
-This module provides token management for the Kinde Management API using client credentials flow.
-"""
-
-import time
-import requests
-import threading
-from typing import Any, Dict, Optional
-
-class ManagementTokenManager:
-    """
-    Token manager for the Kinde Management API.
-    Uses client credentials grant type to obtain access tokens.
-    """
-    _instances = {}
-    _lock = threading.RLock()  # Add a lock for thread safety
-
-    @classmethod
-    def reset_instances(cls):
-        """Reset all management token manager instances - useful for testing"""
-        with cls._lock:
-            cls._instances = {}
-
-    def __new__(cls, domain, *args, **kwargs):
-        """
-        Ensure only one instance per domain and client_id combination.
-        FIXED: Restore original signature to match the original design
-        """
-        with cls._lock:
-            # Extract client_id from args or kwargs
-            client_id = args[0] if args else kwargs.get('client_id', '')
-            instance_key = f"{domain}-{client_id}"
-            if instance_key not in cls._instances:
-                cls._instances[instance_key] = super(ManagementTokenManager, cls).__new__(cls)
-            return cls._instances[instance_key]
-
-    def __init__(self, domain, client_id, client_secret):
-        # Skip initialization if already initialized
-        if hasattr(self, "initialized") and self.initialized:
-            return
-            
-        self.domain = domain
-        self.client_id = client_id
-        self.client_secret = client_secret
-        self.token_url = f"https://{domain}/oauth2/token"
-        self.tokens = {}  # Store tokens
-        self.lock = threading.RLock()  # Add a lock for thread safety
-        self.initialized = True
-
-    def set_tokens(self, token_data: Dict[str, Any]):
-        """ Store tokens with expiration. """
-        with self.lock:
-            # Handle None values by using default
-            expires_in = token_data.get("expires_in") or 3600
-            token_type = token_data.get("token_type") or "Bearer"
-            self.tokens = {
-            "access_token": token_data.get("access_token"),
-            "expires_at": time.time() + expires_in,
-            "token_type": token_type
-            }
-
-    def get_access_token(self):
-        """ Get a valid access token. Request new if expired. """
-        with self.lock:
-            # Check if token exists and is not expired
-            if self.tokens and "access_token" in self.tokens and time.time() < self.tokens.get("expires_at", 0) - 60:
-                return self.tokens["access_token"]
-                
-            # Need to get a new token
-            return self.request_new_token()
-
-    def request_new_token(self):
-        """Use client credentials to get a new access token."""
-        data = {
-            "grant_type": "client_credentials",
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-            "audience": f"https://{self.domain}/api"
-        }
-            
-        headers = {
-            "Content-Type": "application/x-www-form-urlencoded"
-        }
-        
-        # CHANGE 3: Add timeout to prevent hanging on network issues
-        try:
-            response = requests.post(
-                self.token_url, 
-                data=data, 
-                headers=headers,
-                timeout=30  # 30-second timeout
-            )
-            response.raise_for_status()
-            token_data = response.json()
-            
-            # This call now works because we use RLock
-            self.set_tokens(token_data)
-            return self.tokens["access_token"]
-            
-        except requests.exceptions.Timeout:
-            raise Exception(f"Token request timed out after 30 seconds for domain {self.domain}")
-        except requests.exceptions.RequestException as e:
-            raise Exception(f"Token request failed for domain {self.domain}: {str(e)}")
-
-    def clear_tokens(self):
-        """ Clear stored tokens. """
-        with self.lock:
-            self.tokens = {}