🔍 Code Extractor

Factory function that creates and initializes a review panel UI component for document review workflow management, with error handling and fallback to a minimal panel on failure.

Purpose

This function serves as a factory to instantiate a review workflow panel UI component. It delegates to a generic workflow panel creator with 'REVIEW' type, handling initialization of the review controller, session management, and parent application context. If creation fails, it provides a graceful fallback with a minimal error-displaying panel that includes basic required methods to prevent downstream errors.

Source Code

def create_review_panel(session_manager=None, parent_app=None, embedded=False):
    """Create and initialize a review panel instance"""
    try:
        # Import from the base module
        from CDocs.ui.workflow_panel_base import create_workflow_panel
        
        # Use the generic function from workflow_panel_base
        return create_workflow_panel(
            workflow_type='REVIEW',
            controller=None,  # Let the panel initialize the controller
            session_manager=session_manager,
            parent_app=parent_app,
            embedded=embedded
        )
                
    except Exception as e:
        logger.error(f"Error creating review panel: {e}")
        logger.error(traceback.format_exc())
        
        # Return a minimal functioning panel
        minimal_panel = pn.Column(
            pn.pane.Markdown("# Review Management"),
            pn.pane.Markdown(f"**Error loading review panel:** {str(e)}")
        )
        minimal_panel.main_content = minimal_panel
        
        # Add minimal set_user method to avoid errors
        import types
        def minimal_set_user(obj, user):
            pass
        minimal_panel.set_user = types.MethodType(minimal_set_user, minimal_panel)
        
        return minimal_panel

Parameters

Parameter Details

session_manager: Optional SessionManager instance for handling user authentication and session state. If None, the panel may initialize its own or operate without session management. Expected type: SessionManager or None.

parent_app: Optional reference to the parent application container. Used for integration with larger application contexts and inter-component communication. Expected type: application object or None.

embedded: Boolean flag indicating whether the panel should be rendered in embedded mode (True) or standalone mode (False). Embedded mode may alter layout, styling, or available features. Default: False.

Return Value

Returns a Panel UI component (typically a WorkflowPanelBase instance or subclass) configured for review workflow management. The returned object has a 'main_content' attribute containing the UI layout and a 'set_user' method for user context updates. On error, returns a minimal pn.Column panel displaying error information with stub methods to maintain interface compatibility.

Dependencies

• panel
• logging
• traceback
• typing
• datetime
• pandas
• CDocs

Required Imports

import panel as pn
import logging
import traceback
from CDocs.ui.workflow_panel_base import create_workflow_panel

Conditional/Optional Imports

These imports are only needed under specific conditions:

import types

from CDocs.auth.session_manager import SessionManager

from CDocs.controllers.review_controller import _controller

Usage Example

import panel as pn
from CDocs.auth.session_manager import SessionManager
from your_module import create_review_panel

# Initialize Panel extension
pn.extension()

# Create session manager
session_mgr = SessionManager()

# Create standalone review panel
review_panel = create_review_panel(
    session_manager=session_mgr,
    parent_app=None,
    embedded=False
)

# Set user context
from CDocs.models.user_extensions import DocUser
user = DocUser(username='reviewer1', role='REVIEWER')
review_panel.set_user(user)

# Display the panel
review_panel.servable()

# Or embed in larger application
app_panel = create_review_panel(
    session_manager=session_mgr,
    parent_app=my_app,
    embedded=True
)
my_app.add_component(app_panel.main_content)

Best Practices

• Always handle the potential for error fallback panel - check if returned panel has full functionality before calling advanced methods
• Initialize Panel extension (pn.extension()) before calling this function
• Provide a session_manager when user authentication and authorization are required
• Call set_user() method on returned panel to establish user context before displaying
• Use embedded=True when integrating into larger applications to avoid layout conflicts
• Monitor logs for 'Error creating review panel' messages to catch initialization failures
• The function catches all exceptions and returns a minimal panel - ensure proper error monitoring in production
• The minimal fallback panel only has set_user and main_content - avoid calling other methods without checking existence first

Tags

Similar Components

AI-powered semantic similarity - components with related functionality:

• function create_review_panel 93.6% similar

  Factory function that creates and initializes a ReviewPanel instance with error handling, supporting both standalone and embedded modes for document review management.

  From: /tf/active/vicechatdev/CDocs/ui/review_panel.py

• function create_workflow_panel 87.1% similar

  Factory function that creates and initializes workflow management panels (Review or Approval) with appropriate configuration, error handling, and fallback mechanisms.

  From: /tf/active/vicechatdev/CDocs single class/ui/workflow_panel_base.py

• function create_approval_panel_v1 80.6% similar

  Factory function that creates and initializes an approval workflow panel UI component for managing document approval cycles.

  From: /tf/active/vicechatdev/CDocs single class/ui/approval_panel.py

• function create_approval_panel_v2 80.6% similar

  Factory function that creates and initializes an ApprovalPanel instance for managing document approvals, with error handling and fallback to a minimal panel on failure.

  From: /tf/active/vicechatdev/CDocs/ui/approval_panel.py

• class ReviewPanel 79.0% similar

  ReviewPanel is a UI component class for managing document review workflows, providing interfaces for viewing review details, submitting review decisions, and managing review cycles.

  From: /tf/active/vicechatdev/CDocs single class/ui/review_panel.py