🔍 Code Extractor

A session management class for Panel applications that provides user authentication and arbitrary key-value storage using Panel's built-in state management system.

Purpose

SessionManager provides a clean interface for managing user sessions in Panel web applications. It handles user authentication state, stores user IDs, and provides generic key-value storage for session data. The class wraps Panel's pn.state.cache to ensure consistent session management across the application lifecycle. It's designed for web applications that need to track user authentication status and maintain session-specific data.

Source Code

class SessionManager:
    """
    Session manager for Panel applications
    
    Uses Panel's built-in state management to store user session information
    """
    
    def __init__(self):
        """Initialize the session manager"""
        # Ensure Panel state is initialized
        if not hasattr(pn.state, 'cache'):
            pn.state.cache = {}
    
    def set_user_id(self, user_id):
        """
        Set the current user ID in the session
        
        Args:
            user_id: The user ID to store
        
        Returns:
            bool: True if successful, False otherwise
        """
        if not user_id:
            return False
            
        # Store in Panel's state
        pn.state.cache['user_id'] = user_id
        logger.debug(f"User ID set in session: {user_id}")
        return True
    
    def get_user_id(self):
        """
        Get the current user ID from the session
        
        Returns:
            The user ID or None if not set
        """
        return pn.state.cache.get('user_id')
    
    def clear_session(self):
        """Clear the current session"""
        if 'user_id' in pn.state.cache:
            del pn.state.cache['user_id']
        logger.debug("Session cleared")
        
    def is_authenticated(self):
        """
        Check if the current session is authenticated
        
        Returns:
            bool: True if authenticated, False otherwise
        """
        return self.get_user_id() is not None
    
    def store_value(self, key, value):
        """
        Store an arbitrary value in the session
        
        Args:
            key (str): The key to store the value under
            value: The value to store
            
        Returns:
            bool: True if successful
        """
        pn.state.cache[key] = value
        return True
    
    def get_value(self, key, default=None):
        """
        Retrieve a value from the session
        
        Args:
            key (str): The key to retrieve
            default: The default value if the key doesn't exist
            
        Returns:
            The stored value or the default
        """
        return pn.state.cache.get(key, default)
    
    def remove_value(self, key):
        """
        Remove a value from the session
        
        Args:
            key (str): The key to remove
            
        Returns:
            bool: True if the key existed and was removed, False otherwise
        """
        if key in pn.state.cache:
            del pn.state.cache[key]
            return True
        return False

Parameters

Name	Type	Default	Kind
bases	-	-

Parameter Details

__init__: No parameters required. The constructor initializes the Panel state cache if it doesn't already exist, ensuring the session storage backend is ready for use.

Return Value

Instantiation returns a SessionManager object. Methods return: set_user_id() returns bool (True on success, False if user_id is empty); get_user_id() returns the stored user ID or None; clear_session() returns None; is_authenticated() returns bool; store_value() returns bool (True on success); get_value() returns the stored value or default; remove_value() returns bool (True if key existed and was removed, False otherwise).

Class Interface

Methods

Attributes

Name	Type	Description	Scope
pn.state.cache	dict	Panel's built-in session cache dictionary used as the underlying storage mechanism. Accessed but not stored as an instance attribute. Contains all session data including 'user_id' and any custom key-value pairs	instance

Dependencies

• panel
• logging

Required Imports

import panel as pn
import logging

Usage Example

import panel as pn
import logging

# Setup logger
logger = logging.getLogger(__name__)

# Initialize Panel
pn.extension()

# Create session manager
session_mgr = SessionManager()

# Set user ID for authentication
session_mgr.set_user_id('user123')

# Check authentication status
if session_mgr.is_authenticated():
    user_id = session_mgr.get_user_id()
    print(f'Authenticated as: {user_id}')

# Store arbitrary session data
session_mgr.store_value('theme', 'dark')
session_mgr.store_value('preferences', {'lang': 'en', 'notifications': True})

# Retrieve session data
theme = session_mgr.get_value('theme', default='light')
prefs = session_mgr.get_value('preferences')

# Remove specific value
session_mgr.remove_value('theme')

# Clear entire session
session_mgr.clear_session()

Best Practices

• Always check is_authenticated() before accessing user-specific resources
• Call clear_session() when users log out to prevent data leakage
• The class relies on Panel's pn.state.cache which is session-specific in Panel applications
• Ensure Panel is properly initialized before instantiating SessionManager
• Use store_value() and get_value() for custom session data beyond user authentication
• The logger variable must be defined in the module scope for debug logging to work
• Session data persists only for the duration of the Panel session and is not shared across browser tabs or sessions
• set_user_id() validates that user_id is not empty/None before storing
• Use get_value() with a default parameter to avoid None checks in calling code

Tags

Similar Components

AI-powered semantic similarity - components with related functionality:

• class _state 72.8% similar

  A global state management class that tracks and manages the state of running Panel applications, including server information, session data, busy status, and various application-level resources.

  From: /tf/active/vicechatdev/patches/state.py

• function _initialize_session_info 64.3% similar

  Initializes and manages session information for a web application session, tracking session lifecycle timestamps and user agent data while maintaining a configurable history limit.

  From: /tf/active/vicechatdev/patches/server.py

• class User 60.8% similar

  A user management class that handles authentication, authorization, user profiles, preferences, file management, and logging for a Panel-based web application with Neo4j backend.

  From: /tf/active/vicechatdev/userclass.py

• class SmartStatSession 58.0% similar

  A session management class that encapsulates a SmartStat statistical analysis session, tracking data, analysis history, plots, and reports for a specific data section.

  From: /tf/active/vicechatdev/vice_ai/smartstat_service.py

• class ControlledDocApp 57.0% similar

  A standalone Panel web application class that provides a complete controlled document management system with user authentication, navigation, and document lifecycle management features.

  From: /tf/active/vicechatdev/panel_app.py

class SessionManager:
    """
    Session manager for Panel applications
    
    Uses Panel's built-in state management to store user session information
    """
    
    def __init__(self):
        """Initialize the session manager"""
        # Ensure Panel state is initialized
        if not hasattr(pn.state, 'cache'):
            pn.state.cache = {}
    
    def set_user_id(self, user_id):
        """
        Set the current user ID in the session
        
        Args:
            user_id: The user ID to store
        
        Returns:
            bool: True if successful, False otherwise
        """
        if not user_id:
            return False
            
        # Store in Panel's state
        pn.state.cache['user_id'] = user_id
        logger.debug(f"User ID set in session: {user_id}")
        return True
    
    def get_user_id(self):
        """
        Get the current user ID from the session
        
        Returns:
            The user ID or None if not set
        """
        return pn.state.cache.get('user_id')
    
    def clear_session(self):
        """Clear the current session"""
        if 'user_id' in pn.state.cache:
            del pn.state.cache['user_id']
        logger.debug("Session cleared")
        
    def is_authenticated(self):
        """
        Check if the current session is authenticated
        
        Returns:
            bool: True if authenticated, False otherwise
        """
        return self.get_user_id() is not None
    
    def store_value(self, key, value):
        """
        Store an arbitrary value in the session
        
        Args:
            key (str): The key to store the value under
            value: The value to store
            
        Returns:
            bool: True if successful
        """
        pn.state.cache[key] = value
        return True
    
    def get_value(self, key, default=None):
        """
        Retrieve a value from the session
        
        Args:
            key (str): The key to retrieve
            default: The default value if the key doesn't exist
            
        Returns:
            The stored value or the default
        """
        return pn.state.cache.get(key, default)
    
    def remove_value(self, key):
        """
        Remove a value from the session
        
        Args:
            key (str): The key to remove
            
        Returns:
            bool: True if the key existed and was removed, False otherwise
        """
        if key in pn.state.cache:
            del pn.state.cache[key]
            return True
        return False