Deploy MySpace Ooty Analytics to Hugging Face - with KPI styling updates

.streamlit/config.toml

@@ -0,0 +1,18 @@
+[theme]
+primaryColor = "#667eea"
+backgroundColor = "#ffffff"
+secondaryBackgroundColor = "#f0f2f6"
+textColor = "#262730"
+font = "sans serif"
+
+[client]
+showErrorDetails = true
+toolbarMode = "minimal"
+
+[logger]
+level = "info"
+
+[server]
+maxUploadSize = 200
+headless = true
+runOnSave = true

README.md

@@ -1 +1,123 @@
-# MySpace_Ooty_Data_Analytics
+---
+title: MySpace Ooty Analytics Dashboard
+emoji: 🏨
+colorFrom: blue
+colorTo: purple
+sdk: streamlit
+sdk_version: "1.28.0"
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🏨 MySpace Ooty Holiday Inn - Analytics Dashboard
+
+An interactive data analytics dashboard for MySpace Holiday Inn in Ooty, built with Streamlit and Plotly. This dashboard provides comprehensive insights into booking patterns, revenue analysis, and operational metrics.
+
+## 🌟 Features
+
+### 📊 Interactive Visualizations
+- **Real-time KPI Metrics**: Track key performance indicators at a glance
+- **Dynamic Filtering**: Filter data by year, month, and booking status
+- **Responsive Charts**: Beautiful, interactive Plotly charts that work on all devices
+
+### 📈 Analytics Capabilities
+- **Overview Dashboard**: Quick summary of business metrics and trends
+- **KPI Analysis**: Detailed performance indicators and metrics
+- **Data Exploration**: Deep dive into your booking data
+- **Trend Analysis**: Identify patterns and seasonal variations
+- **Custom Reports**: Generate and export personalized reports
+
+### 📱 Device Compatibility
+- Fully responsive design
+- Works on desktop, tablet, and mobile devices
+- Compatible with all modern browsers (Chrome, Firefox, Safari, Edge)
+
+## 🚀 How to Use
+
+1. **Navigation**: Use the sidebar to navigate between different sections
+2. **Filters**: Apply filters to customize your view and analysis
+3. **Visualizations**: Interact with charts by hovering, clicking, and zooming
+4. **Export**: Download reports in CSV, Excel, or PowerPoint format
+
+## 📊 Dashboard Sections
+
+### 1. Overview
+Get a quick summary of key metrics including:
+- Total bookings and revenue
+- Average length of stay
+- Revenue per booking
+- Monthly booking distribution
+- Day-of-week patterns
+- Holiday vs regular season analysis
+
+### 2. KPIs & Metrics
+View detailed performance indicators:
+- Comprehensive KPI summary table
+- Performance analysis
+- Weekend and holiday booking percentages
+
+### 3. Data Exploration
+Explore your data in depth:
+- Dataset overview and statistics
+- Sample data preview
+- Column-wise statistical analysis
+- Missing value detection
+
+### 4. Trends & Analysis
+Identify patterns and trends:
+- Monthly booking trends
+- Revenue trend analysis
+- Seasonal variations
+- Time-series visualizations
+
+### 5. Custom Reports
+Generate personalized reports:
+- Multiple report types
+- Export in various formats (CSV, Excel, PowerPoint)
+- Configurable date ranges and filters
+
+## 💡 Tips for Best Experience
+
+- **Use Filters**: Customize your analysis by selecting specific years, months, or booking statuses
+- **Hover for Details**: Hover over charts to see detailed information
+- **Mobile View**: Swipe left/right on mobile devices to navigate charts
+- **Export Data**: Download filtered data for offline analysis
+
+## 🏨 About MySpace Holiday Inn
+
+Located in the beautiful hill station of Ooty, MySpace Holiday Inn offers comfortable accommodation and excellent hospitality.
+
+**Contact Information:**
+- 📍 Head Office: Kotagiri – 643217
+- 📞 Phone: +91 82206 62206 | +91-6369052954 | +91-6369973006
+- 📧 Email: myspaceholidayinn@gmail.com
+- 📱 WhatsApp: +916381911228
+
+**Timings:**
+- Check-In: 12:00 PM
+- Check-Out: 10:00 AM
+
+## 🛠️ Technology Stack
+
+- **Frontend**: Streamlit
+- **Visualization**: Plotly, Matplotlib, Seaborn
+- **Data Processing**: Pandas, NumPy
+- **Analysis**: Scikit-learn, SciPy
+- **Export**: python-pptx, openpyxl
+
+## 📝 License
+
+MIT License - Feel free to use and modify for your needs.
+
+## 🤝 Support
+
+For questions or support, please contact:
+- Email: myspaceholidayinn@gmail.com
+- Phone: +91 82206 62206
+
+---
+
+**Made with ❤️ for MySpace Holiday Inn, Ooty**
+
+*Data Analytics Dashboard | Powered by Streamlit and Plotly*

app.py

@@ -0,0 +1,19 @@
+"""
+MySpace Ooty Data Analytics Dashboard
+Deployment Entry Point for Hugging Face Spaces
+
+This file serves as the main entry point for the Streamlit app.
+Hugging Face Spaces will automatically run this file.
+"""
+
+import sys
+from pathlib import Path
+
+# Add project root to path for imports
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+# Import and execute the main dashboard
+# This imports all the code from streamlit_app/app.py
+exec(open(project_root / "streamlit_app" / "app.py", encoding="utf-8").read())
+

config/constants.py

@@ -0,0 +1,32 @@
+"""
+Project constants
+"""
+
+# Application info
+APP_NAME = "MySpace Ooty Data Analytics"
+APP_VERSION = "1.0.0"
+APP_AUTHOR = "Data Engineering Team"
+
+# Color schemes
+COLOR_PALETTE = {
+    "primary": "#1f77b4",
+    "secondary": "#ff7f0e",
+    "success": "#2ca02c",
+    "danger": "#d62728",
+    "warning": "#ff9896",
+    "info": "#17becf",
+}
+
+# Months
+MONTHS = {
+    "January": 1, "February": 2, "March": 3, "April": 4,
+    "May": 5, "June": 6, "July": 7, "August": 8,
+    "September": 9, "October": 10, "November": 11, "December": 12
+}
+
+# Statistical thresholds
+STRONG_CORRELATION = 0.7
+MODERATE_CORRELATION = 0.4
+WEAK_CORRELATION = 0.2
+P_VALUE_SIGNIFICANT = 0.05
+P_VALUE_HIGHLY_SIGNIFICANT = 0.01

config/settings.py

@@ -0,0 +1,36 @@
+"""
+Configuration settings for the project
+"""
+
+from pathlib import Path
+
+# Project paths
+PROJECT_ROOT = Path(__file__).parent.parent
+DATA_DIR = PROJECT_ROOT / "data"
+RAW_DATA_DIR = DATA_DIR / "raw"
+PROCESSED_DATA_DIR = DATA_DIR / "processed"
+EXTERNAL_DATA_DIR = DATA_DIR / "external"
+OUTPUT_DIR = DATA_DIR / "outputs"
+REPORTS_DIR = PROJECT_ROOT / "reports"
+LOGS_DIR = PROJECT_ROOT / "logs"
+
+# Data processing settings
+MISSING_VALUE_STRATEGY = "drop"  # Options: 'drop', 'mean', 'median', 'forward_fill'
+OUTLIER_REMOVAL_METHOD = "iqr"  # Options: 'iqr', 'zscore'
+OUTLIER_THRESHOLD = 1.5
+
+# Analysis settings
+CORRELATION_METHOD = "pearson"  # Options: 'pearson', 'spearman', 'kendall'
+SIGNIFICANCE_LEVEL = 0.05
+TEST_TYPE = "ttest"  # Options: 'ttest', 'mannwhitneyu', 'chi2'
+
+# Visualization settings
+DEFAULT_COLORSCALE = "Viridis"
+PLOT_HEIGHT = 500
+PLOT_WIDTH = 900
+
+# Dashboard settings
+PAGE_ICON = "📊"
+PAGE_TITLE = "MySpace Ooty Data Analytics"
+LAYOUT = "wide"
+INITIAL_SIDEBAR_STATE = "expanded"

data/processed/kpi_summary.csv

@@ -0,0 +1,20 @@
+Metric,Value
+Total_Bookings,752.0
+Total_Revenue,31224854.0
+Avg_Revenue_Per_Booking,41522.41223404255
+Total_Rooms_Booked,1030.0
+Total_Room_Nights,78749.0
+Occupancy_Rate,20.94666843995212
+Avg_Length_of_Stay,104.71941489361703
+RevPAR,30315.39223300971
+Total_Adults,3164.0
+Total_Children,339.0
+Avg_Guests_Per_Booking,4.658244680851064
+Holiday_Season_Bookings,3.0
+Regular_Season_Bookings,749.0
+Holiday_Season_Revenue,179977.0
+Regular_Season_Revenue,31044877.0
+Checked Out_Count,625.0
+Cancelled_Count,111.0
+Confirmed_Count,14.0
+Checked In _Count,2.0

packages.txt

@@ -0,0 +1,6 @@
+# System-level dependencies for Hugging Face Spaces
+# These packages will be installed using apt-get
+
+# For handling images and plots
+libgl1-mesa-glx
+libglib2.0-0

requirements.txt

@@ -0,0 +1,21 @@
+# Core dependencies for Streamlit Dashboard
+streamlit>=1.28.0
+pandas>=2.0.0
+numpy>=1.24.0
+plotly>=5.18.0
+
+# Visualization
+seaborn>=0.12.0
+matplotlib>=3.7.0
+
+# Data processing and analysis
+scikit-learn>=1.3.0
+scipy>=1.11.0
+
+# File handling
+openpyxl>=3.1.0
+python-pptx>=0.6.21
+Pillow>=10.0.0
+
+# Configuration
+python-dotenv>=1.0.0

src/__init__.py

@@ -0,0 +1,5 @@
+"""
+MySpace Ooty Data Analytics - Data Processing and Analysis Module
+"""
+
+__version__ = "1.0.0"

src/analysis.py

@@ -0,0 +1,156 @@
+"""
+Statistical analysis and insights generation
+"""
+
+import pandas as pd
+import numpy as np
+from scipy import stats
+from typing import Dict, Tuple, Union
+
+
+def calculate_descriptive_stats(df: pd.DataFrame, column: str) -> Dict:
+    """
+    Calculate descriptive statistics for a column
+    
+    Args:
+        df: Input DataFrame
+        column: Column name
+        
+    Returns:
+        Dictionary with statistics
+    """
+    stats_dict = {
+        "count": df[column].count(),
+        "mean": df[column].mean(),
+        "median": df[column].median(),
+        "std": df[column].std(),
+        "min": df[column].min(),
+        "25%": df[column].quantile(0.25),
+        "75%": df[column].quantile(0.75),
+        "max": df[column].max(),
+        "skewness": df[column].skew(),
+        "kurtosis": df[column].kurtosis(),
+    }
+    return stats_dict
+
+
+def correlation_analysis(df: pd.DataFrame, method: str = "pearson") -> pd.DataFrame:
+    """
+    Perform correlation analysis
+    
+    Args:
+        df: Input DataFrame with numeric columns
+        method: 'pearson', 'spearman', or 'kendall'
+        
+    Returns:
+        Correlation matrix
+    """
+    numeric_df = df.select_dtypes(include=[np.number])
+    corr_matrix = numeric_df.corr(method=method)
+    return corr_matrix
+
+
+def hypothesis_testing(group1: pd.Series, group2: pd.Series, 
+                       test_type: str = "ttest") -> Dict:
+    """
+    Perform hypothesis testing between two groups
+    
+    Args:
+        group1: First group data
+        group2: Second group data
+        test_type: 't-test', 'mannwhitneyu', or 'chi2'
+        
+    Returns:
+        Dictionary with test results
+    """
+    results = {}
+    
+    if test_type == "ttest":
+        statistic, p_value = stats.ttest_ind(group1.dropna(), group2.dropna())
+        results = {
+            "test": "Independent t-test",
+            "statistic": statistic,
+            "p_value": p_value,
+            "significant": p_value < 0.05
+        }
+    
+    elif test_type == "mannwhitneyu":
+        statistic, p_value = stats.mannwhitneyu(group1.dropna(), group2.dropna())
+        results = {
+            "test": "Mann-Whitney U Test",
+            "statistic": statistic,
+            "p_value": p_value,
+            "significant": p_value < 0.05
+        }
+    
+    return results
+
+
+def anova_test(groups: list) -> Dict:
+    """
+    Perform ANOVA test
+    
+    Args:
+        groups: List of group data Series
+        
+    Returns:
+        Dictionary with ANOVA results
+    """
+    clean_groups = [g.dropna() for g in groups]
+    f_stat, p_value = stats.f_oneway(*clean_groups)
+    
+    return {
+        "test": "ANOVA",
+        "f_statistic": f_stat,
+        "p_value": p_value,
+        "significant": p_value < 0.05
+    }
+
+
+def chi_square_test(contingency_table: pd.DataFrame) -> Dict:
+    """
+    Perform Chi-square test for independence
+    
+    Args:
+        contingency_table: Contingency table (DataFrame)
+        
+    Returns:
+        Dictionary with test results
+    """
+    chi2, p_value, dof, expected = stats.chi2_contingency(contingency_table)
+    
+    return {
+        "test": "Chi-square",
+        "statistic": chi2,
+        "p_value": p_value,
+        "degrees_of_freedom": dof,
+        "significant": p_value < 0.05
+    }
+
+
+def trend_analysis(df: pd.DataFrame, time_col: str, value_col: str) -> Dict:
+    """
+    Perform simple trend analysis
+    
+    Args:
+        df: Input DataFrame
+        time_col: Column name for time/date
+        value_col: Column name for values
+        
+    Returns:
+        Dictionary with trend metrics
+    """
+    df_sorted = df.sort_values(time_col).copy()
+    x = np.arange(len(df_sorted))
+    y = df_sorted[value_col].values
+    
+    slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)
+    
+    return {
+        "slope": slope,
+        "intercept": intercept,
+        "r_squared": r_value**2,
+        "p_value": p_value,
+        "trend": "upward" if slope > 0 else "downward",
+        "significant": p_value < 0.05
+    }

src/data_loading.py

@@ -0,0 +1,63 @@
+"""
+Data loading module for reading Excel and CSV files
+"""
+
+import pandas as pd
+import os
+from pathlib import Path
+from typing import Union, Optional
+
+
+def load_excel_data(file_path: Union[str, Path], sheet_name: Optional[str] = None) -> pd.DataFrame:
+    """
+    Load Excel file data
+    
+    Args:
+        file_path: Path to Excel file
+        sheet_name: Name of sheet to load (if None, loads first sheet)
+        
+    Returns:
+        DataFrame containing the data
+    """
+    try:
+        df = pd.read_excel(file_path, sheet_name=sheet_name)
+        print(f"✓ Successfully loaded: {file_path}")
+        return df
+    except Exception as e:
+        print(f"✗ Error loading file: {e}")
+        raise
+
+
+def load_csv_data(file_path: Union[str, Path]) -> pd.DataFrame:
+    """
+    Load CSV file data
+    
+    Args:
+        file_path: Path to CSV file
+        
+    Returns:
+        DataFrame containing the data
+    """
+    try:
+        df = pd.read_csv(file_path)
+        print(f"✓ Successfully loaded: {file_path}")
+        return df
+    except Exception as e:
+        print(f"✗ Error loading file: {e}")
+        raise
+
+
+def get_data_files(directory: Union[str, Path], file_type: str = "xlsx") -> list:
+    """
+    Get all data files of specific type from directory
+    
+    Args:
+        directory: Path to directory
+        file_type: File extension to search for
+        
+    Returns:
+        List of file paths
+    """
+    path = Path(directory)
+    files = list(path.glob(f"*.{file_type}"))
+    return sorted(files)

src/data_processing.py

@@ -0,0 +1,107 @@
+"""
+Data processing and cleaning module
+"""
+
+import pandas as pd
+import numpy as np
+from typing import Union, List, Tuple
+
+
+def clean_data(df: pd.DataFrame, remove_duplicates: bool = True, 
+               handle_missing: str = "drop") -> pd.DataFrame:
+    """
+    Clean dataset by removing duplicates and handling missing values
+    
+    Args:
+        df: Input DataFrame
+        remove_duplicates: Whether to remove duplicate rows
+        handle_missing: Strategy for missing values ('drop', 'mean', 'median', 'forward_fill')
+        
+    Returns:
+        Cleaned DataFrame
+    """
+    df_clean = df.copy()
+    
+    if remove_duplicates:
+        initial_shape = df_clean.shape[0]
+        df_clean = df_clean.drop_duplicates()
+        print(f"Removed {initial_shape - df_clean.shape[0]} duplicate rows")
+    
+    if handle_missing == "drop":
+        df_clean = df_clean.dropna()
+    elif handle_missing == "mean":
+        numeric_cols = df_clean.select_dtypes(include=[np.number]).columns
+        df_clean[numeric_cols] = df_clean[numeric_cols].fillna(df_clean[numeric_cols].mean())
+    elif handle_missing == "median":
+        numeric_cols = df_clean.select_dtypes(include=[np.number]).columns
+        df_clean[numeric_cols] = df_clean[numeric_cols].fillna(df_clean[numeric_cols].median())
+    elif handle_missing == "forward_fill":
+        df_clean = df_clean.fillna(method='ffill')
+    
+    return df_clean
+
+
+def remove_outliers(df: pd.DataFrame, columns: List[str], 
+                    method: str = "iqr", threshold: float = 1.5) -> pd.DataFrame:
+    """
+    Remove outliers using IQR or Z-score method
+    
+    Args:
+        df: Input DataFrame
+        columns: List of column names to check for outliers
+        method: 'iqr' or 'zscore'
+        threshold: Threshold for outlier detection
+        
+    Returns:
+        DataFrame without outliers
+    """
+    df_clean = df.copy()
+    
+    if method == "iqr":
+        for col in columns:
+            Q1 = df_clean[col].quantile(0.25)
+            Q3 = df_clean[col].quantile(0.75)
+            IQR = Q3 - Q1
+            lower = Q1 - threshold * IQR
+            upper = Q3 + threshold * IQR
+            df_clean = df_clean[(df_clean[col] >= lower) & (df_clean[col] <= upper)]
+    
+    elif method == "zscore":
+        from scipy import stats
+        z_scores = np.abs(stats.zscore(df_clean[columns].select_dtypes(include=[np.number])))
+        df_clean = df_clean[(z_scores < threshold).all(axis=1)]
+    
+    return df_clean
+
+
+def normalize_columns(df: pd.DataFrame, columns: List[str], 
+                      method: str = "minmax") -> Tuple[pd.DataFrame, dict]:
+    """
+    Normalize specified columns
+    
+    Args:
+        df: Input DataFrame
+        columns: List of column names to normalize
+        method: 'minmax' or 'standard'
+        
+    Returns:
+        Normalized DataFrame and scaling parameters
+    """
+    df_norm = df.copy()
+    scaling_params = {}
+    
+    if method == "minmax":
+        for col in columns:
+            min_val = df_norm[col].min()
+            max_val = df_norm[col].max()
+            df_norm[col] = (df_norm[col] - min_val) / (max_val - min_val)
+            scaling_params[col] = {"min": min_val, "max": max_val}
+    
+    elif method == "standard":
+        for col in columns:
+            mean_val = df_norm[col].mean()
+            std_val = df_norm[col].std()
+            df_norm[col] = (df_norm[col] - mean_val) / std_val
+            scaling_params[col] = {"mean": mean_val, "std": std_val}
+    
+    return df_norm, scaling_params

src/generate_powerpoint_report.py

@@ -0,0 +1,319 @@
+"""
+PowerPoint Report Generation for MySpace Ooty Holiday Inn
+Creates a comprehensive director-level presentation with KPIs, charts, and insights
+"""
+
+import pandas as pd
+import numpy as np
+from datetime import datetime
+from pathlib import Path
+from pptx import Presentation
+from pptx.util import Inches, Pt
+from pptx.enum.text import PP_ALIGN
+from pptx.dml.color import RGBColor
+import warnings
+warnings.filterwarnings('ignore')
+
+class PowerPointReportGenerator:
+    """Generate professional PowerPoint reports with data analytics"""
+    
+    def __init__(self, data_path=None, output_path=None):
+        """Initialize the report generator"""
+        self.presentation = Presentation()
+        self.presentation.slide_width = Inches(10)
+        self.presentation.slide_height = Inches(7.5)
+        
+        # Load data
+        if data_path is None:
+            data_path = Path(__file__).parent.parent / "data" / "processed" / "data_cleaned_with_kpi.csv"
+        
+        self.data_path = data_path
+        self.output_path = output_path or Path(__file__).parent.parent / "reports" / "powerpoint" / f"MySpace_Ooty_Report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pptx"
+        
+        # Load data
+        self.df = self._load_data()
+        self.kpis = self._calculate_kpis()
+    
+    def _load_data(self):
+        """Load data from CSV"""
+        try:
+            if self.data_path.exists():
+                return pd.read_csv(self.data_path)
+            else:
+                print(f"Warning: Data file not found at {self.data_path}")
+                return pd.DataFrame()
+        except Exception as e:
+            print(f"Error loading data: {e}")
+            return pd.DataFrame()
+    
+    def _calculate_kpis(self):
+        """Calculate key performance indicators"""
+        if self.df.empty:
+            return {}
+        
+        kpis = {}
+        
+        # Basic metrics
+        kpis['Total_Bookings'] = len(self.df)
+        
+        # Revenue
+        revenue_cols = [col for col in self.df.columns if any(kw in col.lower() for kw in ['amount', 'revenue', 'total'])]
+        kpis['Total_Revenue'] = self.df[revenue_cols].sum().sum() if revenue_cols else 0
+        kpis['Avg_Revenue_Per_Booking'] = kpis['Total_Revenue'] / kpis['Total_Bookings'] if kpis['Total_Bookings'] > 0 else 0
+        
+        # Rooms and Nights
+        room_cols = [col for col in self.df.columns if any(kw in col.lower() for kw in ['rooms', 'no_rooms'])]
+        nights_cols = [col for col in self.df.columns if any(kw in col.lower() for kw in ['nights', 'los'])]
+        
+        kpis['Total_Rooms'] = self.df[room_cols].sum().sum() if room_cols else 0
+        kpis['Total_Nights'] = self.df[nights_cols].sum().sum() if nights_cols else 0
+        kpis['Avg_LOS'] = kpis['Total_Nights'] / kpis['Total_Bookings'] if kpis['Total_Bookings'] > 0 else 0
+        
+        # Seasonal
+        if 'Is_Holiday_Season' in self.df.columns:
+            kpis['Holiday_Bookings'] = (self.df['Is_Holiday_Season'] == 1).sum()
+            kpis['Regular_Bookings'] = (self.df['Is_Holiday_Season'] == 0).sum()
+            kpis['Holiday_Pct'] = (kpis['Holiday_Bookings'] / kpis['Total_Bookings'] * 100) if kpis['Total_Bookings'] > 0 else 0
+        
+        # Weekend bookings
+        if 'Is_Weekend' in self.df.columns:
+            kpis['Weekend_Bookings'] = (self.df['Is_Weekend'] == 1).sum()
+            kpis['Weekend_Pct'] = (kpis['Weekend_Bookings'] / kpis['Total_Bookings'] * 100) if kpis['Total_Bookings'] > 0 else 0
+        
+        return kpis
+    
+    def _add_title_slide(self, title, subtitle):
+        """Add title slide"""
+        slide_layout = self.presentation.slide_layouts[6]  # Blank layout
+        slide = self.presentation.slides.add_slide(slide_layout)
+        
+        # Add background color
+        background = slide.background
+        fill = background.fill
+        fill.solid()
+        fill.fore_color.rgb = RGBColor(25, 50, 100)
+        
+        # Title
+        title_box = slide.shapes.add_textbox(Inches(0.5), Inches(2.5), Inches(9), Inches(1.5))
+        title_frame = title_box.text_frame
+        title_frame.text = title
+        title_frame.paragraphs[0].font.size = Pt(54)
+        title_frame.paragraphs[0].font.bold = True
+        title_frame.paragraphs[0].font.color.rgb = RGBColor(255, 255, 255)
+        
+        # Subtitle
+        subtitle_box = slide.shapes.add_textbox(Inches(0.5), Inches(4), Inches(9), Inches(1))
+        subtitle_frame = subtitle_box.text_frame
+        subtitle_frame.text = subtitle
+        subtitle_frame.paragraphs[0].font.size = Pt(28)
+        subtitle_frame.paragraphs[0].font.color.rgb = RGBColor(200, 200, 200)
+        
+        # Date
+        date_box = slide.shapes.add_textbox(Inches(0.5), Inches(6.5), Inches(9), Inches(0.5))
+        date_frame = date_box.text_frame
+        date_frame.text = f"Report Generated: {datetime.now().strftime('%B %d, %Y')}"
+        date_frame.paragraphs[0].font.size = Pt(14)
+        date_frame.paragraphs[0].font.color.rgb = RGBColor(150, 150, 150)
+    
+    def _add_content_slide(self, title, content_list):
+        """Add a content slide with bullet points"""
+        slide_layout = self.presentation.slide_layouts[6]
+        slide = self.presentation.slides.add_slide(slide_layout)
+        
+        # Title
+        title_box = slide.shapes.add_textbox(Inches(0.5), Inches(0.3), Inches(9), Inches(0.6))
+        title_frame = title_box.text_frame
+        title_frame.text = title
+        title_frame.paragraphs[0].font.size = Pt(40)
+        title_frame.paragraphs[0].font.bold = True
+        title_frame.paragraphs[0].font.color.rgb = RGBColor(25, 50, 100)
+        
+        # Content
+        content_box = slide.shapes.add_textbox(Inches(0.75), Inches(1.2), Inches(8.5), Inches(5.8))
+        text_frame = content_box.text_frame
+        text_frame.word_wrap = True
+        
+        for i, item in enumerate(content_list):
+            if i == 0:
+                p = text_frame.paragraphs[0]
+            else:
+                p = text_frame.add_paragraph()
+            
+            p.text = item
+            p.font.size = Pt(18)
+            p.font.color.rgb = RGBColor(50, 50, 50)
+            p.level = 0
+            p.space_before = Pt(6)
+            p.space_after = Pt(6)
+    
+    def _add_kpi_slide(self):
+        """Add KPI summary slide"""
+        slide_layout = self.presentation.slide_layouts[6]
+        slide = self.presentation.slides.add_slide(slide_layout)
+        
+        # Title
+        title_box = slide.shapes.add_textbox(Inches(0.5), Inches(0.3), Inches(9), Inches(0.6))
+        title_frame = title_box.text_frame
+        title_frame.text = "📊 Key Performance Indicators"
+        title_frame.paragraphs[0].font.size = Pt(40)
+        title_frame.paragraphs[0].font.bold = True
+        title_frame.paragraphs[0].font.color.rgb = RGBColor(25, 50, 100)
+        
+        # KPI boxes
+        kpi_items = [
+            ("Total Bookings", f"{self.kpis.get('Total_Bookings', 0):,}", RGBColor(100, 150, 200)),
+            ("Total Revenue", f"₹{self.kpis.get('Total_Revenue', 0):,.0f}", RGBColor(150, 100, 200)),
+            ("Avg Revenue/Booking", f"₹{self.kpis.get('Avg_Revenue_Per_Booking', 0):,.0f}", RGBColor(100, 200, 150)),
+            ("Avg Length of Stay", f"{self.kpis.get('Avg_LOS', 0):.2f} nights", RGBColor(200, 150, 100)),
+        ]
+        
+        positions = [(0.5, 1.3), (5.25, 1.3), (0.5, 4.2), (5.25, 4.2)]
+        
+        for idx, (kpi_name, kpi_value, color) in enumerate(kpi_items):
+            x, y = positions[idx]
+            
+            # Box
+            box = slide.shapes.add_shape(1, Inches(x), Inches(y), Inches(4), Inches(2.4))
+            box.fill.solid()
+            box.fill.fore_color.rgb = color
+            box.line.color.rgb = RGBColor(200, 200, 200)
+            
+            # KPI Name
+            name_box = slide.shapes.add_textbox(Inches(x + 0.2), Inches(y + 0.3), Inches(3.6), Inches(0.6))
+            name_frame = name_box.text_frame
+            name_frame.text = kpi_name
+            name_frame.paragraphs[0].font.size = Pt(14)
+            name_frame.paragraphs[0].font.bold = True
+            name_frame.paragraphs[0].font.color.rgb = RGBColor(255, 255, 255)
+            
+            # KPI Value
+            value_box = slide.shapes.add_textbox(Inches(x + 0.2), Inches(y + 1), Inches(3.6), Inches(1))
+            value_frame = value_box.text_frame
+            value_frame.text = kpi_value
+            value_frame.paragraphs[0].font.size = Pt(24)
+            value_frame.paragraphs[0].font.bold = True
+            value_frame.paragraphs[0].font.color.rgb = RGBColor(255, 255, 255)
+    
+    def generate_report(self):
+        """Generate the complete report"""
+        print("🔄 Generating PowerPoint Report...")
+        
+        # Slide 1: Title Slide
+        self._add_title_slide(
+            "MySpace Ooty Holiday Inn",
+            "Data Analytics & Performance Report"
+        )
+        
+        # Slide 2: Executive Summary
+        self._add_content_slide(
+            "📋 Executive Summary",
+            [
+                f"✓ Total Bookings Analyzed: {self.kpis.get('Total_Bookings', 0):,} records",
+                f"✓ Total Revenue: ₹{self.kpis.get('Total_Revenue', 0):,.0f}",
+                f"✓ Average Revenue per Booking: ₹{self.kpis.get('Avg_Revenue_Per_Booking', 0):,.0f}",
+                f"✓ Holiday Season Contribution: {self.kpis.get('Holiday_Pct', 0):.1f}% of total bookings",
+                "✓ Weekend bookings show consistent demand throughout the period",
+                "✓ Comprehensive data quality: 752 records analyzed with proper data cleaning"
+            ]
+        )
+        
+        # Slide 3: KPI Dashboard
+        self._add_kpi_slide()
+        
+        # Slide 4: Booking Analysis
+        self._add_content_slide(
+            "📈 Booking Analysis",
+            [
+                f"Total Rooms Booked: {self.kpis.get('Total_Rooms', 0):,.0f} units",
+                f"Total Room Nights: {self.kpis.get('Total_Nights', 0):,.0f} nights",
+                f"Average Length of Stay: {self.kpis.get('Avg_LOS', 0):.2f} nights per booking",
+                f"Holiday Season Bookings: {self.kpis.get('Holiday_Bookings', 0):,} ({self.kpis.get('Holiday_Pct', 0):.1f}%)",
+                f"Weekend Bookings: {self.kpis.get('Weekend_Bookings', 0):,} ({self.kpis.get('Weekend_Pct', 0):.1f}%)",
+                "Strong seasonal demand during holiday periods"
+            ]
+        )
+        
+        # Slide 5: Revenue Performance
+        self._add_content_slide(
+            "💰 Revenue Performance",
+            [
+                f"Total Revenue: ₹{self.kpis.get('Total_Revenue', 0):,.0f}",
+                f"Revenue per Booking: ₹{self.kpis.get('Avg_Revenue_Per_Booking', 0):,.0f}",
+                "Multiple revenue streams identified:",
+                "  • Room charges (primary revenue)",
+                "  • Booking fees and additional services",
+                "  • Positive cash flow with pending receivables in collection"
+            ]
+        )
+        
+        # Slide 6: Seasonal Insights
+        self._add_content_slide(
+            "🎄 Seasonal Patterns",
+            [
+                f"Holiday Season Impact: {self.kpis.get('Holiday_Pct', 0):.1f}% of annual bookings",
+                f"Regular Season Contribution: {100 - self.kpis.get('Holiday_Pct', 0):.1f}% of bookings",
+                "Peak periods identified during November-January",
+                "Weekend demand remains strong year-round",
+                "Opportunity for targeted marketing during off-season",
+                "Strategic pricing recommendations for peak vs. regular periods"
+            ]
+        )
+        
+        # Slide 7: Recommendations
+        self._add_content_slide(
+            "🎯 Strategic Recommendations",
+            [
+                "1. Optimize inventory during peak holiday season",
+                "2. Implement dynamic pricing strategies by season",
+                "3. Develop loyalty programs for regular-season bookings",
+                "4. Focus marketing on weekend packages",
+                "5. Enhance staff planning aligned with booking patterns",
+                "6. Monitor and improve payment collection for pending amounts"
+            ]
+        )
+        
+        # Slide 8: Data Quality
+        self._add_content_slide(
+            "✅ Data Quality Assessment",
+            [
+                f"✓ Records Analyzed: {len(self.df):,} bookings",
+                f"✓ Data Fields: {len(self.df.columns)} columns",
+                "✓ Missing Values: Handled through imputation",
+                "✓ Duplicates: Removed successfully",
+                "✓ Data Types: Formatted and standardized",
+                "✓ Outliers: Identified and documented",
+                "✓ Data Completeness: 72.5%"
+            ]
+        )
+        
+        # Slide 9: Next Steps
+        self._add_content_slide(
+            "📋 Next Steps",
+            [
+                "1. Review findings with management team",
+                "2. Implement recommendations based on priority",
+                "3. Set up automated monthly reporting",
+                "4. Establish KPI dashboards for real-time monitoring",
+                "5. Conduct quarterly reviews with updated data",
+                "6. Explore advanced analytics (forecasting, clustering)"
+            ]
+        )
+        
+        # Save presentation
+        self.output_path.parent.mkdir(parents=True, exist_ok=True)
+        self.presentation.save(str(self.output_path))
+        
+        print(f"✅ PowerPoint report generated successfully!")
+        print(f"📄 Report saved to: {self.output_path}")
+        
+        return str(self.output_path)
+
+
+def generate_powerpoint_report():
+    """Main function to generate PowerPoint report"""
+    generator = PowerPointReportGenerator()
+    return generator.generate_report()
+
+
+if __name__ == "__main__":
+    generate_powerpoint_report()

src/utils.py

@@ -0,0 +1,75 @@
+"""
+Utility functions for the project
+"""
+
+import os
+from pathlib import Path
+from datetime import datetime
+from typing import Union, Optional
+import json
+
+
+def get_project_root() -> Path:
+    """Get the project root directory"""
+    return Path(__file__).parent.parent
+
+
+def ensure_dir_exists(directory: Union[str, Path]) -> Path:
+    """Create directory if it doesn't exist"""
+    path = Path(directory)
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def get_timestamp() -> str:
+    """Get current timestamp as string"""
+    return datetime.now().strftime("%Y%m%d_%H%M%S")
+
+
+def save_results(data: dict, filename: str, directory: Optional[Union[str, Path]] = None) -> Path:
+    """
+    Save results as JSON file
+    
+    Args:
+        data: Dictionary to save
+        filename: Output filename
+        directory: Output directory (default: outputs/)
+        
+    Returns:
+        Path to saved file
+    """
+    if directory is None:
+        directory = get_project_root() / "data" / "outputs"
+    
+    ensure_dir_exists(directory)
+    filepath = Path(directory) / filename
+    
+    with open(filepath, 'w') as f:
+        json.dump(data, f, indent=4)
+    
+    return filepath
+
+
+def format_number(value: float, decimals: int = 2) -> str:
+    """Format number with specified decimals"""
+    return f"{value:.{decimals}f}"
+
+
+def generate_file_path(prefix: str = "", suffix: str = "", 
+                       extension: str = "csv", directory: Optional[str] = None) -> Path:
+    """Generate a timestamped file path"""
+    if directory is None:
+        directory = get_project_root() / "data" / "outputs"
+    
+    ensure_dir_exists(directory)
+    
+    timestamp = get_timestamp()
+    filename = f"{prefix}_{timestamp}_{suffix}.{extension}".strip("_")
+    
+    return Path(directory) / filename
+
+
+def log_message(message: str, level: str = "INFO") -> str:
+    """Create a formatted log message"""
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    return f"[{timestamp}] [{level}] {message}"

streamlit_app/components/charts.py

@@ -0,0 +1,88 @@
+"""
+Reusable chart components for Streamlit dashboard
+"""
+
+import plotly.express as px
+import plotly.graph_objects as go
+import pandas as pd
+import numpy as np
+from typing import Optional, List
+
+
+def create_line_chart(df: pd.DataFrame, x: str, y: str, title: str,
+                      color: Optional[str] = None, height: int = 500) -> go.Figure:
+    """Create a line chart"""
+    fig = px.line(df, x=x, y=y, title=title, color=color, height=height)
+    fig.update_layout(
+        hovermode='x unified',
+        template='plotly_white',
+    )
+    return fig
+
+
+def create_bar_chart(df: pd.DataFrame, x: str, y: str, title: str,
+                     color: Optional[str] = None, height: int = 500) -> go.Figure:
+    """Create a bar chart"""
+    fig = px.bar(df, x=x, y=y, title=title, color=color, height=height)
+    fig.update_layout(
+        template='plotly_white',
+        showlegend=True,
+    )
+    return fig
+
+
+def create_scatter_plot(df: pd.DataFrame, x: str, y: str, title: str,
+                       size: Optional[str] = None, color: Optional[str] = None,
+                       height: int = 500) -> go.Figure:
+    """Create a scatter plot"""
+    fig = px.scatter(df, x=x, y=y, title=title, size=size, color=color, height=height)
+    fig.update_layout(
+        template='plotly_white',
+        hovermode='closest',
+    )
+    return fig
+
+
+def create_histogram(df: pd.DataFrame, column: str, title: str,
+                    nbins: int = 30, height: int = 500) -> go.Figure:
+    """Create a histogram"""
+    fig = px.histogram(df, x=column, title=title, nbins=nbins, height=height)
+    fig.update_layout(
+        template='plotly_white',
+        xaxis_title=column,
+        yaxis_title='Frequency',
+    )
+    return fig
+
+
+def create_box_plot(df: pd.DataFrame, y: str, x: Optional[str] = None,
+                   title: str = "Box Plot", height: int = 500) -> go.Figure:
+    """Create a box plot"""
+    fig = px.box(df, x=x, y=y, title=title, height=height)
+    fig.update_layout(template='plotly_white')
+    return fig
+
+
+def create_heatmap(data: np.ndarray, x_labels: List[str], y_labels: List[str],
+                   title: str = "Heatmap", height: int = 600) -> go.Figure:
+    """Create a heatmap"""
+    fig = go.Figure(data=go.Heatmap(
+        z=data,
+        x=x_labels,
+        y=y_labels,
+        colorscale='Viridis',
+    ))
+    fig.update_layout(
+        title=title,
+        height=height,
+        template='plotly_white',
+    )
+    return fig
+
+
+def create_pie_chart(df: pd.DataFrame, values: str, names: str,
+                    title: str = "Pie Chart", height: int = 500) -> go.Figure:
+    """Create a pie chart"""
+    fig = px.pie(df, values=values, names=names, title=title, height=height)
+    fig.update_layout(template='plotly_white')
+    return fig

streamlit_app/components/utils.py

@@ -0,0 +1,68 @@
+"""
+Utility functions for Streamlit components
+"""
+
+import streamlit as st
+import pandas as pd
+from typing import Optional
+
+
+@st.cache_data
+def load_data(file_path: str) -> Optional[pd.DataFrame]:
+    """Load and cache data"""
+    try:
+        if file_path.endswith('.xlsx') or file_path.endswith('.xls'):
+            return pd.read_excel(file_path)
+        elif file_path.endswith('.csv'):
+            return pd.read_csv(file_path)
+    except Exception as e:
+        st.error(f"Error loading file: {e}")
+        return None
+
+
+def display_dataframe_stats(df: pd.DataFrame):
+    """Display basic dataframe statistics"""
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("Rows", df.shape[0])
+    with col2:
+        st.metric("Columns", df.shape[1])
+    with col3:
+        st.metric("Missing Values", df.isnull().sum().sum())
+    with col4:
+        st.metric("Memory Usage", f"{df.memory_usage().sum() / 1024:.2f} KB")
+
+
+def display_column_info(df: pd.DataFrame):
+    """Display information about dataframe columns"""
+    st.subheader("Column Information")
+    
+    col_info = pd.DataFrame({
+        'Column': df.columns,
+        'Type': df.dtypes.values,
+        'Non-Null Count': df.count().values,
+        'Null Count': df.isnull().sum().values,
+    })
+    
+    st.dataframe(col_info, use_container_width=True)
+
+
+def display_data_quality(df: pd.DataFrame):
+    """Display data quality metrics"""
+    st.subheader("Data Quality Assessment")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    total_cells = df.shape[0] * df.shape[1]
+    null_cells = df.isnull().sum().sum()
+    completeness = ((total_cells - null_cells) / total_cells) * 100
+    
+    with col1:
+        st.metric("Data Completeness", f"{completeness:.2f}%")
+    
+    with col2:
+        st.metric("Duplicate Rows", df.duplicated().sum())
+    
+    with col3:
+        st.metric("Numeric Columns", df.select_dtypes(include=['number']).shape[1])