I'll create a comprehensive Python script that analyzes your e-commerce transaction data for seasonal trends and anomalies. Here's a complete solution:

"""
E-commerce Transaction Analysis Script
Analyzes seasonal trends and detects revenue anomalies
"""

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
import warnings
warnings.filterwarnings('ignore')

# For anomaly detection
from sklearn.ensemble import IsolationForest
from scipy import stats
import calendar

# Set style for visualizations
plt.style.use('seaborn-v0_8-darkgrid')
sns.set_palette("husl")

def load_and_prepare_data(file_path):
    """
    Load and prepare transaction data
    """
    print("Loading data...")
    df = pd.read_csv(file_path)
    
    # Ensure timestamp is datetime
    if 'timestamp' in df.columns:
        df['timestamp'] = pd.to_datetime(df['timestamp'])
    elif 'date' in df.columns:
        df['timestamp'] = pd.to_datetime(df['date'])
    elif 'order_date' in df.columns:
        df['timestamp'] = pd.to_datetime(df['order_date'])
    
    # Create time-based features
    df['date'] = df['timestamp'].dt.date
    df['year'] = df['timestamp'].dt.year
    df['month'] = df['timestamp'].dt.month
    df['month_name'] = df['timestamp'].dt.strftime('%B')
    df['quarter'] = df['timestamp'].dt.quarter
    df['day_of_week'] = df['timestamp'].dt.dayofweek
    df['day_name'] = df['timestamp'].dt.strftime('%A')
    df['week_of_year'] = df['timestamp'].dt.isocalendar().week
    df['hour'] = df['timestamp'].dt.hour
    
    print(f"Data loaded: {len(df)} rows, {len(df.columns)} columns")
    print(f"Date range: {df['timestamp'].min()} to {df['timestamp'].max()}")
    
    return df

def create_daily_summary(df):
    """
    Create daily revenue and transaction summary
    """
    print("\nCreating daily summary...")
    
    # Daily revenue aggregation
    daily_revenue = df.groupby('date').agg({
        'revenue': 'sum',
        'timestamp': 'count'
    }).rename(columns={'timestamp': 'transaction_count'})
    
    # Add rolling statistics for trend analysis
    daily_revenue['7_day_avg'] = daily_revenue['revenue'].rolling(window=7, center=True).mean()
    daily_revenue['30_day_avg'] = daily_revenue['revenue'].rolling(window=30, center=True).mean()
    daily_revenue['revenue_std'] = daily_revenue['revenue'].rolling(window=30).std()
    
    # Add percentage change
    daily_revenue['daily_pct_change'] = daily_revenue['revenue'].pct_change() * 100
    daily_revenue['weekly_pct_change'] = daily_revenue['revenue'].pct_change(periods=7) * 100
    
    # Add day of week
    daily_revenue['day_of_week'] = pd.to_datetime(daily_revenue.index).dayofweek
    daily_revenue['day_name'] = pd.to_datetime(daily_revenue.index).strftime('%A')
    
    return daily_revenue

def detect_revenue_anomalies(daily_revenue):
    """
    Detect anomalies in daily revenue using multiple methods
    """
    print("\nDetecting revenue anomalies...")
    
    revenue_series = daily_revenue['revenue'].dropna()
    
    # Method 1: Z-score method
    z_scores = np.abs(stats.zscore(revenue_series))
    z_score_threshold = 3
    z_anomalies = revenue_series[z_scores > z_score_threshold]
    
    # Method 2: Isolation Forest
    iso_forest = IsolationForest(contamination=0.05, random_state=42)
    iso_labels = iso_forest.fit_predict(revenue_series.values.reshape(-1, 1))
    iso_anomalies = revenue_series[iso_labels == -1]
    
    # Method 3: IQR method
    Q1 = revenue_series.quantile(0.25)
    Q3 = revenue_series.quantile(0.75)
    IQR = Q3 - Q1
    iqr_anomalies = revenue_series[(revenue_series < (Q1 - 1.5 * IQR)) | 
                                   (revenue_series > (Q3 + 1.5 * IQR))]
    
    # Combine all anomalies
    all_anomalies = set(z_anomalies.index) | set(iso_anomalies.index) | set(iqr_anomalies.index)
    
    anomalies_df = daily_revenue.loc[list(all_anomalies)]
    anomalies_df['anomaly_type'] = 'Revenue'
    anomalies_df['detection_method'] = 'Multiple'
    
    print(f"Detected {len(anomalies_df)} anomalous days")
    
    return anomalies_df, z_anomalies, iso_anomalies, iqr_anomalies

def analyze_seasonal_trends(df, daily_revenue):
    """
    Analyze seasonal purchasing patterns
    """
    print("\nAnalyzing seasonal trends...")
    
    seasonal_analysis = {}
    
    # Monthly trends
    monthly_revenue = df.groupby(['year', 'month']).agg({
        'revenue': ['sum', 'mean', 'count']
    }).round(2)
    monthly_revenue.columns = ['total_revenue', 'avg_order_value', 'transaction_count']
    seasonal_analysis['monthly'] = monthly_revenue
    
    # Quarterly trends
    quarterly_revenue = df.groupby(['year', 'quarter']).agg({
        'revenue': ['sum', 'mean', 'count']
    }).round(2)
    quarterly_revenue.columns = ['total_revenue', 'avg_order_value', 'transaction_count']
    seasonal_analysis['quarterly'] = quarterly_revenue
    
    # Day of week patterns
    dow_revenue = df.groupby('day_name').agg({
        'revenue': ['sum', 'mean', 'count']
    }).round(2)
    dow_revenue.columns = ['total_revenue', 'avg_order_value', 'transaction_count']
    # Reorder days
    day_order = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
    dow_revenue = dow_revenue.reindex(day_order)
    seasonal_analysis['day_of_week'] = dow_revenue
    
    # Hourly patterns (if available)
    if 'hour' in df.columns:
        hourly_revenue = df.groupby('hour').agg({
            'revenue': ['sum', 'mean', 'count']
        }).round(2)
        hourly_revenue.columns = ['total_revenue', 'avg_order_value', 'transaction_count']
        seasonal_analysis['hourly'] = hourly_revenue
    
    # Category trends by month
    if 'product_category' in df.columns:
        category_monthly = df.groupby(['product_category', 'month']).agg({
            'revenue': 'sum',
            'timestamp': 'count'
        }).rename(columns={'timestamp': 'count'}).round(2)
        seasonal_analysis['category_monthly'] = category_monthly
    
    return seasonal_analysis

def create_visualizations(df, daily_revenue, anomalies_df, seasonal_analysis):
    """
    Generate all visualizations
    """
    print("\nCreating visualizations...")
    
    # Create figure with subplots
    fig = plt.figure(figsize=(20, 16))
    
    # 1. Daily Revenue with Anomalies
    ax1 = plt.subplot(3, 3, 1)
    ax1.plot(daily_revenue.index, daily_revenue['revenue'], 
             label='Daily Revenue', alpha=0.7, linewidth=1)
    ax1.plot(daily_revenue.index, daily_revenue['7_day_avg'], 
             label='7-Day Avg', color='red', linewidth=2)
    ax1.scatter(anomalies_df.index, anomalies_df['revenue'], 
                color='red', s=50, zorder=5, label='Anomalies')
    ax1.set_title('Daily Revenue with Anomalies')
    ax1.set_xlabel('Date')
    ax1.set_ylabel('Revenue')
    ax1.legend()
    ax1.grid(True, alpha=0.3)
    
    # 2. Monthly Revenue Trend
    ax2 = plt.subplot(3, 3, 2)
    monthly_revenue = seasonal_analysis['monthly']['total_revenue'].unstack(level=0)
    monthly_revenue.plot(kind='bar', ax=ax2, width=0.8)
    ax2.set_title('Monthly Revenue by Year')
    ax2.set_xlabel('Month')
    ax2.set_ylabel('Revenue')
    ax2.legend(title='Year')
    plt.xticks(rotation=45)
    
    # 3. Day of Week Pattern
    ax3 = plt.subplot(3, 3, 3)
    dow_data = seasonal_analysis['day_of_week']
    dow_data['total_revenue'].plot(kind='bar', ax=ax3, color='skyblue')
    ax3.set_title('Revenue by Day of Week')
    ax3.set_xlabel('Day')
    ax3.set_ylabel('Revenue')
    plt.xticks(rotation=45)
    
    # 4. Quarterly Revenue
    ax4 = plt.subplot(3, 3, 4)
    quarterly_data = seasonal_analysis['quarterly']['total_revenue'].unstack(level=0)
    quarterly_data.plot(kind='line', marker='o', ax=ax4, linewidth=2)
    ax4.set_title('Quarterly Revenue Trend')
    ax4.set_xlabel('Quarter')
    ax4.set_ylabel('Revenue')
    ax4.legend(title='Year')
    
    # 5. Revenue Distribution
    ax5 = plt.subplot(3, 3, 5)
    ax5.hist(daily_revenue['revenue'].dropna(), bins=50, alpha=0.7, color='green', edgecolor='black')
    ax5.axvline(daily_revenue['revenue'].mean(), color='red', linestyle='--', 
                label=f'Mean: ${daily_revenue["revenue"].mean():,.2f}')
    ax5.axvline(daily_revenue['revenue'].median(), color='blue', linestyle='--', 
                label=f'Median: ${daily_revenue["revenue"].median():,.2f}')
    ax5.set_title('Daily Revenue Distribution')
    ax5.set_xlabel('Revenue')
    ax5.set_ylabel('Frequency')
    ax5.legend()
    
    # 6. Moving Average Comparison
    ax6 = plt.subplot(3, 3, 6)
    ax6.plot(daily_revenue.index, daily_revenue['revenue'], label='Daily', alpha=0.5)
    ax6.plot(daily_revenue.index, daily_revenue['7_day_avg'], label='7-Day MA', linewidth=2)
    ax6.plot(daily_revenue.index, daily_revenue['30_day_avg'], label='30-Day MA', linewidth=2)
    ax6.set_title('Moving Average Comparison')
    ax6.set_xlabel('Date')
    ax6.set_ylabel('Revenue')
    ax6.legend()
    ax6.grid(True, alpha=0.3)
    
    # 7. Percentage Change
    ax7 = plt.subplot(3, 3, 7)
    daily_revenue['daily_pct_change'].dropna().plot(ax=ax7, alpha=0.7)
    ax7.axhline(y=0, color='r', linestyle='-', alpha=0.3)
    ax7.set_title('Daily Revenue Percentage Change')
    ax7.set_xlabel('Date')
    ax7.set_ylabel('% Change')
    ax7.grid(True, alpha=0.3)
    
    # 8. Category Analysis (if available)
    if 'product_category' in df.columns:
        ax8 = plt.subplot(3, 3, 8)
        top_categories = df.groupby('product_category')['revenue'].sum().nlargest(10)
        top_categories.plot(kind='barh', ax=ax8, color='purple')
        ax8.set_title('Top 10 Categories by Revenue')
        ax8.set_xlabel('Total Revenue')
        ax8.invert_yaxis()
    
    # 9. Anomaly Timeline
    ax9 = plt.subplot(3, 3, 9)
    anomaly_dates = pd.to_datetime(anomalies_df.index)
    ax9.eventplot(anomaly_dates, orientation='horizontal', colors='red')
    ax9.set_title('Anomaly Timeline')
    ax9.set_xlabel('Date')
    ax9.set_yticks([])
    
    plt.tight_layout()
    plt.savefig('ecommerce_analysis_report.png', dpi=150, bbox_inches='tight')
    print("Visualizations saved as 'ecommerce_analysis_report.png'")
    
    # Create additional detailed visualizations
    create_detailed_visualizations(df, daily_revenue, seasonal_analysis)

def create_detailed_visualizations(df, daily_revenue, seasonal_analysis):
    """
    Create additional detailed visualizations
    """
    fig, axes = plt.subplots(2, 2, figsize=(15, 10))
    
    # 1. Heatmap of daily patterns
    if 'hour' in df.columns:
        hourly_pivot = df.pivot_table(values='revenue', 
                                      index='hour', 
                                      columns='day_name', 
                                      aggfunc='sum')
        sns.heatmap(hourly_pivot, cmap='YlOrRd', ax=axes[0,0])
        axes[0,0].set_title('Revenue Heatmap: Hour vs Day of Week')
    
    # 2. Boxplot by day of week
    daily_revenue['day_name'] = pd.Categorical(daily_revenue['day_name'], 
                                                categories=['Monday', 'Tuesday', 'Wednesday', 
                                                          'Thursday', 'Friday', 'Saturday', 'Sunday'])
    sns.boxplot(x='day_name', y='revenue', data=daily_revenue.reset_index(), ax=axes[0,1])
    axes[0,1].set_title('Revenue Distribution by Day of Week')
    axes[0,1].set_xlabel('Day of Week')
    axes[0,1].set_ylabel('Revenue')
    plt.setp(axes[0,1].xaxis.get_majorticklabels(), rotation=45)
    
    # 3. Cumulative revenue
    axes[1,0].plot(daily_revenue.index, daily_revenue['revenue'].cumsum(), linewidth=2)
    axes[1,0].set_title('Cumulative Revenue Over Time')
    axes[1,0].set_xlabel('Date')
    axes[1,0].set_ylabel('Cumulative Revenue')
    axes[1,0].grid(True, alpha=0.3)
    
    # 4. Monthly comparison (if multiple years)
    if 'year' in df.columns and df['year'].nunique() > 1:
        monthly_comparison = df.groupby(['month', 'year'])['revenue'].sum().unstack()
        monthly_comparison.plot(kind='line', marker='o', ax=axes[1,1])
        axes[1,1].set_title('Monthly Revenue Year-over-Year Comparison')
        axes[1,1].set_xlabel('Month')
        axes[1,1].set_ylabel('Revenue')
        axes[1,1].legend(title='Year')
    
    plt.tight_layout()
    plt.savefig('detailed_analysis.png', dpi=150, bbox_inches='tight')
    print("Detailed visualizations saved as 'detailed_analysis.png'")

def generate_summary_report(df, daily_revenue, anomalies_df, seasonal_analysis):
    """
    Generate a comprehensive text summary report
    """
    print("\n" + "="*60)
    print("E-COMMERCE TRANSACTION ANALYSIS REPORT")
    print("="*60)
    
    # Basic statistics
    total_revenue = df['revenue'].sum()
    avg_daily_revenue = daily_revenue['revenue'].mean()
    median_daily_revenue = daily_revenue['revenue'].median()
    std_daily_revenue = daily_revenue['revenue'].std()
    total_transactions = len(df)
    avg_order_value = df['revenue'].mean()
    
    print(f"\n1. OVERALL PERFORMANCE")
    print(f"   Total Revenue: ${total_revenue:,.2f}")
    print(f"   Total Transactions: {total_transactions:,}")
    print(f"   Average Order Value: ${avg_order_value:.2f}")
    print(f"   Average Daily Revenue: ${avg_daily_revenue:,.2f}")
    print(f"   Median Daily Revenue: ${median_daily_revenue:,.2f}")
    print(f"   Daily Revenue Std Dev: ${std_daily_revenue:,.2f}")
    
    print(f"\n2. ANOMALY DETECTION")
    print(f"   Total Anomalous Days: {len(anomalies_df)}")
    print(f"   Anomaly Percentage: {(len(anomalies_df)/len(daily_revenue)*100):.1f}%")
    
    if len(anomalies_df) > 0:
        print(f"   Top 5 Highest Revenue Anomalies:")
        top_anomalies = anomalies_df.nlargest(5, 'revenue')
        for idx, (date, row) in enumerate(top_anomalies.iterrows(), 1):
            print(f"     {idx}. {date}: ${row['revenue']:,.2f}")
    
    print(f"\n3. SEASONAL TRENDS")
    
    # Best performing months
    monthly_summary = seasonal_analysis['monthly']['total_revenue'].groupby('month').mean()
    best_month_idx = monthly_summary.idxmax()
    best_month_name = calendar.month_name[best_month_idx]
    print(f"   Best Performing Month: {best_month_name} (${monthly_summary.max():,.2f} avg)")
    
    # Best performing day of week
    best_day = seasonal_analysis['day_of_week']['total_revenue'].idxmax()
    print(f"   Best Performing Day: {best_day}")
    
    # Quarterly performance
    quarterly_summary = seasonal_analysis['quarterly']['total_revenue'].groupby('quarter').mean()
    best_quarter = quarterly_summary.idxmax()
    print(f"   Best Performing Quarter: Q{best_quarter} (${quarterly_summary.max():,.2f} avg)")
    
    print(f"\n4. RECOMMENDATIONS")
    
    recommendations = []
    
    # Analyze anomalies
    if len(anomalies_df) > 5:
        recommendations.append("• Investigate frequent revenue anomalies for potential issues")
    
    # Analyze seasonality
    monthly_std = monthly_summary.std() / monthly_summary.mean()
    if monthly_std > 0.3:
        recommendations.append("• Significant monthly seasonality detected - consider inventory planning")
    
    # Day of week analysis
    dow_ratio = seasonal_analysis['day_of_week']['total_revenue'].max() / \
                seasonal_analysis['day_of_week']['total_revenue'].min()
    if dow_ratio > 2:
        recommendations.append("• Large day-of-week variations - optimize marketing for low-performing days")
    
    # Add general recommendations
    recommendations.extend([
        "• Monitor daily revenue for deviations from 7-day moving average",
        "• Review top-performing categories for expansion opportunities",
        "• Plan promotions around identified peak seasons"
    ])
    
    for i, rec in enumerate(recommendations, 1):
        print(f"   {i}. {rec}")
    
    # Save report to file
    with open('analysis_summary.txt', 'w') as f:
        f.write("="*60 + "\n")
        f.write("E-COMMERCE TRANSACTION ANALYSIS REPORT\n")
        f.write("="*60 + "\n\n")
        f.write(f"1. OVERALL PERFORMANCE\n")
        f.write(f"   Total Revenue: ${total_revenue:,.2f}\n")
        f.write(f"   Total Transactions: {total_transactions:,}\n")
        f.write(f"   Average Order Value: ${avg_order_value:.2f}\n")
        f.write(f"   Average Daily Revenue: ${avg_daily_revenue:,.2f}\n\n")
        
        f.write(f"2. ANOMALY DETECTION\n")
        f.write(f"   Total Anomalous Days: {len(anomalies_df)}\n")
        
        f.write(f"\n3. SEASONAL TRENDS\n")
        f.write(f"   Best Performing Month: {best_month_name}\n")
        f.write(f"   Best Performing Day: {best_day}\n")
        f.write(f"   Best Performing Quarter: Q{best_quarter}\n")
        
        f.write(f"\n4. RECOMMENDATIONS\n")
        for rec in recommendations:
            f.write(f"   • {rec}\n")
    
    print(f"\n" + "="*60)
    print(f"Summary report saved as 'analysis_summary.txt'")
    print(f"Visualizations saved as PNG files")
    print("="*60)

def save_analysis_results(df, daily_revenue, anomalies_df, seasonal_analysis):
    """
    Save all analysis results to CSV files
    """
    print("\nSaving analysis results...")
    
    # Save daily summary
    daily_revenue.to_csv('daily_revenue_summary.csv')
    
    # Save anomalies
    anomalies_df.to_csv('detected_anomalies.csv')
    
    # Save monthly trends
    seasonal_analysis['monthly'].to_csv('monthly_trends.csv')
    
    # Save quarterly trends
    seasonal_analysis['quarterly'].to_csv('quarterly_trends.csv')
    
    # Save day of week patterns
    seasonal_analysis['day_of_week'].to_csv('day_of_week_patterns.csv')
    
    print("Analysis results saved as CSV files")

def main():
    """
    Main execution function
    """
    # Update this path to your CSV file
    csv_file_path = 'ecommerce_transactions.csv'  # Change this to your file path
    
    try:
        # Step 1: Load and prepare data
        df = load_and_prepare_data(csv_file_path)
        
        # Step 2: Create daily summary
        daily_revenue = create_daily_summary(df)
        
        # Step 3: Detect anomalies
        anomalies_df, z_anomalies, iso_anomalies, iqr_anomalies = detect_revenue_anomalies(daily_revenue)
        
        # Step 4: Analyze seasonal trends
        seasonal_analysis = analyze_seasonal_trends(df, daily_revenue)
        
        # Step 5: Create visualizations
        create_visualizations(df, daily_revenue, anomalies_df, seasonal_analysis)
        
        # Step 6: Generate summary report
        generate_summary_report(df, daily_revenue, anomalies_df, seasonal_analysis)
        
        # Step 7: Save results
        save_analysis_results(df, daily_revenue, anomalies_df, seasonal_analysis)
        
        print("\nAnalysis completed successfully!")
        
    except FileNotFoundError:
        print(f"Error: File '{csv_file_path}' not found.")
        print("Please update the csv_file_path variable with your actual file path.")
    except Exception as e:
        print(f"Error during analysis: {str(e)}")
        import traceback
        traceback.print_exc()

if __name__ == "__main__":
    main()

Key Features of the Script:

1. Data Processing:

• Loads CSV with timestamp conversion
• Creates time-based features (year, month, quarter, day of week, etc.)
• Handles missing data gracefully

2. Anomaly Detection:

• Uses three methods: Z-score, Isolation Forest, and IQR
• Identifies unusual revenue days
• Flags both high and low anomalies

3. Seasonal Analysis:

• Monthly, quarterly, and daily patterns
• Day-of-week and hourly analysis
• Category-based seasonality (if category data exists)

4. Visualizations:

• Daily revenue with anomalies highlighted
• Monthly and quarterly trends
• Revenue distribution
• Moving averages
• Percentage changes
• Category analysis
• Heatmaps for time patterns

5. Outputs Generated:

• PNG files: ecommerce_analysis_report.png, detailed_analysis.png
• CSV files: Daily summaries, anomalies, trends
• Text report: analysis_summary.txt with key findings

Usage Instructions:

1. Install required packages:

pip install pandas numpy matplotlib seaborn scikit-learn scipy

2. Update the file path in the main() function (line ~360):

csv_file_path = 'path/to/your/ecommerce_transactions.csv'

3. Run the script:

python ecommerce_analysis.py

Expected CSV Columns:

The script expects your CSV to have at minimum:

• timestamp (or date/order_date) - datetime column
• revenue - numeric column for transaction value

Optional but recommended:

• product_category - for category analysis
• Other transaction details

Customization Options:

You can modify these parameters in the script:

• z_score_threshold in detect_revenue_anomalies() for sensitivity
• Window sizes for moving averages
• Visualization colors and styles
• Contamination rate in Isolation Forest

The script will handle 50,000 rows efficiently and provide both visual and text-based insights into your e-commerce trends and anomalies.

E-Commerce Transaction Analysis Script

#!/usr/bin/env python3
"""
E-Commerce Transaction Analysis
Identifies seasonal trends, detects revenue anomalies, and generates visual reports.
"""

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime
from scipy import stats
import warnings
import os
from typing import Tuple, Dict, Optional
import json

warnings.filterwarnings('ignore')
sns.set_style('whitegrid')
plt.rcParams['figure.figsize'] = (12, 6)


class ECommerceAnalyzer:
    """Comprehensive e-commerce transaction analyzer."""
    
    def __init__(self, csv_path: str, output_dir: str = 'analysis_output'):
        """
        Initialize the analyzer.
        
        Args:
            csv_path: Path to the CSV file
            output_dir: Directory for saving outputs
        """
        self.csv_path = csv_path
        self.output_dir = output_dir
        self.df = None
        self.daily_revenue = None
        self.anomalies = None
        self.seasonal_patterns = {}
        
        os.makedirs(output_dir, exist_ok=True)
    
    def load_data(self) -> pd.DataFrame:
        """Load and validate the CSV data."""
        print("Loading data...")
        
        try:
            self.df = pd.read_csv(self.csv_path)
            
            # Required columns
            required_cols = ['timestamp', 'product_category', 'revenue']
            missing_cols = [col for col in required_cols if col not in self.df.columns]
            
            if missing_cols:
                raise ValueError(f"Missing required columns: {missing_cols}")
            
            # Convert timestamp to datetime
            self.df['timestamp'] = pd.to_datetime(self.df['timestamp'], errors='coerce')
            
            # Remove invalid rows
            initial_rows = len(self.df)
            self.df = self.df.dropna(subset=['timestamp', 'revenue'])
            self.df = self.df[self.df['revenue'] >= 0]
            
            print(f"Loaded {len(self.df):,} valid rows (removed {initial_rows - len(self.df):,} invalid)")
            
            return self.df
            
        except Exception as e:
            print(f"Error loading data: {e}")
            raise
    
    def preprocess_data(self) -> None:
        """Add time-based features for analysis."""
        print("Preprocessing data...")
        
        self.df['date'] = self.df['timestamp'].dt.date
        self.df['year'] = self.df['timestamp'].dt.year
        self.df['month'] = self.df['timestamp'].dt.month
        self.df['week'] = self.df['timestamp'].dt.isocalendar().week
        self.df['day_of_week'] = self.df['timestamp'].dt.dayofweek
        self.df['hour'] = self.df['timestamp'].dt.hour
        self.df['day_of_month'] = self.df['timestamp'].dt.day
        self.df['quarter'] = self.df['timestamp'].dt.quarter
        
        # Aggregate daily revenue
        self.daily_revenue = self.df.groupby('date').agg({
            'revenue': ['sum', 'mean', 'std', 'count']
        }).reset_index()
        
        self.daily_revenue.columns = ['date', 'total_revenue', 'avg_revenue', 
                                       'std_revenue', 'transaction_count']
        self.daily_revenue['date'] = pd.to_datetime(self.daily_revenue['date'])
        
        print(f"Aggregated data into {len(self.daily_revenue):,} daily records")
    
    def analyze_seasonal_trends(self) -> Dict:
        """Identify seasonal purchasing patterns."""
        print("Analyzing seasonal trends...")
        
        # Monthly trends
        monthly = self.df.groupby(['year', 'month']).agg({
            'revenue': ['sum', 'mean'],
            'timestamp': 'count'
        }).reset_index()
        monthly.columns = ['year', 'month', 'total_revenue', 'avg_revenue', 'transaction_count']
        
        # Weekly trends (day of week)
        weekly = self.df.groupby('day_of_week').agg({
            'revenue': ['sum', 'mean'],
            'timestamp': 'count'
        }).reset_index()
        weekly.columns = ['day_of_week', 'total_revenue', 'avg_revenue', 'transaction_count']
        
        # Hourly trends
        hourly = self.df.groupby('hour').agg({
            'revenue': ['sum', 'mean'],
            'timestamp': 'count'
        }).reset_index()
        hourly.columns = ['hour', 'total_revenue', 'avg_revenue', 'transaction_count']
        
        # Category trends by month
        category_monthly = self.df.groupby(['month', 'product_category']).agg({
            'revenue': 'sum'
        }).reset_index()
        
        # Quarter trends
        quarterly = self.df.groupby('quarter').agg({
            'revenue': ['sum', 'mean'],
            'timestamp': 'count'
        }).reset_index()
        quarterly.columns = ['quarter', 'total_revenue', 'avg_revenue', 'transaction_count']
        
        self.seasonal_patterns = {
            'monthly': monthly,
            'weekly': weekly,
            'hourly': hourly,
            'category_monthly': category_monthly,
            'quarterly': quarterly
        }
        
        return self.seasonal_patterns
    
    def detect_anomalies(self, method: str = 'zscore', threshold: float = 3.0) -> pd.DataFrame:
        """
        Detect anomalies in daily revenue.
        
        Args:
            method: 'zscore' or 'iqr'
            threshold: Threshold for anomaly detection
            
        Returns:
            DataFrame with anomaly flags
        """
        print(f"Detecting anomalies using {method} method...")
        
        daily = self.daily_revenue.copy()
        
        if method == 'zscore':
            # Z-score method
            daily['zscore'] = np.abs(stats.zscore(daily['total_revenue']))
            daily['is_anomaly'] = daily['zscore'] > threshold
            
        elif method == 'iqr':
            # IQR method
            Q1 = daily['total_revenue'].quantile(0.25)
            Q3 = daily['total_revenue'].quantile(0.75)
            IQR = Q3 - Q1
            lower_bound = Q1 - threshold * IQR
            upper_bound = Q3 + threshold * IQR
            
            daily['is_anomaly'] = (daily['total_revenue'] < lower_bound) | \
                                 (daily['total_revenue'] > upper_bound)
            daily['zscore'] = np.abs(stats.zscore(daily['total_revenue']))
        
        else:
            raise ValueError("Method must be 'zscore' or 'iqr'")
        
        self.anomalies = daily[daily['is_anomaly']].copy()
        
        print(f"Detected {len(self.anomalies):,} anomalous days ({len(self.anomalies)/len(daily)*100:.2f}%)")
        
        return daily
    
    def create_visualizations(self) -> None:
        """Generate all visualizations."""
        print("Creating visualizations...")
        
        # 1. Daily Revenue Trend with Anomalies
        self._plot_daily_revenue()
        
        # 2. Monthly Revenue Pattern
        self._plot_monthly_trends()
        
        # 3. Weekly Pattern
        self._plot_weekly_pattern()
        
        # 4. Hourly Pattern
        self._plot_hourly_pattern()
        
        # 5. Category Performance
        self._plot_category_performance()
        
        # 6. Quarterly Comparison
        self._plot_quarterly_comparison()
        
        # 7. Anomaly Distribution
        self._plot_anomaly_distribution()
        
        # 8. Revenue Heatmap (Month vs Day of Week)
        self._plot_revenue_heatmap()
        
        print(f"Visualizations saved to {self.output_dir}/")
    
    def _plot_daily_revenue(self) -> None:
        """Plot daily revenue with highlighted anomalies."""
        fig, ax = plt.subplots(figsize=(14, 7))
        
        ax.plot(self.daily_revenue['date'], self.daily_revenue['total_revenue'], 
                label='Daily Revenue', linewidth=1, alpha=0.7)
        
        # Highlight anomalies
        anomalies = self.daily_revenue[self.daily_revenue['is_anomaly']]
        ax.scatter(anomalies['date'], anomalies['total_revenue'], 
                   c='red', s=100, label='Anomalies', zorder=5, alpha=0.8)
        
        # Add moving average
        self.daily_revenue['rolling_avg'] = self.daily_revenue['total_revenue'].rolling(window=7).mean()
        ax.plot(self.daily_revenue['date'], self.daily_revenue['rolling_avg'], 
                label='7-Day Moving Average', linewidth=2, color='green')
        
        ax.set_xlabel('Date', fontsize=12)
        ax.set_ylabel('Revenue ($)', fontsize=12)
        ax.set_title('Daily Revenue Trend with Anomalies', fontsize=14, fontweight='bold')
        ax.legend()
        ax.grid(True, alpha=0.3)
        plt.xticks(rotation=45)
        plt.tight_layout()
        plt.savefig(f'{self.output_dir}/01_daily_revenue.png', dpi=300, bbox_inches='tight')
        plt.close()
    
    def _plot_monthly_trends(self) -> None:
        """Plot monthly revenue trends."""
        monthly = self.seasonal_patterns['monthly']
        
        fig, axes = plt.subplots(2, 1, figsize=(14, 10))
        
        # Total revenue by month
        ax1 = axes[0]
        monthly_pivot = monthly.pivot(index='year', columns='month', values='total_revenue')
        sns.heatmap(monthly_pivot, annot=True, fmt='.0f', cmap='YlOrRd', ax=ax1, 
                    cbar_kws={'label': 'Revenue ($)'})
        ax1.set_xlabel('Month', fontsize=12)
        ax1.set_ylabel('Year', fontsize=12)
        ax1.set_title('Monthly Revenue Heatmap', fontsize=14, fontweight='bold')
        
        # Average revenue by month (aggregated across years)
        ax2 = axes[1]
        monthly_avg = monthly.groupby('month')['avg_revenue'].mean()
        months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 
                  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
        
        bars = ax2.bar(months, monthly_avg.values, color='steelblue', alpha=0.7)
        ax2.set_xlabel('Month', fontsize=12)
        ax2.set_ylabel('Average Revenue ($)', fontsize=12)
        ax2.set_title('Average Monthly Revenue Pattern', fontsize=14, fontweight='bold')
        ax2.grid(True, alpha=0.3)
        
        # Add value labels
        for bar, val in zip(bars, monthly_avg.values):
            ax2.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 50, 
                    f'${val:,.0f}', ha='center', fontsize=9)
        
        plt.tight_layout()
        plt.savefig(f'{self.output_dir}/02_monthly_trends.png', dpi=300, bbox_inches='tight')
        plt.close()
    
    def _plot_weekly_pattern(self) -> None:
        """Plot day-of-week revenue patterns."""
        weekly = self.seasonal_patterns['weekly']
        days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
        
        fig, axes = plt.subplots(1, 2, figsize=(14, 6))
        
        # Total revenue by day
        ax1 = axes[0]
        bars1 = ax1.bar(days, weekly['total_revenue'], color='coral', alpha=0.7)
        ax1.set_xlabel('Day of Week', fontsize=12)
        ax1.set_ylabel('Total Revenue ($)', fontsize=12)
        ax1.set_title('Total Revenue by Day of Week', fontsize=14, fontweight='bold')
        ax1.tick_params(axis='x', rotation=45)
        ax1.grid(True, alpha=0.3)
        
        # Average revenue by day
        ax2 = axes[1]
        bars2 = ax2.bar(days, weekly['avg_revenue'], color='teal', alpha=0.7)
        ax2.set_xlabel('Day of Week', fontsize=12)
        ax2.set_ylabel('Average Revenue ($)', fontsize=12)
        ax2.set_title('Average Revenue by Day of Week', fontsize=14, fontweight='bold')
        ax2.tick_params(axis='x', rotation=45)
        ax2.grid(True, alpha=0.3)
        
        plt.tight_layout()
        plt.savefig(f'{self.output_dir}/03_weekly_pattern.png', dpi=300, bbox_inches='tight')
        plt.close()
    
    def _plot_hourly_pattern(self) -> None:
        """Plot hourly revenue patterns."""
        hourly = self.seasonal_patterns['hourly']
        
        fig, ax = plt.subplots(figsize=(14, 6))
        
        bars = ax.bar(hourly['hour'], hourly['total_revenue'], color='mediumseagreen', alpha=0.7)
        ax.set_xlabel('Hour of Day', fontsize=12)
        ax.set_ylabel('Total Revenue ($)', fontsize=12)
        ax.set_title('Revenue Distribution by Hour', fontsize=14, fontweight='bold')
        ax.grid(True, alpha=0.3)
        ax.set_xticks(range(0, 24, 2))
        
        plt.tight_layout()
        plt.savefig(f'{self.output_dir}/04_hourly_pattern.png', dpi=300, bbox_inches='tight')
        plt.close()
    
    def _plot_category_performance(self) -> None:
        """Plot product category performance."""
        category_stats = self.df.groupby('product_category').agg({
            'revenue': ['sum', 'mean', 'count']
        }).reset_index()
        category_stats.columns = ['category', 'total_revenue', 'avg_revenue', 'transaction_count']
        category_stats = category_stats.sort_values('total_revenue', ascending=True)
        
        fig, ax = plt.subplots(figsize=(10, 8))
        
        bars = ax.barh(category_stats['category'], category_stats['total_revenue'], 
                       color='slateblue', alpha=0.7)
        ax.set_xlabel('Total Revenue ($)', fontsize=12)
        ax.set_ylabel('Product Category', fontsize=12)
        ax.set_title('Revenue by Product Category', fontsize=14, fontweight='bold')
        ax.grid(True, alpha=0.3)
        
        # Add value labels
        for bar, val in zip(bars, category_stats['total_revenue']):
            ax.text(bar.get_width() + 500, bar.get_y() + bar.get_height()/2, 
                   f'${val:,.0f}', va='center', fontsize=9)
        
        plt.tight_layout()
        plt.savefig(f'{self.output_dir}/05_category_performance.png', dpi=300, bbox_inches='tight')
        plt.close()
    
    def _plot_quarterly_comparison(self) -> None:
        """Plot quarterly revenue comparison."""
        quarterly = self.seasonal_patterns['quarterly']
        quarters = ['Q1', 'Q2', 'Q3', 'Q4']
        
        fig, axes = plt.subplots(1, 2, figsize=(14, 6))
        
        # Total revenue by quarter
        ax1 = axes[0]
        bars1 = ax1.bar(quarters, quarterly['total_revenue'], 
                        color=['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFA07A'], alpha=0.8)
        ax1.set_xlabel('Quarter', fontsize=12)
        ax1.set_ylabel('Total Revenue ($)', fontsize=12)
        ax1.set_title('Total Revenue by Quarter', fontsize=14, fontweight='bold')
        ax1.grid(True, alpha=0.3)
        
        # Transaction count by quarter
        ax2 = axes[1]
        bars2 = ax2.bar(quarters, quarterly['transaction_count'], 
                        color=['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFA07A'], alpha=0.8)
        ax2.set_xlabel('Quarter', fontsize=12)
        ax2.set_ylabel('Transaction Count', fontsize=12)
        ax2.set_title('Transaction Count by Quarter', fontsize=14, fontweight='bold')
        ax2.grid(True, alpha=0.3)
        
        plt.tight_layout()
        plt.savefig(f'{self.output_dir}/06_quarterly_comparison.png', dpi=300, bbox_inches='tight')
        plt.close()
    
    def _plot_anomaly_distribution(self) -> None:
        """Plot anomaly distribution and details."""
        if len(self.anomalies) == 0:
            print("No anomalies to plot")
            return
        
        fig, axes = plt.subplots(2, 2, figsize=(14, 10))
        
        # Anomaly timeline
        ax1 = axes[0, 0]
        ax1.scatter(self.anomalies['date'], self.anomalies['total_revenue'], 
                   c='red', s=100, alpha=0.6, label='Anomalies')
        ax1.plot(self.daily_revenue['date'], self.daily_revenue['total_revenue'], 
                alpha=0.3, label='All Days')
        ax1.set_xlabel('Date', fontsize=12)
        ax1.set_ylabel('Revenue ($)', fontsize=12)
        ax1.set_title('Anomaly Timeline', fontsize=14, fontweight='bold')
        ax1.legend()
        ax1.grid(True, alpha=0.3)
        plt.setp(ax1.xaxis.get_majorticklabels(), rotation=45)
        
        # Z-score distribution
        ax2 = axes[0, 1]
        ax2.hist(self.daily_revenue['zscore'], bins=50, color='skyblue', 
                edgecolor='black', alpha=0.7)
        ax2.axvline(x=3, color='red', linestyle='--', linewidth=2, label='Threshold (3.0)')
        ax2.axvline(x=-3, color='red', linestyle='--', linewidth=2)
        ax2.set_xlabel('Z-Score', fontsize=12)
        ax2.set_ylabel('Frequency', fontsize=12)
        ax2.set_title('Z-Score Distribution', fontsize=14, fontweight='bold')
        ax2.legend()
        ax2.grid(True, alpha=0.3)
        
        # Anomaly revenue distribution
        ax3 = axes[1, 0]
        ax3.boxplot([self.daily_revenue['total_revenue'], self.anomalies['total_revenue']], 
                   labels=['Normal Days', 'Anomalous Days'])
        ax3.set_ylabel('Revenue ($)', fontsize=12)
        ax3.set_title('Revenue Distribution: Normal vs Anomalous', fontsize=14, fontweight='bold')
        ax3.grid(True, alpha=0.3)
        
        # Anomaly count by month
        ax4 = axes[1, 1]
        self.anomalies['month'] = pd.to_datetime(self.anomalies['date']).dt.month
        anomaly_by_month = self.anomalies.groupby('month').size()
        months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 
                  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
        ax4.bar(months, anomaly_by_month.values, color='salmon', alpha=0.7)
        ax4.set_xlabel('Month', fontsize=12)
        ax4.set_ylabel('Number of Anomalies', fontsize=12)
        ax4.set_title('Anomaly Count by Month', fontsize=14, fontweight='bold')
        ax4.grid(True, alpha=0.3)
        
        plt.tight_layout()
        plt.savefig(f'{self.output_dir}/07_anomaly_analysis.png', dpi=300, bbox_inches='tight')
        plt.close()
    
    def _plot_revenue_heatmap(self) -> None:
        """Plot revenue heatmap (Month vs Day of Week)."""
        heatmap_data = self.df.groupby(['month', 'day_of_week'])['revenue'].sum().unstack()
        
        plt.figure(figsize=(12, 8))
        days = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
        months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 
                  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
        
        sns.heatmap(heatmap_data, annot=True, fmt='.0f', cmap='YlOrRd', 
                   xticklabels=days, yticklabels=months)
        plt.xlabel('Day of Week', fontsize=12)
        plt.ylabel('Month', fontsize=12)
        plt.title('Revenue Heatmap: Month vs Day of Week', fontsize=14, fontweight='bold')
        plt.tight_layout()
        plt.savefig(f'{self.output_dir}/08_revenue_heatmap.png', dpi=300, bbox_inches='tight')
        plt.close()
    
    def generate_report(self) -> str:
        """Generate comprehensive summary report."""
        print("Generating summary report...")
        
        report = []
        report.append("=" * 80)
        report.append("E-COMMERCE TRANSACTION ANALYSIS REPORT")
        report.append("=" * 80)
        report.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        report.append(f"Data File: {self.csv_path}")
        report.append("")
        
        # Overview
        report.append("-" * 80)
        report.append("1. DATA OVERVIEW")
        report.append("-" * 80)
        report.append(f"Total Transactions: {len(self.df):,}")
        report.append(f"Date Range: {self.df['timestamp'].min().date()} to {self.df['timestamp'].max().date()}")
        report.append(f"Total Revenue: ${self.df['revenue'].sum():,.2f}")
        report.append(f"Average Transaction: ${self.df['revenue'].mean():,.2f}")
        report.append(f"Unique Categories: {self.df['product_category'].nunique()}")
        report.append(f"Product Categories: {', '.join(self.df['product_category'].unique()[:10])}")
        report.append("")
        
        # Seasonal Insights
        report.append("-" * 80)
        report.append("2. SEASONAL TRENDS")
        report.append("-" * 80)
        
        # Best month
        monthly_avg = self.seasonal_patterns['monthly'].groupby('month')['total_revenue'].mean()
        best_month = monthly_avg.idxmax()
        worst_month = monthly_avg.idxmin()
        months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 
                  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
        
        report.append(f"Best Performing Month: {months[best_month-1]} (Avg: ${monthly_avg[best_month]:,.2f})")
        report.append(f"Worst Performing Month: {months[worst_month-1]} (Avg: ${monthly_avg[worst_month]:,.2f})")
        
        # Best day
        weekly = self.seasonal_patterns['weekly']
        best_day_idx = weekly['total_revenue'].idxmax()
        days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
        report.append(f"Best Performing Day: {days[weekly.loc[best_day_idx, 'day_of_week']]}")
        
        # Best hour
        hourly = self.seasonal_patterns['hourly']
        best_hour = hourly.loc[hourly['total_revenue'].idxmax(), 'hour']
        report.append(f"Peak Hour: {best_hour}:00 - {best_hour+1}:00")
        report.append("")
        
        # Category Performance
        report.append("-" * 80)
        report.append("3. CATEGORY PERFORMANCE")
        report.append("-" * 80)
        category_stats = self.df.groupby('product_category')['revenue'].agg(['sum', 'mean', 'count'])
        category_stats = category_stats.sort_values('sum', ascending=False)
        
        for i, (cat, row) in enumerate(category_stats.head(5).iterrows()):
            report.append(f"{i+1}. {cat}: ${row['sum']:,.2f} ({row['count']:,} transactions, Avg: ${row['mean']:,.2f})")
        report.append("")
        
        # Anomaly Summary
        report.append("-" * 80)
        report.append("4. ANOMALY DETECTION")
        report.append("-" * 80)
        report.append(f"Total Anomalous Days: {len(self.anomalies):,}")
        report.append(f"Anomaly Rate: {len(self.anomalies)/len(self.daily_revenue)*100:.2f}%")
        
        if len(self.anomalies) > 0:
            report.append(f"Average Anomaly Revenue: ${self.anomalies['total_revenue'].mean():,.2f}")
            report.append(f"Normal Days Average Revenue: ${self.daily_revenue[~self.daily_revenue['is_anomaly']]['total_revenue'].mean():,.2f}")
            
            report.append("\nTop 5 Anomalous Days:")
            top_anomalies = self.anomalies.nlargest(5, 'total_revenue')
            for _, row in top_anomalies.iterrows():
                report.append(f"  - {row['date'].date()}: ${row['total_revenue']:,.2f} (Z-Score: {row['zscore']:.2f})")
        report.append("")
        
        # Quarterly Summary
        report.append("-" * 80)
        report.append("5. QUARTERLY SUMMARY")
        report.append("-" * 80)
        quarterly = self.seasonal_patterns['quarterly']
        for _, row in quarterly.iterrows():
            report.append(f"Q{row['quarter']}: ${row['total_revenue']:,.2f} ({row['transaction_count']:,} transactions)")
        report.append("")
        
        # Recommendations
        report.append("-" * 80)
        report.append("6. KEY INSIGHTS & RECOMMENDATIONS")
        report.append("-" * 80)
        
        # Seasonal recommendation
        if best_month != worst_month:
            report.append(f"• Focus marketing efforts in {months[best_month-1]}, consider promotions in {months[worst_month-1]}")
        
        # Weekly recommendation
        best_day = days[weekly.loc[weekly['total_revenue'].idxmax(), 'day_of_week']]
        worst_day = days[weekly['total_revenue'].idxmin()]
        report.append(f"• {best_day} shows highest revenue, consider staffing accordingly")
        report.append(f"• {worst_day} may benefit from promotional activities")
        
        # Category recommendation
        top_category = category_stats.index[0]
        report.append(f"• {top_category} is the top-performing category - ensure adequate inventory")
        
        # Anomaly recommendation
        if len(self.anomalies) > 0:
            report.append(f"• Investigate {len(self.anomalies)} anomalous days for potential issues or opportunities")
        
        report.append("")
        report.append("=" * 80)
        report.append("END OF REPORT")
        report.append("=" * 80)
        
        # Save report
        report_text = '\n'.join(report)
        
        with open(f'{self.output_dir}/analysis_report.txt', 'w') as f:
            f.write(report_text)
        
        # Save JSON summary
        summary = {
            'total_transactions': len(self.df),
            'total_revenue': float(self.df['revenue'].sum()),
            'average_transaction': float(self.df['revenue'].mean()),
            'date_range': {
                'start': str(self.df['timestamp'].min().date()),
                'end': str(self.df['timestamp'].max().date())
            },
            'anomalies_detected': len(self.anomalies),
            'best_month': months[best_month-1],
            'best_day': best_day,
            'top_category': top_category
        }
        
        with open(f'{self.output_dir}/summary.json', 'w') as f:
            json.dump(summary, f, indent=2)
        
        print(f"Report saved to {self.output_dir}/analysis_report.txt")
        print(f"Summary JSON saved to {self.output_dir}/summary.json")
        
        return report_text
    
    def run_full_analysis(self) -> None:
        """Execute complete analysis pipeline."""
        print("\n" + "="*80)
        print("STARTING E-COMMERCE TRANSACTION ANALYSIS")
        print("="*80 + "\n")
        
        # Execute pipeline
        self.load_data()
        self.preprocess_data()
        self.analyze_seasonal_trends()
        self.detect_anomalies(method='zscore', threshold=3.0)
        self.create_visualizations()
        report = self.generate_report()
        
        print("\n" + "="*80)
        print("ANALYSIS COMPLETE!")
        print("="*80)
        print(f"\nOutput files saved to: {os.path.abspath(self.output_dir)}/")
        print("\nGenerated files:")
        for file in os.listdir(self.output_dir):
            print(f"  - {file}")
        
        # Print report summary
        print("\n" + report[:500] + "...")


def create_sample_data(n_rows=50000, output_path='sample_transactions.csv'):
    """Create sample e-commerce transaction data for testing."""
    print(f"Creating sample data with {n_rows:,} rows...")
    
    np.random.seed(42)
    
    # Generate dates over 2 years
    start_date = datetime(2022, 1, 1)
    end_date = datetime(2023, 12, 31)
    date_range = pd.date_range(start=start_date, end=end_date, freq='D')
    
    # Categories with different weights
    categories = ['Electronics', 'Clothing', 'Home & Garden', 'Sports', 
                  'Books', 'Beauty', 'Toys', 'Food', 'Automotive', 'Health']
    category_weights = [0.20, 0.18, 0.15, 0.12, 0.10, 0.08, 0.07, 0.05, 0.03, 0.02]
    
    # Generate data
    data = {
        'timestamp': np.random.choice(date_range, n_rows),
        'product_category': np.random.choice(categories, n_rows, p=category_weights),
        'revenue': np.zeros(n_rows)
    }
    
    # Add seasonal patterns to revenue
    for i in range(n_rows):
        month = data['timestamp'][i].month
        hour = np.random.randint(6, 23)
        data['timestamp'][i] = data['timestamp'][i].replace(hour=hour, 
                                                             minute=np.random.randint(0, 60),
                                                             second=np.random.randint(0, 60))
        
        # Base revenue by category
        base_revenue = {
            'Electronics': 150, 'Clothing': 80, 'Home & Garden': 120,
            'Sports': 90, 'Books': 30, 'Beauty': 60, 'Toys': 50,
            'Food': 40, 'Automotive': 200, 'Health': 70
        }
        
        # Seasonal multiplier (higher in Nov-Dec for holidays)
        seasonal_mult = 1.0
        if month in [11, 12]:
            seasonal_mult = 1.5 + np.random.uniform(0, 0.5)
        elif month in [1, 2]:
            seasonal_mult = 0.8
        elif month in [6, 7, 8]:
            seasonal_mult = 1.1
        
        # Day of week effect (weekends higher)
        dow = data['timestamp'][i].dayofweek
        if dow >= 5:  # Weekend
            seasonal_mult *= 1.3
        
        # Hour effect (evening higher)
        if 18 <= hour <= 21:
            seasonal_mult *= 1.2
        
        # Add randomness
        revenue = base_revenue[data['product_category'][i]] * seasonal_mult
        revenue *= np.random.lognormal(0, 0.5)  # Log-normal distribution
        revenue = max(10, revenue)  # Minimum $10
        
        data['revenue'][i] = round(revenue, 2)
    
    # Add some anomalies (5% of days)
    n_anomalies = int(n_rows * 0.05)
    anomaly_indices = np.random.choice(n_rows, n_anomalies, replace=False)
    data['revenue'][anomaly_indices] *= np.random.uniform(3, 10, n_anomalies)
    
    # Create DataFrame and save
    df = pd.DataFrame(data)
    df.to_csv(output_path, index=False)
    print(f"Sample data saved to: {output_path}")
    
    return output_path


if __name__ == "__main__":
    import sys
    
    # Check if sample data should be created
    if len(sys.argv) > 1 and sys.argv[1] == '--create-sample':
        csv_path = create_sample_data(n_rows=50000)
    elif len(sys.argv) > 1:
        csv_path = sys.argv[1]
    else:
        csv_path = 'sample_transactions.csv'
        if not os.path.exists(csv_path):
            print("Sample data file not found. Creating sample data...")
            csv_path = create_sample_data(n_rows=50000)
    
    # Run analysis
    analyzer = ECommerceAnalyzer(csv_path, output_dir='ecommerce_analysis')
    analyzer.run_full_analysis()

Usage Instructions

Quick Start

# Run with existing CSV
python ecommerce_analyzer.py your_data.csv

# Or create sample data and analyze
python ecommerce_analyzer.py --create-sample

Key Features

1. Seasonal Trend Analysis

   • Monthly, weekly, hourly patterns
   • Category performance over time
   • Quarterly comparisons

2. Anomaly Detection

   • Z-score and IQR methods
   • Visual highlighting of anomalies
   • Detailed anomaly reports

3. Visualizations (8 charts)

   • Daily revenue trends
   • Monthly heatmaps
   • Day/hour patterns
   • Category performance
   • Anomaly analysis
   • Revenue heatmaps

4. Reports

   • Text summary report
   • JSON summary for integration
   • All visualizations saved as PNG

Output Files

ecommerce_analysis/
├── 01_daily_revenue.png
├── 02_monthly_trends.png
├── 03_weekly_pattern.png
├── 04_hourly_pattern.png
├── 05_category_performance.png
├── 06_quarterly_comparison.png
├──