Tableau Dashboard Automation

import tableauserverclient as TSC
import pandas as pd
import requests
from typing import Dict, List, Optional
import json
from datetime import datetime

class TableauDashboardManager:
    def __init__(self, server_url: str, username: str, password: str, site_id: str = ''):
        self.server_url = server_url
        self.username = username
        self.password = password
        self.site_id = site_id
        self.server = None
        self.auth_token = None
    
    def connect_to_server(self):
        """Establish connection to Tableau Server"""
        server = TSC.Server(self.server_url, use_server_version=True)
        
        tableau_auth = TSC.TableauAuth(self.username, self.password, site_id=self.site_id)
        
        try:
            server.auth.sign_in(tableau_auth)
            self.server = server
            print(f"Successfully connected to Tableau Server: {self.server_url}")
            return True
        except Exception as e:
            print(f"Failed to connect to Tableau Server: {e}")
            return False
    
    def refresh_data_source(self, datasource_id: str) -> bool:
        """Refresh a specific data source"""
        try:
            datasource = self.server.datasources.get_by_id(datasource_id)
            self.server.datasources.refresh(datasource)
            print(f"Data source {datasource.name} refreshed successfully")
            return True
        except Exception as e:
            print(f"Failed to refresh data source: {e}")
            return False
    
    def publish_workbook(self, workbook_path: str, project_name: str) -> Optional[str]:
        """Publish workbook to Tableau Server"""
        try:
            # Find the project
            all_projects, _ = self.server.projects.get()
            project = next((p for p in all_projects if p.name == project_name), None)
            
            if not project:
                print(f"Project '{project_name}' not found")
                return None
            
            # Create workbook item
            new_workbook = TSC.WorkbookItem(project.id)
            
            # Publish workbook
            new_workbook = self.server.workbooks.publish(
                new_workbook, 
                workbook_path, 
                mode=TSC.Server.PublishMode.Overwrite
            )
            
            print(f"Workbook published successfully. ID: {new_workbook.id}")
            return new_workbook.id
            
        except Exception as e:
            print(f"Failed to publish workbook: {e}")
            return None
    
    def get_dashboard_metrics(self, workbook_id: str) -> Dict:
        """Extract metrics from dashboard views"""
        try:
            workbook = self.server.workbooks.get_by_id(workbook_id)
            
            # Get workbook views
            self.server.workbooks.populate_views(workbook)
            
            metrics = {
                'workbook_name': workbook.name,
                'total_views': len(workbook.views),
                'view_details': [],
                'last_updated': workbook.updated_at
            }
            
            for view in workbook.views:
                view_info = {
                    'view_name': view.name,
                    'view_id': view.id,
                    'view_url': f"{self.server_url}/#/views/{view.content_url}"
                }
                metrics['view_details'].append(view_info)
            
            return metrics
            
        except Exception as e:
            print(f"Failed to get dashboard metrics: {e}")
            return {}
    
    def create_usage_report(self) -> pd.DataFrame:
        """Generate usage report for all dashboards"""
        try:
            all_workbooks, _ = self.server.workbooks.get()
            
            usage_data = []
            for workbook in all_workbooks:
                # Get detailed workbook info
                workbook = self.server.workbooks.get_by_id(workbook.id)
                
                usage_data.append({
                    'workbook_name': workbook.name,
                    'project_name': workbook.project_name,
                    'owner': workbook.owner_id,
                    'created_at': workbook.created_at,
                    'updated_at': workbook.updated_at,
                    'size': workbook.size,
                    'view_count': len(workbook.views) if hasattr(workbook, 'views') else 0
                })
            
            return pd.DataFrame(usage_data)
            
        except Exception as e:
            print(f"Failed to create usage report: {e}")
            return pd.DataFrame()
    
    def disconnect(self):
        """Sign out from Tableau Server"""
        if self.server:
            self.server.auth.sign_out()
            print("Disconnected from Tableau Server")

# Usage example
def main():
    # Initialize Tableau manager
    tableau_manager = TableauDashboardManager(
        server_url="https://your-tableau-server.com",
        username="your-username",
        password="your-password",
        site_id="your-site-id"
    )
    
    # Connect and perform operations
    if tableau_manager.connect_to_server():
        # Refresh data sources
        tableau_manager.refresh_data_source("datasource-id")
        
        # Generate usage report
        usage_report = tableau_manager.create_usage_report()
        usage_report.to_csv('tableau_usage_report.csv', index=False)
        
        # Disconnect
        tableau_manager.disconnect()

if __name__ == "__main__":
    main()