Blame for pages/11_Collaborative_Features.py

import streamlit as st
import pandas as pd
import numpy as np
import json
import base64
import io
from datetime import datetime
import os

# Page configuration
st.set_page_config(
    page_title="Collaborative Features",
    page_icon="👥",
    layout="wide"
)

# Page title
st.title("👥 Collaborative Features")
st.markdown("""
Share your analysis, save projects for later, and collaborate with others 
by importing and exporting complete analysis workflows and results.
""")

# Create tabs for different collaborative features
tab1, tab2, tab3 = st.tabs([
    "Project Management", 
    "Share Analysis", 
    "Import/Export Workflows"
])

# Initialize project state if not exists
if 'projects' not in st.session_state:
    st.session_state.projects = []

# Project Management Tab
with tab1:
    st.subheader("Project Management")
    
    # Project saving section
    st.markdown("""
    Save your current dataset and analysis settings as a project to continue working on it later.
    Projects are stored in your browser and will be available when you return.
    """)
    
    # Form for saving a project
    with st.form("save_project_form"):
        project_name = st.text_input("Project Name", placeholder="My Data Analysis Project")
        project_description = st.text_area("Description (optional)", placeholder="Brief description of this analysis project")
        
        col1, col2, col3 = st.columns([2, 1, 1])
        with col1:
            project_tags = st.text_input("Tags (comma separated)", placeholder="finance, stocks, analysis")
        with col2:
            save_data = st.checkbox("Include Dataset", value=True)
        with col3:
            overwrite = st.checkbox("Overwrite if exists", value=False)
            
        save_button = st.form_submit_button("Save Project")
    
    if save_button:
        if not project_name:
            st.error("Please provide a project name.")
        else:
            try:
                # Check if project exists
                existing_project = False
                for i, project in enumerate(st.session_state.projects):
                    if project['name'] == project_name:
                        existing_project = True
                        if overwrite:
                            # Update existing project
                            project_index = i
                            break
                        else:
                            st.error(f"Project '{project_name}' already exists. Use 'Overwrite if exists' to replace it.")
                            break
                
                # If project doesn't exist or we're overwriting
                if not existing_project or (existing_project and overwrite):
                    # Create project data structure
                    project_data = {
                        'name': project_name,
                        'description': project_description,
                        'tags': [tag.strip() for tag in project_tags.split(',')] if project_tags else [],
                        'date_created': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                        'dataset_name': st.session_state.get('dataset_name', 'Unknown'),
                        'settings': {}
                    }
                    
                    # Include dataset if selected
                    if save_data and 'df' in st.session_state and st.session_state.df is not None:
                        # Convert dataframe to CSV string
                        csv_buffer = io.StringIO()
                        st.session_state.df.to_csv(csv_buffer, index=False)
                        csv_str = csv_buffer.getvalue()
                        
                        # Base64 encode to reduce storage size
                        csv_bytes = csv_str.encode()
                        b64_csv = base64.b64encode(csv_bytes).decode()
                        
                        # Add to project data
                        project_data['dataset'] = b64_csv
                        project_data['row_count'] = len(st.session_state.df)
                        project_data['column_count'] = len(st.session_state.df.columns)
                    else:
                        project_data['dataset'] = None
                    
                    # Save the project
                    if existing_project and overwrite:
                        st.session_state.projects[project_index] = project_data
                        st.success(f"Project '{project_name}' updated successfully!")
                    else:
                        st.session_state.projects.append(project_data)
                        st.success(f"Project '{project_name}' saved successfully!")
                    
            except Exception as e:
                st.error(f"Error saving project: {e}")
    
    # Project list section
    st.subheader("Your Saved Projects")
    
    if not st.session_state.projects:
        st.info("You don't have any saved projects yet.")
    else:
        # Filter and search options
        col1, col2 = st.columns([3, 1])
        with col1:
            search_term = st.text_input("Search Projects", placeholder="Enter project name or tag")
        with col2:
            sort_by = st.selectbox("Sort By", ["Date (newest)", "Date (oldest)", "Name (A-Z)", "Name (Z-A)"])
        
        # Filter projects based on search term
        filtered_projects = st.session_state.projects
        if search_term:
            filtered_projects = [
                p for p in filtered_projects if (
                    search_term.lower() in p['name'].lower() or
                    search_term.lower() in p['description'].lower() or
                    any(search_term.lower() in tag.lower() for tag in p['tags'])
                )
            ]
        
        # Sort projects
        if sort_by == "Date (newest)":
            filtered_projects = sorted(filtered_projects, key=lambda p: p['date_created'], reverse=True)
        elif sort_by == "Date (oldest)":
            filtered_projects = sorted(filtered_projects, key=lambda p: p['date_created'])
        elif sort_by == "Name (A-Z)":
            filtered_projects = sorted(filtered_projects, key=lambda p: p['name'])
        elif sort_by == "Name (Z-A)":
            filtered_projects = sorted(filtered_projects, key=lambda p: p['name'], reverse=True)
        
        # Display projects in a grid
        if filtered_projects:
            # Create 3 columns for the grid
            cols = st.columns(3)
            
            # Display each project in the grid
            for i, project in enumerate(filtered_projects):
                col_index = i % 3
                
                with cols[col_index]:
                    st.markdown(f"""
                    <div style="
                        border: 1px solid #ddd;
                        border-radius: 5px;
                        padding: 10px;
                        margin-bottom: 15px;
                    ">
                        <h4>{project['name']}</h4>
                        <p><small>{project['date_created']}</small></p>
                        <p>{project['description']}</p>
                        <p>
                            <small>
                                {'Dataset: ' + (str(project.get('row_count', 'N/A')) + ' rows × ' + str(project.get('column_count', 'N/A')) + ' columns' if project.get('dataset') else 'No dataset')}
                            </small>
                        </p>
                        <p>
                            <small>
                                {', '.join(['#' + tag for tag in project['tags']]) if project['tags'] else 'No tags'}
                            </small>
                        </p>
                    </div>
                    """, unsafe_allow_html=True)
                    
                    c1, c2, c3 = st.columns([1, 1, 1])
                    with c1:
                        if st.button("Load", key=f"load_{i}"):
                            # Load the project
                            if project.get('dataset'):
                                try:
                                    # Decode base64 to CSV
                                    b64_csv = project['dataset']
                                    csv_bytes = base64.b64decode(b64_csv)
                                    csv_str = csv_bytes.decode()
                                    
                                    # Load CSV into dataframe
                                    csv_buffer = io.StringIO(csv_str)
                                    loaded_df = pd.read_csv(csv_buffer)
                                    
                                    # Update session state
                                    st.session_state.df = loaded_df
                                    st.session_state.dataset_name = project['name']
                                    
                                    st.success(f"Project '{project['name']}' loaded successfully!")
                                    st.rerun()
                                except Exception as e:
                                    st.error(f"Error loading project data: {e}")
                            else:
                                st.warning("This project does not include dataset. Only project metadata was loaded.")
                    
                    with c2:
                        if st.button("Delete", key=f"delete_{i}"):
                            # Ask for confirmation
                            st.session_state.delete_index = i
                            st.info(f"Are you sure you want to delete project '{project['name']}'?")
                            st.button("Yes, Delete", key=f"confirm_delete_{i}", on_click=lambda: delete_project(i))
                    
                    with c3:
                        if st.button("Export", key=f"export_{i}"):
                            # Export the project to JSON
                            try:
                                project_json = json.dumps(project, indent=2)
                                b64 = base64.b64encode(project_json.encode()).decode()
                                
                                href = f'<a href="data:application/json;base64,{b64}" download="{project["name"].replace(" ", "_")}.json">Download Project JSON</a>'
                                st.markdown(href, unsafe_allow_html=True)
                            except Exception as e:
                                st.error(f"Error exporting project: {e}")
        else:
            st.info("No projects match your search criteria.")

# Function to delete a project
def delete_project(index):
    if 0 <= index < len(st.session_state.projects):
        project_name = st.session_state.projects[index]['name']
        del st.session_state.projects[index]
        st.success(f"Project '{project_name}' deleted successfully!")
        st.rerun()

# Share Analysis Tab
with tab2:
    st.subheader("Share Your Analysis")
    
    # Analysis report generation
    st.markdown("""
    Generate a sharable report of your current analysis, including visualizations and insights.
    You can download the report in various formats or get a shareable link.
    """)
    
    # Check if data is loaded
    if 'df' not in st.session_state or st.session_state.df is None:
        st.warning("Please load a dataset first to generate a report.")
    else:
        # Report options
        st.subheader("Report Configuration")
        
        col1, col2 = st.columns(2)
        
        with col1:
            report_title = st.text_input("Report Title", value=f"Analysis of {st.session_state.dataset_name}")
            report_author = st.text_input("Author/Organization")
        
        with col2:
            include_options = st.multiselect(
                "Include in Report",
                ["Dataset Info", "Data Preview", "Summary Statistics", "Visualizations", "Insights"],
                default=["Dataset Info", "Data Preview", "Summary Statistics"]
            )
            
            report_format = st.selectbox(
                "Report Format",
                ["HTML", "PDF", "JSON"]
            )
        
        if st.button("Generate Report"):
            with st.spinner("Generating report..."):
                try:
                    # Create basic report data
                    report_data = {
                        "title": report_title,
                        "author": report_author,
                        "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                        "dataset_name": st.session_state.dataset_name,
                        "sections": []
                    }
                    
                    # Include selected sections
                    if "Dataset Info" in include_options:
                        dataset_info = {
                            "section_title": "Dataset Information",
                            "content": {
                                "rows": len(st.session_state.df),
                                "columns": len(st.session_state.df.columns),
                                "column_names": st.session_state.df.columns.tolist(),
                                "data_types": {col: str(dtype) for col, dtype in st.session_state.df.dtypes.items()}
                            }
                        }
                        report_data["sections"].append(dataset_info)
                    
                    if "Data Preview" in include_options:
                        data_preview = {
                            "section_title": "Data Preview",
                            "content": {
                                "preview": st.session_state.df.head(10).to_dict(orient="records")
                            }
                        }
                        report_data["sections"].append(data_preview)
                    
                    if "Summary Statistics" in include_options:
                        # Get numeric columns for summary stats
                        numeric_cols = st.session_state.df.select_dtypes(include=['number']).columns.tolist()
                        if numeric_cols:
                            summary_stats = {
                                "section_title": "Summary Statistics",
                                "content": {
                                    "stats": st.session_state.df[numeric_cols].describe().to_dict()
                                }
                            }
                            report_data["sections"].append(summary_stats)
                    
                    # Generate report based on format
                    if report_format == "JSON":
                        # Convert report data to JSON
                        report_json = json.dumps(report_data, indent=2)
                        
                        # Create download link
                        b64 = base64.b64encode(report_json.encode()).decode()
                        filename = f"{report_title.replace(' ', '_')}_report.json"
                        href = f'<a href="data:application/json;base64,{b64}" download="{filename}">Download Report JSON</a>'
                        
                        st.success("Report generated successfully!")
                        st.markdown(href, unsafe_allow_html=True)
                    
                    elif report_format == "HTML":
                        # Create a simple HTML report
                        html_report = f"""
                        <!DOCTYPE html>
                        <html>
                        <head>
                            <title>{report_title}</title>
                            <style>
                                body {{ font-family: Arial, sans-serif; margin: 20px; line-height: 1.6; }}
                                h1 {{ color: #1E88E5; }}
                                h2 {{ color: #0D47A1; margin-top: 20px; }}
                                .metadata {{ color: #666; font-style: italic; margin-bottom: 20px; }}
                                table {{ border-collapse: collapse; width: 100%; }}
                                th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
                                th {{ background-color: #f2f2f2; }}
                                tr:hover {{ background-color: #f5f5f5; }}
                            </style>
                        </head>
                        <body>
                            <h1>{report_title}</h1>
                            <div class="metadata">
                                <p>Author: {report_author if report_author else 'Anonymous'}</p>
                                <p>Date: {report_data['date']}</p>
                                <p>Dataset: {report_data['dataset_name']}</p>
                            </div>
                        """
                        
                        # Add sections
                        for section in report_data["sections"]:
                            section_title = section["section_title"]
                            content = section["content"]
                            
                            html_report += f"<h2>{section_title}</h2>"
                            
                            if section_title == "Dataset Information":
                                html_report += f"""
                                <p>Rows: {content['rows']}</p>
                                <p>Columns: {content['columns']}</p>
                                <h3>Columns:</h3>
                                <table>
                                    <tr>
                                        <th>Column Name</th>
                                        <th>Data Type</th>
                                    </tr>
                                """
                                
                                for col in content['column_names']:
                                    html_report += f"""
                                    <tr>
                                        <td>{col}</td>
                                        <td>{content['data_types'][col]}</td>
                                    </tr>
                                    """
                                
                                html_report += "</table>"
                            
                            elif section_title == "Data Preview":
                                preview = content['preview']
                                if preview:
                                    # Create table headers
                                    html_report += """
                                    <table>
                                        <tr>
                                    """
                                    
                                    for col in preview[0].keys():
                                        html_report += f"<th>{col}</th>"
                                    
                                    html_report += "</tr>"
                                    
                                    # Add data rows
                                    for row in preview:
                                        html_report += "<tr>"
                                        for col, val in row.items():
                                            html_report += f"<td>{val}</td>"
                                        html_report += "</tr>"
                                    
                                    html_report += "</table>"
                            
                            elif section_title == "Summary Statistics":
                                stats = content['stats']
                                if stats:
                                    # Create table headers
                                    html_report += """
                                    <table>
                                        <tr>
                                            <th>Statistic</th>
                                    """
                                    
                                    for col in stats.keys():
                                        html_report += f"<th>{col}</th>"
                                    
                                    html_report += "</tr>"
                                    
                                    # Add stats rows
                                    for stat in ['count', 'mean', 'std', 'min', '25%', '50%', '75%', 'max']:
                                        html_report += f"<tr><td>{stat}</td>"
                                        
                                        for col, values in stats.items():
                                            value = values.get(stat, "")
                                            if isinstance(value, (int, float)):
                                                value = f"{value:.4f}" if stat != 'count' else f"{int(value)}"
                                            html_report += f"<td>{value}</td>"
                                        
                                        html_report += "</tr>"
                                    
                                    html_report += "</table>"
                        
                        # Close HTML
                        html_report += """
                        </body>
                        </html>
                        """
                        
                        # Create download link
                        b64 = base64.b64encode(html_report.encode()).decode()
                        filename = f"{report_title.replace(' ', '_')}_report.html"
                        href = f'<a href="data:text/html;base64,{b64}" download="{filename}">Download HTML Report</a>'
                        
                        st.success("Report generated successfully!")
                        st.markdown(href, unsafe_allow_html=True)
                        
                        # Preview
                        with st.expander("Preview HTML Report", expanded=False):
                            st.components.v1.html(html_report, height=500, scrolling=True)
                    
                    elif report_format == "PDF":
                        st.info("PDF export requires additional libraries. Please use HTML or JSON format instead.")
                
                except Exception as e:
                    st.error(f"Error generating report: {e}")

# Import/Export Workflows Tab
with tab3:
    st.subheader("Import and Export Workflows")
    
    st.markdown("""
    Save your entire analysis workflow, including dataset, transformations, and visualizations.
    Export workflows to share with others or import workflows created by your colleagues.
    """)
    
    # Export workflow section
    st.subheader("Export Current Workflow")
    
    # Check if data is loaded
    if 'df' not in st.session_state or st.session_state.df is None:
        st.warning("Please load a dataset first to export a workflow.")
    else:
        # Workflow export options
        include_data = st.checkbox("Include Dataset", value=True)
        
        if st.button("Export Workflow"):
            with st.spinner("Preparing workflow export..."):
                try:
                    # Create workflow data structure
                    workflow_data = {
                        'name': st.session_state.get('dataset_name', 'Unnamed Workflow'),
                        'date_exported': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                        'settings': {}
                    }
                    
                    # Include dataset if selected
                    if include_data:
                        # Convert dataframe to CSV string
                        csv_buffer = io.StringIO()
                        st.session_state.df.to_csv(csv_buffer, index=False)
                        csv_str = csv_buffer.getvalue()
                        
                        # Base64 encode to reduce storage size
                        csv_bytes = csv_str.encode()
                        b64_csv = base64.b64encode(csv_bytes).decode()
                        
                        # Add to workflow data
                        workflow_data['dataset'] = b64_csv
                        workflow_data['row_count'] = len(st.session_state.df)
                        workflow_data['column_count'] = len(st.session_state.df.columns)
                    else:
                        workflow_data['dataset'] = None
                    
                    # Convert workflow to JSON
                    workflow_json = json.dumps(workflow_data, indent=2)
                    
                    # Create download link
                    b64 = base64.b64encode(workflow_json.encode()).decode()
                    filename = f"{workflow_data['name'].replace(' ', '_')}_workflow.json"
                    href = f'<a href="data:application/json;base64,{b64}" download="{filename}">Download Workflow</a>'
                    
                    st.success("Workflow exported successfully!")
                    st.markdown(href, unsafe_allow_html=True)
                
                except Exception as e:
                    st.error(f"Error exporting workflow: {e}")
    
    # Import workflow section
    st.subheader("Import Workflow")
    
    uploaded_file = st.file_uploader("Upload Workflow JSON", type=['json'])
    
    if uploaded_file is not None:
        try:
            # Load JSON from uploaded file
            workflow_json = uploaded_file.read()
            workflow_data = json.loads(workflow_json)
            
            # Display workflow info
            st.write(f"**Workflow Name:** {workflow_data.get('name', 'Unnamed Workflow')}")
            st.write(f"**Date Exported:** {workflow_data.get('date_exported', 'Unknown')}")
            
            if workflow_data.get('dataset') is not None:
                st.write(f"**Includes Dataset:** Yes ({workflow_data.get('row_count', 'N/A')} rows × {workflow_data.get('column_count', 'N/A')} columns)")
            else:
                st.write("**Includes Dataset:** No")
            
            # Import button
            if st.button("Import Workflow"):
                with st.spinner("Importing workflow..."):
                    if workflow_data.get('dataset') is not None:
                        try:
                            # Decode base64 to CSV
                            b64_csv = workflow_data['dataset']
                            csv_bytes = base64.b64decode(b64_csv)
                            csv_str = csv_bytes.decode()
                            
                            # Load CSV into dataframe
                            csv_buffer = io.StringIO(csv_str)
                            loaded_df = pd.read_csv(csv_buffer)
                            
                            # Update session state
                            st.session_state.df = loaded_df
                            st.session_state.dataset_name = workflow_data['name']
                            
                            st.success(f"Workflow '{workflow_data['name']}' imported successfully with dataset!")
                            st.rerun()
                        except Exception as e:
                            st.error(f"Error importing workflow dataset: {e}")
                    else:
                        st.warning("This workflow does not include a dataset. Only workflow metadata was imported.")
        
        except Exception as e:
            st.error(f"Error parsing workflow file: {e}")

# Sidebar with educational content
with st.sidebar:
    st.title("📚 Collaborative Data Science")
    
    st.markdown("""
    ### Benefits of Collaboration in Data Science
    
    Collaborative data science leads to:
    - **Diverse perspectives** that enhance analysis
    - **Knowledge sharing** across team members
    - **Faster problem solving** through combined expertise
    - **Increased reproducibility** with shared workflows
    - **Better documentation** for future reference
    
    ### Best Practices for Collaboration
    
    1. **Document your analysis**
       - Include clear descriptions of what you did and why
       - Note any assumptions made
       - Explain preprocessing steps
    
    2. **Use version control**
       - Save your work regularly
       - Track changes over time
       - Create branches for experimental analyses
    
    3. **Standardize workflows**
       - Use consistent naming conventions
       - Organize projects with clear structure
       - Define standard preprocessing steps
    
    4. **Share meaningful insights**
       - Focus on key findings rather than all results
       - Use visualizations effectively
       - Relate analysis to business questions
    
    5. **Request specific feedback**
       - Ask targeted questions when sharing work
       - Be open to constructive criticism
       - Incorporate feedback into iterations
    
    ### Data Privacy Considerations
    
    - Always consider data sensitivity when sharing
    - Remove or anonymize personally identifiable information
    - Follow relevant regulations (GDPR, HIPAA, etc.)
    - Use secure methods for sharing sensitive data
    """)