PyPI - kinde-python-sdk - Versions diffs - 2.0.0b3__tar.gz → 2.0.0b5__tar.gz - Mend

kinde-python-sdk 2.0.0b3tar.gz → 2.0.0b5tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (460) hide show

kinde_python_sdk-2.0.0b5/MANIFEST.in ADDED Viewed

@@ -0,0 +1,14 @@
+include README.md
+include LICENSE
+recursive-include kinde_sdk *.py
+recursive-include kinde_sdk *.json
+recursive-include kinde_sdk *.yaml
+recursive-include kinde_sdk *.yml
+recursive-include kinde_fastapi *.py
+recursive-include kinde_fastapi *.json
+recursive-include kinde_fastapi *.yaml
+recursive-include kinde_fastapi *.yml
+recursive-include kinde_flask *.py
+recursive-include kinde_flask *.json
+recursive-include kinde_flask *.yaml
+recursive-include kinde_flask *.yml

{kinde_python_sdk-2.0.0b3/kinde_python_sdk.egg-info → kinde_python_sdk-2.0.0b5}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinde-python-sdk
-Version: 2.0.0b3
+Version: 2.0.0b5
 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.0.0b5/kinde_fastapi/examples/example_app.py ADDED Viewed

@@ -0,0 +1,61 @@
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
+from starlette.middleware.sessions import SessionMiddleware
+from .session import InMemorySessionMiddleware
+from pathlib import Path
+import os
+from dotenv import load_dotenv
+import logging
+from kinde_sdk.auth.oauth import OAuth
+logger = logging.getLogger(__name__)
+# Load environment variables from .env file
+load_dotenv()
+# Initialize FastAPI app
+app = FastAPI(title="Kinde FastAPI Example")
+# Add session middleware with proper configuration
+app.add_middleware(
+    InMemorySessionMiddleware,
+    max_age=3600,  # 1 hour
+    https_only=False
+)
+# Initialize Kinde OAuth with FastAPI framework
+kinde_oauth = OAuth(
+    framework="fastapi",
+    app=app
+)
+# Example home route
+@app.get("/", response_class=HTMLResponse)
+async def home(request: Request):
+    """
+    Home page that shows different content based on authentication status.
+    """
+    if kinde_oauth.is_authenticated():
+        user = kinde_oauth.get_user_info()
+        return f"""
+        <html>
+            <body>
+                <h1>Welcome, {user.get('email', 'User')}!</h1>
+                <p>You are logged in.</p>
+                <a href="/logout">Logout</a>
+            </body>
+        </html>
+        """
+    return """
+    <html>
+        <body>
+            <h1>Welcome to the Example App</h1>
+            <p>You are not logged in.</p>
+            <a href="/login">Login</a>
+        </body>
+    </html>
+    """
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=5000)

kinde_python_sdk-2.0.0b5/kinde_fastapi/examples/session.py ADDED Viewed

@@ -0,0 +1,74 @@
+from fastapi import Request, Response
+import json
+import secrets
+from datetime import datetime, timedelta
+from typing import Optional, Any, Dict, Callable, Awaitable
+from threading import Lock
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.types import ASGIApp, Receive, Scope, Send
+class InMemorySessionMiddleware(BaseHTTPMiddleware):
+    def __init__(
+        self,
+        app: ASGIApp,
+        session_cookie: str = "session",
+        max_age: int = 14 * 24 * 60 * 60,  # 14 days in seconds
+        same_site: str = "lax",
+        https_only: bool = False
+    ):
+        super().__init__(app)
+        self.session_cookie = session_cookie
+        self.max_age = max_age
+        self.same_site = same_site
+        self.https_only = https_only
+        self._sessions: Dict[str, Dict[str, Any]] = {}
+        self._lock = Lock()  # Thread safety for session operations
+    async def dispatch(self, request: Request, call_next):
+        session_id = request.cookies.get(self.session_cookie)
+        if not session_id:
+            session_id = secrets.token_urlsafe(32)
+            session_data = {}
+        else:
+            session_data = self._get_session(session_id) or {}
+        # Add session to request scope
+        request.scope["session"] = session_data
+        # Process the request
+        response = await call_next(request)
+        # Update session in memory
+        if "session" in request.scope:
+            self._set_session(session_id, request.scope["session"])
+            # Set cookie
+            response.set_cookie(
+                key=self.session_cookie,
+                value=session_id,
+                max_age=self.max_age,
+                httponly=True,
+                samesite=self.same_site,
+                secure=self.https_only
+            )
+        return response
+    def _get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
+        with self._lock:
+            return self._sessions.get(session_id)
+    def _set_session(self, session_id: str, data: Dict[str, Any]) -> None:
+        with self._lock:
+            self._sessions[session_id] = data
+    def delete_session(self, session_id: str) -> None:
+        with self._lock:
+            self._sessions.pop(session_id, None)
+    def cleanup_expired_sessions(self) -> None:
+        """Optional: Method to clean up expired sessions if needed"""
+        with self._lock:
+            # Implementation would depend on how you want to track session expiration
+            pass

kinde_python_sdk-2.0.0b5/kinde_fastapi/framework/__init__.py ADDED Viewed

@@ -0,0 +1,7 @@
+from .fastapi_framework import FastAPIFramework
+from .fastapi_framework_factory import FastAPIFrameworkFactory
+__all__ = [
+    'FastAPIFramework',
+    'FastAPIFrameworkFactory',
+]

kinde_python_sdk-2.0.0b5/kinde_fastapi/framework/fastapi_framework.py ADDED Viewed

@@ -0,0 +1,195 @@
+from typing import Optional, Dict, Any
+from fastapi import FastAPI, Request, Depends
+from fastapi.responses import RedirectResponse, HTMLResponse
+from fastapi import FastAPI, Request, Depends
+from fastapi.responses import RedirectResponse, HTMLResponse
+from kinde_sdk.core.framework.framework_interface import FrameworkInterface
+from kinde_sdk.auth.oauth import OAuth
+from ..middleware.framework_middleware import FrameworkMiddleware
+import os
+import uuid
+import logging
+logger = logging.getLogger(__name__)
+class FastAPIFramework(FrameworkInterface):
+    """
+    FastAPI framework implementation.
+    This class provides FastAPI-specific functionality and integration.
+    """
+    def __init__(self, app: Optional[FastAPI] = None):
+        """
+        Initialize the FastAPI framework.
+        Args:
+            app (Optional[FastAPI]): The FastAPI application instance.
+                If not provided, a new instance will be created.
+        """
+        self.app = app or FastAPI()
+        self._initialized = False
+        self._oauth = None
+        self._logger = logging.getLogger(__name__)
+    def get_name(self) -> str:
+        """
+        Get the name of the framework.
+        Returns:
+            str: The name of the framework
+        """
+        return "fastapi"
+    def get_description(self) -> str:
+        """
+        Get a description of the framework.
+        Returns:
+            str: A description of the framework
+        """
+        return "FastAPI framework implementation for Kinde authentication"
+    def start(self) -> None:
+        """
+        Start the framework.
+        This method initializes any necessary FastAPI components and registers Kinde routes.
+        This method initializes any necessary FastAPI components and registers Kinde routes.
+        """
+        if not self._initialized:
+            # Add framework middleware
+            self.app.add_middleware(FrameworkMiddleware)
+            # Register Kinde routes
+            self._register_kinde_routes()
+            self._initialized = True
+    def stop(self) -> None:
+        """
+        Stop the framework.
+        This method cleans up any FastAPI resources.
+        """
+        if self._initialized:
+            self._initialized = False
+    def get_app(self) -> FastAPI:
+        """
+        Get the FastAPI application instance.
+        Returns:
+            FastAPI: The FastAPI application instance
+        """
+        return self.app
+    def get_request(self) -> Optional[Request]:
+        """
+        Get the current request object.
+        Returns:
+            Optional[Request]: The current FastAPI request object, if available
+        """
+        from kinde_sdk.core.framework.framework_context import FrameworkContext
+        return FrameworkContext.get_request()
+    def get_user_id(self) -> Optional[str]:
+        """
+        Get the user ID from the current request.
+        Returns:
+            Optional[str]: The user ID, or None if not available
+        """
+        request = self.get_request()
+        if not request:
+            return None
+        return request.session.get("user_id")
+    def set_oauth(self, oauth: OAuth) -> None:
+        """
+        Set the OAuth instance for this framework.
+        Args:
+            oauth (OAuth): The OAuth instance
+        """
+        self._oauth = oauth
+    def _register_kinde_routes(self) -> None:
+        """
+        Register all Kinde-specific routes with the FastAPI application.
+        """
+        # Helper function to get current user
+        async def get_current_user(request: Request):
+            if not self._oauth.is_authenticated(request):
+                return None
+            try:
+                return self._oauth.get_user_info(request)
+            except ValueError:
+                return None
+        # Login route
+        @self.app.get("/login")
+        async def login(request: Request):
+            """Redirect to Kinde login page."""
+            url=await self._oauth.login()
+            self._logger.warning(f"[Login] Session is: {request.session}")
+            return RedirectResponse(url=url)
+        # Callback route
+        @self.app.get("/callback")
+        async def callback(request: Request, code: str, state: Optional[str] = None):
+            """Handle the OAuth callback from Kinde."""
+            try:
+                # Generate a unique user ID for the session
+                logger.warning(f"[Callback] Request session is: {request.session}")
+                user_id = request.session.get("user_id") or str(uuid.uuid4())
+                # Use OAuth's handle_redirect method to process the callback
+                logger.warning(f"[Callback] code[{code}] state[{state}] user_id[{user_id}]")
+                result = await self._oauth.handle_redirect(code, user_id, state)
+                # Store user ID in session
+                logger.warning(f"[Callback] Storing user ID in session: {user_id}")
+                request.session["user_id"] = user_id
+                # Create response with explicit session cookie settings
+                self._logger.warning(f"[Callback] Request session is: {request.session}")
+                self._logger.warning(f"[Callback] The full result: {result}")
+                response = RedirectResponse(url="/")
+                return response
+            except Exception as e:
+                logger.error(f"Authentication failed: {str(e)}")
+                return HTMLResponse(f"Authentication failed: {str(e)}")
+        # Logout route
+        @self.app.get("/logout")
+        async def logout(request: Request):
+            """Logout the user and redirect to Kinde logout page."""
+            request.session.clear()
+            return RedirectResponse(url=await self._oauth.logout())
+        # Register route
+        @self.app.get("/register")
+        async def register(request: Request):
+            """Redirect to Kinde registration page."""
+            return RedirectResponse(url=await self._oauth.register())
+        # User info route
+        @self.app.get("/user")
+        async def get_user(request: Request):
+            """Get the current user's information."""
+            if not self._oauth.is_authenticated(request):
+                return RedirectResponse(url=await self._oauth.login())
+            return self._oauth.get_user_info(request)
+    def can_auto_detect(self) -> bool:
+        """
+        Check if this framework can be auto-detected.
+        Returns:
+            bool: True if FastAPI is installed and available
+        """
+        try:
+            import fastapi
+            return True
+        except ImportError:
+            return False

kinde_python_sdk-2.0.0b5/kinde_fastapi/framework/fastapi_framework_factory.py ADDED Viewed

@@ -0,0 +1,24 @@
+from typing import Optional, Dict, Any
+from fastapi import FastAPI
+from kinde_sdk.core.framework.framework_factory import FrameworkFactory
+from .fastapi_framework import FastAPIFramework
+class FastAPIFrameworkFactory:
+    """
+    Factory class for creating FastAPI framework instances.
+    This factory is responsible for creating and registering FastAPI framework instances.
+    """
+    @staticmethod
+    def create_framework(app: Optional[FastAPI] = None) -> FastAPIFramework:
+        """
+        Create a FastAPI framework instance.
+        Args:
+            app (Optional[FastAPI]): The FastAPI application instance.
+                If not provided, a new instance will be created.
+        Returns:
+            FastAPIFramework: A FastAPI framework instance
+        """
+        return FastAPIFramework(app)

kinde_python_sdk-2.0.0b5/kinde_fastapi/middleware/framework_middleware.py ADDED Viewed

@@ -0,0 +1,32 @@
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+from kinde_sdk.core.framework.framework_context import FrameworkContext
+class FrameworkMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware that sets the current request in the framework context.
+    This allows framework-specific storage implementations to access the current request
+    without needing to pass it through the entire call chain.
+    """
+    async def dispatch(self, request: Request, call_next) -> Response:
+        """
+        Process the request and set it in the framework context.
+        Args:
+            request (Request): The incoming request
+            call_next: The next middleware or route handler
+        Returns:
+            Response: The response from the next middleware or route handler
+        """
+        # Set the request in the context
+        FrameworkContext.set_request(request)
+        try:
+            # Process the request
+            response = await call_next(request)
+            return response
+        finally:
+            # Clean up the context
+            FrameworkContext.clear_request()

kinde_python_sdk-2.0.0b5/kinde_fastapi/storage/fastapi_storage.py ADDED Viewed

@@ -0,0 +1,81 @@
+from typing import Dict, Optional
+from kinde_sdk.core.storage.framework_aware_storage import FrameworkAwareStorage
+from kinde_sdk.core.storage.framework_aware_storage import FrameworkAwareStorage
+from fastapi import Request
+from kinde_sdk.core.framework.framework_context import FrameworkContext
+import logging
+logger = logging.getLogger(__name__)
+class FastAPIStorage(FrameworkAwareStorage):
+    """
+    FastAPI storage implementation that uses FastAPI's session management.
+    This implementation stores data in the session using cookies.
+    """
+    def __init__(self):
+        """Initialize the FastAPI storage."""
+        super().__init__()
+    def get(self, key: str) -> Optional[Dict]:
+        """
+        Retrieve data associated with the given key from the session.
+        Args:
+            key (str): The key to retrieve data for.
+        Returns:
+            Optional[Dict]: The stored data or None if not found.
+        """
+        session = self._get_session()
+        if session is None:
+            logger.error("No session object found in request")
+            return None
+        return session.get(key)
+    def set(self, key: str, value: Dict) -> None:
+        """
+        Store data associated with the given key in the session.
+        Args:
+            key (str): The key to store the data under.
+            value (Dict): The data to store.
+        """
+        session = self._get_session()
+        if session is not None:
+            session[key] = value
+            # Mark session as modified for FastAPI/Starlette
+            if hasattr(session, 'modified'):
+                session.modified = True
+    def set_flat(self, value: str) -> None:
+        """
+        Store flat data in the session.
+        Args:
+            value (str): The data to store.
+        """
+        session = self._get_session()
+        if session is not None:
+            session["_flat_data"] = value
+            # Mark session as modified for FastAPI/Starlette
+            if hasattr(session, 'modified'):
+                session.modified = True
+    def delete(self, key: str) -> None:
+        """
+        Delete data associated with the given key from the session.
+        Args:
+            key (str): The key to delete data for.
+        """
+        logger.warning(f"Deleting a session key")
+        session = self._get_session()
+        if session is not None and key in session:
+            del session[key]
+            # Mark session as modified for FastAPI/Starlette
+            if hasattr(session, 'modified'):
+                session.modified = True

kinde_python_sdk-2.0.0b5/kinde_fastapi/storage/fastapi_storage_factory.py ADDED Viewed

@@ -0,0 +1,26 @@
+from typing import Dict, Any
+from kinde_sdk.core.storage.storage_interface import StorageInterface
+from kinde_sdk.core.storage.storage_factory import StorageFactory
+from .fastapi_storage import FastAPIStorage
+class FastAPIStorageFactory:
+    """
+    Factory class for creating FastAPI storage instances.
+    """
+    @staticmethod
+    def create_storage(config: Dict[str, Any] = None) -> StorageInterface:
+        """
+        Create a FastAPI storage instance.
+        Args:
+            config (Dict[str, Any], optional): Configuration dictionary. Not used in this implementation
+                but kept for consistency with other storage factories.
+        Returns:
+            StorageInterface: A FastAPI storage instance.
+        """
+        return FastAPIStorage()
+# Register the FastAPI storage factory
+StorageFactory.register_framework_factory("fastapi", FastAPIStorageFactory)

kinde_python_sdk-2.0.0b5/kinde_flask/examples/example_app.py ADDED Viewed

@@ -0,0 +1,47 @@
+from flask import Flask, render_template_string
+import os
+from dotenv import load_dotenv
+from kinde_sdk.auth.oauth import OAuth
+# Load environment variables from .env file
+load_dotenv()
+# Initialize Flask app
+app = Flask(__name__)
+# Initialize Kinde OAuth with Flask framework
+kinde_oauth = OAuth(
+    framework="flask",
+    app=app
+)
+# Example home route
+@app.route('/')
+def home():
+    """
+    Home page that shows different content based on authentication status.
+    """
+    if kinde_oauth.is_authenticated():
+        user = kinde_oauth.get_user_info()
+        return render_template_string("""
+            <html>
+                <body>
+                    <h1>Welcome, {{ user.email }}!</h1>
+                    <p>You are logged in.</p>
+                    <a href="/logout">Logout</a>
+                </body>
+            </html>
+        """, user=user)
+    return render_template_string("""
+        <html>
+            <body>
+                <h1>Welcome to the Example App</h1>
+                <p>You are not logged in.</p>
+                <a href="/login">Login</a>
+            </body>
+        </html>
+    """)
+if __name__ == '__main__':
+    app.run(debug=True)

kinde-python-sdk 2.0.0b3__tar.gz → 2.0.0b5__tar.gz

kinde-python-sdk 2.0.0b3tar.gz → 2.0.0b5tar.gz