Skip to main content

Response Visualization API Reference

Overview​

This document provides a comprehensive API reference for the Response Visualization System, including all classes, methods, and configuration options.

Core Classes​

ResponseVisualizationSystem​

Main system class for response visualization.

class ResponseVisualizationSystem:
    def __init__(self, config: Optional[VisualizationConfig] = None)
    async def process_response(self, text: str, device_type: DeviceType = DeviceType.DESKTOP) -> VisualizationResult
    async def get_analytics(self) -> Dict[str, Any]
    async def optimize_visualizations(self)

Methods​

  • process_response(text, device_type): Process response and generate visualization
  • get_analytics(): Get visualization analytics
  • optimize_visualizations(): Optimize based on usage patterns

ContentTypeDetector​

Detects content type for appropriate visualization.

class ContentTypeDetector:
    async def analyze_content(self, text: str) -> ContentAnalysis

Methods​

  • analyze_content(text): Analyze content to determine visualization type

VisualizationGenerator​

Generates visualizations based on content analysis.

class VisualizationGenerator:
    def __init__(self, config: VisualizationConfig)
    async def generate_visualization(self, analysis: ContentAnalysis, device_type: DeviceType) -> VisualizationResult

Methods​

  • generate_visualization(analysis, device_type): Generate visualization based on content analysis

Configuration Classes​

VisualizationConfig​

Configuration for visualization generation.

@dataclass
class VisualizationConfig:
    theme: str = "default"
    color_scheme: str = "viridis"
    font_family: str = "Arial"
    font_size: int = 12
    width: int = 800
    height: int = 600
    responsive: bool = True
    interactive: bool = True
    accessibility: bool = True
    animation: bool = True
    export_enabled: bool = True

ContentAnalysis​

Result of content analysis.

@dataclass
class ContentAnalysis:
    content_type: ContentType
    confidence: float
    data_points: List[Dict[str, Any]]
    relationships: List[Dict[str, Any]]
    temporal_elements: List[Dict[str, Any]]
    numerical_elements: List[Dict[str, Any]]
    categorical_elements: List[Dict[str, Any]]
    metadata: Dict[str, Any]

VisualizationResult​

Result of visualization generation.

@dataclass
class VisualizationResult:
    visualization_type: VisualizationType
    content: str
    metadata: Dict[str, Any]
    export_formats: Dict[ExportFormat, str]
    accessibility_info: Dict[str, Any]
    responsive_breakpoints: Dict[DeviceType, Dict[str, Any]]

Enums​

ContentType​

Types of content that can be visualized.

class ContentType(str, Enum):
    NUMERICAL_DATA = "numerical_data"
    RELATIONSHIPS = "relationships"
    PROCESSES = "processes"
    COMPARISONS = "comparisons"
    TIMELINE = "timeline"
    HIERARCHY = "hierarchy"
    GEOGRAPHICAL = "geographical"
    TEXTUAL = "textual"
    MIXED = "mixed"

VisualizationType​

Types of visualizations.

class VisualizationType(str, Enum):
    BAR_CHART = "bar_chart"
    LINE_CHART = "line_chart"
    PIE_CHART = "pie_chart"
    SCATTER_PLOT = "scatter_plot"
    HEATMAP = "heatmap"
    TIMELINE = "timeline"
    FLOWCHART = "flowchart"
    NETWORK_DIAGRAM = "network_diagram"
    HIERARCHY_TREE = "hierarchy_tree"
    COMPARISON_TABLE = "comparison_table"
    SUMMARY_CARDS = "summary_cards"
    INTERACTIVE_DASHBOARD = "interactive_dashboard"

DeviceType​

Device types for responsive design.

class DeviceType(str, Enum):
    DESKTOP = "desktop"
    TABLET = "tablet"
    MOBILE = "mobile"

Factory Functions​

create_visualization_system​

Create a response visualization system.

def create_visualization_system(config: Optional[VisualizationConfig] = None) -> ResponseVisualizationSystem

create_visualization_config​

Create a visualization configuration.

def create_visualization_config(
    theme: str = "default",
    color_scheme: str = "viridis",
    interactive: bool = True,
    accessibility: bool = True
) -> VisualizationConfig

Usage Examples​

Basic Usage​

from packages.rag.response_visualization import ResponseVisualizationSystem, VisualizationConfig

# Create system
config = VisualizationConfig(interactive=True, accessibility=True)
system = ResponseVisualizationSystem(config)

# Process content
result = await system.process_response("Sales: $100K, Marketing: $75K", DeviceType.DESKTOP)
print(result.visualization_type)  # BAR_CHART
print(result.content)  # HTML content

Advanced Configuration​

# Custom configuration
config = VisualizationConfig(
    theme="modern",
    color_scheme="plasma",
    font_family="Roboto",
    font_size=14,
    width=1200,
    height=800,
    responsive=True,
    interactive=True,
    accessibility=True,
    animation=True,
    export_enabled=True
)

system = ResponseVisualizationSystem(config)

Analytics Usage​

# Get analytics
analytics = await system.get_analytics()
print(f"Total visualizations: {analytics['total_visualizations']}")
print(f"Visualization types: {analytics['visualization_types']}")
print(f"Accessibility usage: {analytics['accessibility_usage']}")

# Optimize based on usage
await system.optimize_visualizations()

Error Handling​

The system includes comprehensive error handling:

try:
    result = await system.process_response(content, DeviceType.DESKTOP)
    if result.content:
        print("Visualization generated successfully")
    else:
        print("No visualization content generated")
except Exception as e:
    print(f"Error generating visualization: {e}")

Performance Considerations​

  • Memory Usage: Large visualizations may require significant memory
  • Processing Time: Complex content may take longer to process
  • Caching: Enable caching for frequently accessed content
  • Optimization: Use optimization features for better performance

Best Practices​

  1. Content Preparation: Structure content clearly for better detection
  2. Configuration: Use appropriate configuration for your use case
  3. Error Handling: Always handle potential errors gracefully
  4. Performance: Monitor performance and optimize as needed
  5. Accessibility: Ensure accessibility features are enabled
  6. Testing: Test with different content types and devices