RSK World - Time Series Analysis Dashboard Documentation | Plotly | Time Series Data Visualization | Dashboard Visualization | Python | Interactive Dashboards | Forecasting | ARIMA | Prophet | Trend Analysis | Seasonality Detection | RSK World

Time Series Analysis Dashboard - Project Description | Plotly | Time Series Data Visualization | Interactive Dashboards

This project creates comprehensive Time Series Analysis Dashboards using Plotly for time series data visualization and temporal analysis. The project includes interactive time series plots with zoom and pan functionality, trend analysis with moving averages and trend detection, seasonality detection to identify and visualize seasonal patterns, time series decomposition to separate trend, seasonal, and residual components, multiple forecasting methods (Prophet, ARIMA, Simple trend-based), statistical analysis with comprehensive summaries, ACF/PACF analysis for autocorrelation and partial autocorrelation functions, lag plots to visualize autocorrelation patterns, distribution analysis with histograms and Q-Q plots, outlier detection using IQR and Z-score methods, rolling statistics with confidence bands, ARIMA modeling for advanced forecasting, and model evaluation with MAE, RMSE, MAPE, MASE, and R² metrics. Perfect for temporal data visualization, pattern analysis, forecasting, and interactive dashboard applications.

The Time Series Analysis Dashboard project features 1 comprehensive Jupyter notebook covering basic visualizations (time series plots, trend analysis, seasonality, decomposition, forecasting) and advanced features (ACF/PACF analysis, lag plots, distribution analysis, outlier detection, rolling statistics, ARIMA modeling, model evaluation). The project includes 5 Python scripts (dashboard.py for main dashboard, generate_dashboard.py for HTML dashboard generation, generate_sample_datasets.py for creating sample datasets, example_usage.py for usage examples, and utility modules in utils/ folder). Built with Python 3.8+, Plotly 5.17+, Pandas 2.0+, Statsmodels 0.14+, Prophet 1.1.5+, NumPy 1.24+, Jupyter Notebook, and optional scikit-learn for machine learning utilities and scipy for scientific computing. The project includes comprehensive sample datasets for stock prices, sales data, temperature data, website traffic, and general sample data.

Time Series Analysis Dashboard Screenshots | Plotly Time Series Dashboards | Interactive Dashboard Examples

1 / 4

Time Series Analysis Dashboard Core Features | Plotly Time Series Features | Interactive Dashboard Features

Interactive Time Series Plots

Interactive line charts
Zoom and pan functionality
Hover tooltips with data
Customizable styling
Multiple series support

Trend Analysis

Moving averages
Trend detection
Customizable windows
Visual trend indicators
Long-term patterns

Seasonality Detection

Seasonal pattern identification
Box plot visualizations
Seasonal decomposition
Period detection
Periodic patterns

Time Series Decomposition

Trend component extraction
Seasonal component analysis
Residual analysis
Additive and multiplicative
Component separation

Multiple Forecasting Methods

Prophet forecasting
ARIMA models
Simple trend-based
Model comparison
Forecast visualization

1 Jupyter Notebook

Complete tutorial
Basic and advanced features
Step-by-step examples
Code explanations
Interactive learning

Advanced Time Series Dashboard Features | ARIMA Modeling | ACF/PACF Analysis | Model Evaluation

ARIMA Modeling

ARIMA(p,d,q) models
Automatic parameter selection
Model diagnostics
Forecast generation
Advanced forecasting

ACF/PACF Analysis

Autocorrelation functions
Partial autocorrelation
Confidence intervals
Model identification

Outlier Detection

IQR method
Z-score method
Customizable thresholds
Anomaly visualization

Model Evaluation

MAE, RMSE, MAPE metrics
MASE and R² calculations
Model comparison
Performance visualization
Comprehensive metrics

Analysis Types | Time Series Analysis Types | Interactive Dashboard Features

Analysis Type	Description	Use Case
Time Series Plot	Interactive line charts showing temporal data over time	Visualize trends, patterns, and changes in time series data
Trend Analysis	Moving averages and trend detection with customizable windows	Identify long-term patterns and directional trends
Seasonality Detection	Identify and visualize seasonal patterns in time series data	Understand periodic patterns and seasonal effects
Time Series Decomposition	Separate time series into trend, seasonal, and residual components	Analyze individual components of time series data
Forecasting	Multiple forecasting methods (Prophet, ARIMA, Simple trend-based)	Predict future values and make data-driven forecasts
ACF/PACF Analysis	Autocorrelation and partial autocorrelation function plots	Identify ARIMA model parameters and autocorrelation patterns
Outlier Detection	IQR and Z-score based methods for identifying anomalies	Detect and handle outliers in time series data
Rolling Statistics	Rolling mean, std, min, max with confidence bands	Analyze how statistics change over time with sliding windows
ARIMA Modeling	Fit and forecast with ARIMA(p,d,q) models	Advanced time series modeling and forecasting
Model Evaluation	Comprehensive metrics: MAE, RMSE, MAPE, MASE, R²	Evaluate and compare forecasting model performance

Technologies Used | Python Technologies | Data Science Stack | Analytics Tools

This Time Series Analysis Dashboard project is built using modern Python time series data visualization and temporal analysis technologies. The core implementation uses Python 3.8+ as the primary programming language and Plotly 5.17+ for creating interactive time series dashboards. The project includes Pandas 2.0+ for data manipulation, Statsmodels 0.14+ for statistical modeling (ARIMA, decomposition), Prophet 1.1.5+ for Facebook's forecasting tool, NumPy 1.24+ for numerical computing, Jupyter Notebook for interactive development, and optional scikit-learn 1.3+ for machine learning utilities and scipy 1.11+ for scientific computing. The visualization library features interactive time series plots with zoom and pan, multiple analysis types (trend analysis, seasonality detection, decomposition, forecasting), ARIMA modeling, ACF/PACF analysis, outlier detection, rolling statistics, and model evaluation for temporal data analysis, pattern recognition, and forecasting applications.

The project uses Plotly as the core visualization library for creating interactive time series dashboards with Python. It supports time series data visualization through interactive time series plots, trend analysis with moving averages, seasonality detection, time series decomposition (trend, seasonal, residual), multiple forecasting methods (Prophet, ARIMA, Simple), ACF/PACF analysis, lag plots, distribution analysis, outlier detection (IQR, Z-score), rolling statistics, and model evaluation (MAE, RMSE, MAPE, MASE, R²). The project includes comprehensive sample datasets for stock prices, sales data with weekly patterns, temperature data with annual seasonality, website traffic with growth trends, and general sample data. The system includes interactive features such as zoom and pan, hover tooltips, customizable styling, multiple forecast methods, and HTML dashboard export capabilities for temporal data analysis, pattern recognition, forecasting, and interactive dashboard applications.

Python 3.8+ Plotly 5.0+ Statsmodels 0.14+ Pandas 2.0+ NumPy 1.24+ Jupyter Notebook Prophet 1.1.5+ scipy 1.11+ ARIMA Models Forecasting

Installation & Usage Guide | How to Install Time Series Dashboard | Setup Tutorial

Installation

Install all required dependencies for the Time Series Analysis Dashboard project:

# Install all requirements
pip install -r requirements.txt

# Required packages:
# - pandas>=1.3.0
# - numpy>=1.21.0
# - plotly>=5.0.0
# - geopandas>=0.10.0
# - shapely>=1.8.0
# - scipy>=1.7.0
# - jupyter>=1.0.0
# - notebook>=6.4.0

# Optional packages for advanced features:
# - scikit-learn>=1.0.0  # For clustering analysis
# - kaleido>=0.2.1  # For image export (PNG, PDF, SVG)

# Verify installation
python check_project.py

Running Jupyter Notebooks

Start Jupyter Notebook to explore the time series dashboard examples:

# Start Jupyter Notebook
jupyter notebook

# Or use JupyterLab
jupyter lab

# Open the notebook:
# - time_series_dashboard.ipynb - Complete tutorial with all features
#   * Interactive time series plots
#   * Trend analysis
#   * Seasonality detection
#   * Time series decomposition
#   * Forecasting (Prophet, ARIMA, Simple)
#   * ACF/PACF analysis
#   * Outlier detection
#   * Rolling statistics
#   * ARIMA modeling
#   * Model evaluation

Running Example Scripts

Run Python scripts to generate time series dashboards:

# Run complete example (generates all basic visualizations):
python example.py

# Run dashboard directly:
python dashboard.py

# Generate sample datasets:
python generate_sample_datasets.py

# This will generate:
# - sample_data.csv (general time series with trend and seasonality)
# - stock_prices.csv (synthetic stock price data)
# - sales_data.csv (sales data with weekly patterns)
# - temperature_data.csv (temperature data with annual seasonality)
# - website_traffic.csv (website traffic with growth trends)

# Verify project setup:
python check_project.py

Project Features

Explore the comprehensive time series analysis dashboard features:

# Project Features:
# 1. Interactive Time Series Plots - Beautiful, interactive visualizations with Plotly
# 2. Trend Analysis - Moving averages and trend detection with customizable windows
# 3. Seasonality Detection - Identify and visualize seasonal patterns
# 4. Time Series Decomposition - Separate trend, seasonal, and residual components
# 5. Multiple Forecasting Methods - Prophet, ARIMA, and Simple trend-based forecasting
# 6. ACF/PACF Analysis - Autocorrelation and partial autocorrelation functions
# 7. Lag Plots - Visualize autocorrelation patterns at different lags
# 8. Distribution Analysis - Histograms and Q-Q plots for normality testing
# 9. Outlier Detection - IQR and Z-score based outlier identification
# 10. Rolling Statistics - Rolling mean, std, min, max with confidence bands
# 11. ARIMA Modeling - Fit and forecast with ARIMA(p,d,q) models
# 12. Model Evaluation - MAE, RMSE, MAPE, MASE, R² metrics
# 13. Data Preprocessing - Missing value handling, outlier removal, transformations
# 14. 1 Jupyter Notebook - Comprehensive tutorial with all features
# 15. 5 Python Scripts - Reusable analysis modules

# All features are demonstrated in the Jupyter notebook

Basic Usage Example

Create time series analysis dashboards with Python:

# Basic Usage Example:
from utils.data_loader import load_time_series_data, generate_sample_data
from utils.visualizations import (
    plot_time_series,
    plot_trend_analysis,
    plot_seasonality,
    plot_decomposition,
    plot_forecast
)
import pandas as pd

# Load your data
df = load_time_series_data('data/sample_data.csv')
# Or generate sample data:
# df = generate_sample_data(n_days=365)

# Create time series plot
fig1 = plot_time_series(df)
fig1.show()

# Create trend analysis
fig2 = plot_trend_analysis(df, window=30)
fig2.show()

# Create seasonality analysis
fig3 = plot_seasonality(df, period=30)
fig3.show()

# Create decomposition
fig4 = plot_decomposition(df, model='additive', period=30)
fig4.show()

# Create forecast
fig5 = plot_forecast(df, forecast_periods=30, method='prophet')
fig5.show()

Project Structure | Time Series Dashboard File Structure | Source Code Organization

                time-series-dashboard/

                ├── README.md                          # Main documentation

                ├── requirements.txt                   # Python dependencies

                ├── LICENSE                            # MIT License

                ├── RELEASE_NOTES.md                   # Release notes

                ├── FEATURES.md                        # Complete features list

                ├── QUICKSTART.md                      # Quick start guide

                ├── setup.py                           # Package setup

                │

                ├── time_series_dashboard.ipynb        # Main tutorial notebook

                │   # Complete tutorial: basic and advanced features

                │   # Time series plots, trend, seasonality, decomposition

                │   # Forecasting, ACF/PACF, ARIMA, model evaluation

                │

                ├── dashboard.py                       # Main dashboard script

                │   # create_dashboard() - Complete dashboard

                │

                ├── generate_dashboard.py             # HTML dashboard generator

                │   # generate_html_dashboard() - Standalone HTML

                │

                ├── generate_sample_datasets.py        # Sample data generator

                │   # Generate stock, sales, temperature, traffic data

                │

                ├── example_usage.py                   # Usage examples

                │

                ├── utils/                             # Utility modules

                │   ├── data_loader.py                 # Data loading and generation

                │   ├── visualizations.py              # Basic visualizations

                │   ├── advanced_visualizations.py     # Advanced analysis

                │   ├── model_evaluation.py            # Model metrics

                │   └── data_preprocessing.py          # Data cleaning

                │

                ├── data/                              # Sample datasets

                │   ├── sample_data.csv                # General time series

                │   ├── stock_prices.csv               # Stock price data

                │   ├── sales_data.csv                  # Sales data

                │   ├── temperature_data.csv           # Temperature data

                │   └── website_traffic.csv            # Website traffic data

                │

                └── dashboard.html                     # Generated HTML dashboard

Configuration Options | Plotly Configuration | Time Series Dashboard Customization Guide

Plotly Configuration

Customize time series dashboard visualization settings in Python code:

# Plotly Configuration for Time Series Dashboards

import plotly.graph_objects as go
import plotly.express as px

# Default configuration in utils/visualizations.py functions:
# - template: 'plotly_white' (can be 'plotly', 'plotly_dark', 'ggplot2', etc.)
# - height: 600 (figure height in pixels)
# - width: 1000 (figure width in pixels)
# - showlegend: True (show legend for multiple series)

# Customize in function calls:
from utils.visualizations import plot_time_series

fig = plot_time_series(
    df,
    title='Custom Time Series Plot',  # Custom title
    height=800,                        # Adjust height
    template='plotly_dark'            # Change template
)

# Modify default settings in utils/visualizations.py:
# Edit function defaults to change global behavior

Configuration Tips:

TEMPLATE: Choose from 'plotly', 'plotly_white', 'plotly_dark', 'ggplot2', 'seaborn', 'simple_white', etc. Default: 'plotly_white'
WINDOW: Adjust moving average window (7-365). Smaller = more responsive, Larger = smoother. Default: 30
PERIOD: Set seasonality period (7 for weekly, 30 for monthly, 365 for yearly). Default: 30
FORECAST_PERIODS: Number of periods to forecast (1-365). Default: 30
HEIGHT: Set figure height in pixels. Default: 600. Adjust for different screen sizes
EXPORT_FORMAT: HTML (interactive), PNG, PDF, or SVG (requires kaleido package)

Time Series Data Format Requirements

Works with various time series data formats. Required structure:

# Supported data formats:
# - Pandas DataFrame with DatetimeIndex (recommended)
# - CSV files (via pd.read_csv() with date parsing)
# - NumPy arrays (with proper date column)

# Required DataFrame structure:
import pandas as pd
import numpy as np

# Minimum required structure:
dates = pd.date_range('2020-01-01', periods=365, freq='D')
data = {
    'value': np.random.randn(365).cumsum() + 100  # Required: numeric values
}
df = pd.DataFrame(data, index=dates)

# Or with date column:
data = {
    'date': pd.date_range('2020-01-01', periods=365, freq='D'),
    'value': np.random.randn(365).cumsum() + 100
}
df = pd.DataFrame(data)
df['date'] = pd.to_datetime(df['date'])
df.set_index('date', inplace=True)

# Works with:
# - DatetimeIndex or date column (datetime format)
# - Value column (numeric values)
# - Optional: multiple value columns for multi-series analysis

Customizing Dashboard Appearance

Modify dashboard configurations in utils/visualizations.py or utils/advanced_visualizations.py:

# Dashboard customization in Python:

from utils.visualizations import plot_time_series
import plotly.graph_objects as go

# Create time series plot
fig = plot_time_series(df)

# Customize layout:
fig.update_layout(
    title={
        'text': 'Custom Time Series Dashboard',
        'x': 0.5,
        'font': {'size': 24, 'color': '#1e293b'}
    },
    height=800,  # Adjust height
    width=1200,  # Adjust width
    margin=dict(l=50, r=50, t=80, b=50),
    template='plotly_white'  # Change template
)

# Customize axes:
fig.update_xaxes(
    title_text="Date",
    title_font=dict(size=16),
    tickfont=dict(size=12)
)

fig.update_yaxes(
    title_text="Value",
    title_font=dict(size=16),
    tickfont=dict(size=12)
)

# Save customized dashboard
fig.write_html('custom_dashboard.html')

Adding Custom Time Series Visualizations

Add new time series analysis visualizations using Plotly:

# Add new visualization function to utils/visualizations.py or utils/advanced_visualizations.py:

import plotly.graph_objects as go
import pandas as pd

def create_custom_time_series_plot(df, value_col='value', **kwargs):
    """Create a custom time series visualization."""
    
    fig = go.Figure()
    
    # Add time series trace
    fig.add_trace(go.Scatter(
        x=df.index,
        y=df[value_col],
        mode='lines',
        name='Time Series',
        line=dict(color=kwargs.get('color', '#1f77b4'), width=2),
        hovertemplate='Date: %{x}
Value: %{y}'
    ))
    
    # Update layout
    fig.update_layout(
        title=kwargs.get('title', 'Custom Time Series Plot'),
        xaxis_title='Date',
        yaxis_title='Value',
        height=kwargs.get('height', 600),
        template=kwargs.get('template', 'plotly_white'),
        hovermode='x unified'
    )
    
    # Save if output file provided
    if kwargs.get('output_file'):
        fig.write_html(kwargs['output_file'])
        print(f"Dashboard saved as '{kwargs['output_file']}'")
    
    return fig

# Use in your code:
from utils.visualizations import create_custom_time_series_plot

fig = create_custom_time_series_plot(df, 
                                     title='My Custom Time Series',
                                     output_file='custom_dashboard.html')

Project Architecture | Time Series Dashboard Architecture | System Architecture | Technical Architecture

Time Series Dashboard Architecture

1. Plotly Visualization Framework:

Built on Plotly for interactive visualizations
Uses Plotly Graph Objects for advanced customization
Plotly Express for quick chart creation
Interactive HTML output with zoom, pan, and hover
Subplot support for multi-panel dashboards

2. Data Processing Pipeline:

Pandas DataFrame for time series data manipulation
CSV file loading and parsing with date handling
DatetimeIndex validation and conversion
Data preprocessing (missing values, outliers, transformations)
Time series decomposition and component extraction

3. Analysis Components:

Scatter plots for time series visualization
Box plots for seasonality analysis
Statistical functions for ACF/PACF analysis
ARIMA models for advanced forecasting
Prophet models for automatic forecasting

Module Structure

The project is organized into focused modules:

# Module Structure:
# utils/visualizations.py - Basic visualization functions
from utils.visualizations import (
    plot_time_series,            # Time series plot
    plot_trend_analysis,         # Trend analysis with moving averages
    plot_seasonality,            # Seasonality detection
    plot_decomposition,          # Time series decomposition
    plot_forecast                # Forecasting visualization
)

# utils/advanced_visualizations.py - Advanced analysis features
from utils.advanced_visualizations import (
    plot_acf_pacf,               # ACF/PACF analysis
    plot_outliers,                # Outlier detection
    plot_arima_forecast,         # ARIMA forecasting
    plot_rolling_statistics,      # Rolling statistics
    plot_distribution             # Distribution analysis
)

# utils/data_loader.py - Data loading and generation
from utils.data_loader import (
    load_time_series_data,       # Load time series from CSV
    generate_sample_data,        # Generate sample time series data
    generate_stock_price_data,   # Stock price data generator
    generate_sales_data,         # Sales data generator
    generate_temperature_data,   # Temperature data generator
    generate_website_traffic_data # Website traffic data generator
)

# utils/data_preprocessing.py - Data preprocessing utilities
from utils.data_preprocessing import (
    handle_missing_values,       # Missing value handling
    remove_outliers,              # Outlier removal
    normalize_series,             # Data normalization
    differencing                  # Create stationary series
)

# utils/model_evaluation.py - Model evaluation
from utils.model_evaluation import (
    calculate_metrics,            # Calculate evaluation metrics
    print_metrics                # Print formatted metrics
)

Data Format and Processing

How time series data is processed for analysis:

# Data Format Requirements:
# CSV file with columns: date, value

# Example data structure:
# date,value
# 2020-01-01,100.5
# 2020-01-02,102.3
# 2020-01-03,98.7
# 2020-01-04,105.2

# Data Processing Flow:
import pandas as pd
from utils.data_loader import load_time_series_data
from utils.data_preprocessing import handle_missing_values, remove_outliers

# Load data
df = load_time_series_data('your_data.csv')
# Automatically converts date column to DatetimeIndex

# Preprocess data
df = handle_missing_values(df, method='interpolate')
df = remove_outliers(df, method='iqr')

# Create visualization
from utils.visualizations import plot_time_series
fig = plot_time_series(df)
fig.write_html('dashboard.html')

Analysis Types and Usage

Different time series analysis types and their use cases:

Time Series Plot: Interactive line charts using go.Scatter()
Trend Analysis: Moving averages using df.rolling() and Plotly
Seasonality Detection: Box plots using go.Box() grouped by period
Decomposition: Component separation using statsmodels.tsa.seasonal.seasonal_decompose()
Forecasting: Multiple methods using Prophet, ARIMA, or simple trend
ACF/PACF Analysis: Autocorrelation plots using statsmodels.tsa.stattools.acf() and pacf()
Outlier Detection: IQR and Z-score methods using statistical calculations
Rolling Statistics: Rolling calculations using df.rolling() with confidence bands
ARIMA Modeling: Advanced forecasting using statsmodels.tsa.arima.model.ARIMA
Model Evaluation: Metrics calculation using custom functions for MAE, RMSE, MAPE, MASE, R²

Advanced Features Usage | Time Series Dashboard Usage Guide | How to Use Time Series Dashboards

Using Basic Dashboard Functions

How to create different types of time series analysis visualizations:

# Basic Dashboard Usage Examples:

from utils.visualizations import (
    plot_time_series,
    plot_trend_analysis,
    plot_seasonality,
    plot_decomposition,
    plot_forecast
)
from utils.data_loader import load_time_series_data, generate_sample_data
import pandas as pd

# Load or generate data
df = load_time_series_data('data/sample_data.csv')
# Or generate sample data:
# df = generate_sample_data(n_days=365)

# 1. Create Time Series Plot:
fig1 = plot_time_series(df, title='Time Series Plot')
fig1.show()

# 2. Create Trend Analysis:
fig2 = plot_trend_analysis(df, window=30, title='Trend Analysis')
fig2.show()

# 3. Create Seasonality Analysis:
fig3 = plot_seasonality(df, period=30, title='Seasonality Detection')
fig3.show()

# 4. Create Decomposition:
fig4 = plot_decomposition(df, model='additive', period=30, title='Time Series Decomposition')
fig4.show()

# 5. Create Forecast:
fig5 = plot_forecast(df, forecast_periods=30, method='prophet', title='Forecasting')
fig5.show()

Using Advanced Features

Create advanced time series analysis visualizations:

# Advanced Features Usage:

from utils.advanced_visualizations import (
    plot_acf_pacf,
    plot_outliers,
    plot_arima_forecast,
    plot_rolling_statistics,
    plot_distribution
)

# 1. ACF/PACF Analysis:
fig1 = plot_acf_pacf(df, lags=40, title='ACF/PACF Analysis')
fig1.show()

# 2. Outlier Detection:
fig2 = plot_outliers(df, method='iqr', title='Outlier Detection')
fig2.show()

# 3. ARIMA Forecasting:
fig3, model = plot_arima_forecast(
    df,
    order=(1,1,1),
    forecast_periods=30,
    title='ARIMA Forecast'
)
fig3.show()

# 4. Rolling Statistics:
fig4 = plot_rolling_statistics(
    df,
    window=30,
    title='Rolling Statistics'
)
fig4.show()

# 5. Distribution Analysis:
fig5 = plot_distribution(df, title='Distribution Analysis')
fig5.show()

Understanding Analysis Types

When to use different analysis types for time series data:

# Analysis Type Usage Guide:

# 1. Time Series Plot
#    - Use: Visualize temporal data over time
#    - Shows: Line chart with time on x-axis, values on y-axis
#    - Best for: Understanding overall trends, identifying patterns
#    - Example: Stock prices over time, sales trends, temperature changes

# 2. Trend Analysis
#    - Use: Identify long-term patterns and directional trends
#    - Shows: Moving averages and trend lines
#    - Best for: Understanding overall direction, smoothing noise
#    - Example: Sales growth trends, population growth, economic indicators

# 3. Seasonality Detection
#    - Use: Identify periodic patterns in time series data
#    - Shows: Box plots grouped by period (day, week, month, year)
#    - Best for: Understanding recurring patterns, seasonal effects
#    - Example: Weekly sales patterns, monthly temperature cycles, annual trends

# 4. Time Series Decomposition
#    - Use: Separate time series into components
#    - Shows: Trend, seasonal, and residual components separately
#    - Best for: Understanding individual components, removing seasonality
#    - Example: Sales decomposition, temperature analysis, economic indicators

# 5. Forecasting
#    - Use: Predict future values based on historical data
#    - Shows: Historical data with forecasted values and confidence intervals
#    - Best for: Planning, budgeting, decision making
#    - Example: Sales forecasting, demand prediction, stock price prediction

# 6. ACF/PACF Analysis
#    - Use: Identify ARIMA model parameters
#    - Shows: Autocorrelation and partial autocorrelation functions
#    - Best for: Model selection, understanding autocorrelation patterns
#    - Example: ARIMA parameter identification, lag analysis

# 7. Outlier Detection
#    - Use: Identify anomalies in time series data
#    - Shows: Data points flagged as outliers
#    - Best for: Data quality, anomaly detection, error identification
#    - Example: Sensor errors, data quality checks, anomaly detection

# 8. Rolling Statistics
#    - Use: Analyze how statistics change over time
#    - Shows: Rolling mean, std, min, max with confidence bands
#    - Best for: Understanding variability, trend changes
#    - Example: Volatility analysis, trend stability, risk assessment

# 9. ARIMA Modeling
#    - Use: Advanced time series modeling and forecasting
#    - Shows: Fitted ARIMA model with forecasts
#    - Best for: Complex time series, advanced forecasting
#    - Example: Economic forecasting, demand prediction, complex patterns

# 10. Model Evaluation
#    - Use: Evaluate forecasting model performance
#    - Shows: Metrics like MAE, RMSE, MAPE, MASE, R²
#    - Best for: Model comparison, performance assessment
#    - Example: Comparing forecast methods, model selection

Data Preparation and Customization

Prepare and customize your time series data for analysis:

# Data Preparation Examples:

import pandas as pd
from utils.data_loader import load_time_series_data
from utils.data_preprocessing import handle_missing_values, remove_outliers, normalize_series

# 1. Load and Validate Data:
df = load_time_series_data('your_data.csv')
# Automatically converts date column to DatetimeIndex

# 2. Handle Missing Values:
df = handle_missing_values(df, method='interpolate')
# Methods: 'forward_fill', 'backward_fill', 'interpolate', 'mean', 'median'

# 3. Remove Outliers:
df = remove_outliers(df, method='iqr')
# Methods: 'iqr', 'zscore'

# 4. Filter Data by Date Range:
df_2024 = df[(df.index >= '2024-01-01') & (df.index <= '2024-12-31')]

# 5. Resample Data (daily to monthly):
df_monthly = df.resample('M').mean()

# 6. Normalize Data:
df_normalized = normalize_series(df, method='min_max')
# Methods: 'min_max', 'zscore'

# 7. Create Stationary Series (differencing):
df_diff = df.diff().dropna()

# 8. Apply Transformations:
import numpy as np
df_log = np.log(df)  # Log transform for exponential growth
df_sqrt = np.sqrt(df)  # Square root transform

Exporting Dashboards

Export dashboards to different formats:

# Export Dashboard Examples:

from utils.visualizations import plot_time_series
import plotly.graph_objects as go

# 1. Export as HTML (interactive, default):
fig = plot_time_series(df)
fig.write_html('dashboard.html')
# Opens in browser with full interactivity

# 2. Export as PNG (requires kaleido):
# Install: pip install kaleido
fig = plot_time_series(df)
fig.write_image('dashboard.png', width=1920, height=1080)

# 3. Export as PDF (requires kaleido):
fig.write_image('dashboard.pdf')

# 4. Export as SVG (requires kaleido):
fig.write_image('dashboard.svg')

# 5. Generate Complete HTML Dashboard:
from generate_dashboard import generate_html_dashboard
generate_html_dashboard(df, output_file='dashboard.html')

Complete Time Series Dashboard Workflow | Step-by-Step Guide | Dashboard Tutorial

Step-by-Step Time Series Dashboard Setup

Step 1: Install Dependencies

# Install all required packages
pip install -r requirements.txt

# Required packages:
# - pandas>=1.3.0
# - numpy>=1.21.0
# - plotly>=5.0.0
# - geopandas>=0.10.0
# - shapely>=1.8.0
# - scipy>=1.7.0
# - jupyter>=1.0.0
# - notebook>=6.4.0

# Optional packages for advanced features:
# - scikit-learn>=1.0.0  # For clustering analysis
# - kaleido>=0.2.1  # For image export (PNG, PDF, SVG)

# Verify installation
python check_project.py

Step 2: Prepare Data

# Option 1: Generate sample datasets
python generate_sample_datasets.py
# This generates:
# - sample_data.csv (general time series with trend and seasonality)
# - stock_prices.csv (synthetic stock price data)
# - sales_data.csv (sales data with weekly patterns)
# - temperature_data.csv (temperature data with annual seasonality)
# - website_traffic.csv (website traffic with growth trends)

# Option 2: Use your own data
# Prepare CSV file with columns: date, value
# Place file in data/ directory

# Option 3: Generate basic sample data
from utils.data_loader import generate_sample_data
df = generate_sample_data(n_days=365)
df.to_csv('data/sample_data.csv')

# Data format:
# date,value
# 2020-01-01,100.5
# 2020-01-02,102.3
# 2020-01-03,98.7

Step 3: Create Basic Dashboards

# Run complete example (generates all basic visualizations):
python example_usage.py

# Or run dashboard directly:
python dashboard.py

# Or generate HTML dashboard:
python generate_dashboard.py

# This creates:
# - dashboard.html (complete interactive dashboard)

# Open HTML file in browser to view interactive dashboard

Step 4: Explore Jupyter Notebook

Open time_series_dashboard.ipynb for complete tutorial
Run cells step-by-step to learn each analysis type
Modify code examples to use your own data
Export visualizations as HTML, PNG, PDF, or SVG
Learn basic and advanced features in one notebook

Step 5: Customize Dashboards

# Customize dashboards in Python code:
from utils.visualizations import plot_time_series

# Change template
fig = plot_time_series(df)
fig.update_layout(template='plotly_dark')

# Adjust moving average window
from utils.visualizations import plot_trend_analysis
fig = plot_trend_analysis(df, window=60)  # Larger window = smoother

# Change forecast method
from utils.visualizations import plot_forecast
fig = plot_forecast(df, method='arima')  # or 'prophet', 'simple'

# Modify utils/visualizations.py for default settings
# Modify utils/advanced_visualizations.py for advanced configurations

Time Series Dashboard Customization Examples | Customization Guide | Code Examples

Customizing Plot Templates

Change plot templates and styling for time series dashboards:

# Customize Plot Templates:

from utils.visualizations import plot_time_series

# Available templates:
# 'plotly', 'plotly_white', 'plotly_dark', 'ggplot2', 
# 'seaborn', 'simple_white', 'presentation', etc.

# Example 1: Use dark theme
fig = plot_time_series(df)
fig.update_layout(template='plotly_dark')

# Example 2: Use ggplot2 style
fig.update_layout(template='ggplot2')

# Example 3: Use seaborn style
fig.update_layout(template='seaborn')

# Example 4: Use presentation style
fig.update_layout(template='presentation')

Adjusting Moving Average Window

Control the smoothness of trend analysis:

# Adjust Moving Average Window:

from utils.visualizations import plot_trend_analysis

# Smaller window (7-14): More responsive, shows short-term trends
fig = plot_trend_analysis(df, window=7)

# Default window (30): Balanced responsiveness and smoothness
fig = plot_trend_analysis(df, window=30)

# Larger window (60-90): Smoother, shows long-term trends
fig = plot_trend_analysis(df, window=60)

# Very large window (180-365): Very smooth, long-term patterns only
fig = plot_trend_analysis(df, window=180)

# Tip: Adjust based on data frequency and desired trend visibility

Changing Forecast Methods

Use different forecasting methods for predictions:

# Change Forecast Methods:

from utils.visualizations import plot_forecast

# Available methods:
# 'prophet' - Facebook's Prophet (default, best for seasonality)
# 'arima' - ARIMA model (best for stationary series)
# 'simple' - Simple trend-based (fast, basic)

# Example 1: Use Prophet (requires Prophet package)
fig = plot_forecast(df, method='prophet', forecast_periods=30)

# Example 2: Use ARIMA
fig = plot_forecast(df, method='arima', forecast_periods=30)

# Example 3: Use Simple trend-based
fig = plot_forecast(df, method='simple', forecast_periods=30)

# Tip: Prophet works best with strong seasonality, ARIMA for stationary data

Modifying Data Source

Load time series data from different sources:

# Load Time Series Data from Different Sources:

import pandas as pd
from utils.visualizations import plot_time_series

# Option 1: Load from CSV file
df = pd.read_csv('your_time_series_data.csv', parse_dates=['date'], index_col='date')

# Option 2: Load from Excel
df = pd.read_excel('your_time_series_data.xlsx', parse_dates=['date'], index_col='date')

# Option 3: Load from database
import sqlite3
conn = sqlite3.connect('time_series_data.db')
df = pd.read_sql_query("SELECT date, value FROM time_series", conn, parse_dates=['date'], index_col='date')
conn.close()

# Option 4: Load from API
import requests
response = requests.get('https://api.example.com/timeseries')
data = response.json()
df = pd.DataFrame(data)
df['date'] = pd.to_datetime(df['date'])
df.set_index('date', inplace=True)

# Option 5: Generate sample data
from utils.data_loader import generate_sample_data
df = generate_sample_data(n_days=365)

# Option 6: Use built-in data generators
from utils.data_loader import generate_stock_price_data
df = generate_stock_price_data(n_days=365)

# Then create dashboard
fig = plot_time_series(df)
fig.write_html('dashboard.html')

Customizing Dashboard Layout

Modify dashboard appearance and layout settings:

# Customize Dashboard Layout:

from utils.visualizations import plot_time_series
import plotly.graph_objects as go

# Create dashboard
fig = plot_time_series(df)

# Customize layout
fig.update_layout(
    title={
        'text': 'Custom Time Series Dashboard',
        'x': 0.5,
        'font': {'size': 24, 'color': '#1e293b'}
    },
    height=800,  # Adjust height
    width=1200,  # Adjust width
    margin=dict(l=50, r=50, t=80, b=50),
    template='plotly_white'
)

# Update axes
fig.update_xaxes(
    title_text="Date",
    title_font=dict(size=16)
)

fig.update_yaxes(
    title_text="Value",
    title_font=dict(size=16)
)

# Save customized dashboard
fig.write_html('custom_dashboard.html')

Dataset Information | Data Format | CSV Format | Data Requirements

Data Format Requirements

The project requires CSV format for time series data:

Required columns: date, value
Date format: YYYY-MM-DD or any parseable date format
Value: Numeric values representing the time series variable
Automatic date parsing and DatetimeIndex conversion
Support for multiple value columns for multi-series analysis
Handles missing values, outliers, and data preprocessing

Sample Data Format

Your time series data CSV file should follow this structure:

# CSV file structure (time_series_data.csv):
date,value
2020-01-01,100.5
2020-01-02,102.3
2020-01-03,98.7
2020-01-04,105.2
2020-01-05,103.8

# Column descriptions:
# - date: Date in YYYY-MM-DD format or any parseable date format
# - value: Numeric value representing the time series variable

# For multiple series, add additional value columns:
# date,value1,value2,value3
# 2020-01-01,100.5,200.3,150.7
# 2020-01-02,102.3,205.1,152.4
# 2020-01-03,98.7,198.9,148.2

Generating Sample Data

Use the included data generators to create sample time series datasets:

# Generate sample datasets
python generate_sample_datasets.py

# This will generate:
# - sample_data.csv (general time series with trend and seasonality)
# - stock_prices.csv (synthetic stock price data)
# - sales_data.csv (sales data with weekly patterns)
# - temperature_data.csv (temperature data with annual seasonality)
# - website_traffic.csv (website traffic with growth trends)

# Or generate basic sample data:
from utils.data_loader import generate_sample_data
df = generate_sample_data(n_days=365)
df.to_csv('data/sample_data.csv')

# Customize data generation:
# Edit generate_sample_datasets.py to modify:
# - Number of days/periods
# - Date ranges
# - Trend and seasonality patterns
# - Noise levels

Using Your Own Time Series Data

Use your own time series data for analysis:

# Steps to use your own time series data:

# 1. Prepare your CSV file
#    - Required: date, value columns
#    - Date: YYYY-MM-DD format or any parseable date format
#    - Value: Numeric values

# 2. Load and validate data
import pandas as pd
from utils.data_loader import load_time_series_data

df = load_time_series_data('your_data.csv')
# Automatically converts date column to DatetimeIndex

# 3. Create dashboard
from utils.visualizations import plot_time_series
fig = plot_time_series(df)
fig.write_html('dashboard.html')

# 4. Verify data format
#    - Check date column is parseable
#    - Ensure no missing values in required columns
#    - Verify value column contains numeric data
#    - Check for proper DatetimeIndex

# 5. Use with all analysis types
#    - All analysis types work with your data
#    - Advanced features (ARIMA, forecasting) work automatically
#    - Preprocessing handles missing values and outliers

Troubleshooting & Best Practices | Common Issues | Performance Optimization | Best Practices

Common Issues

Port Already in Use: Change port in .streamlit/config.toml (default: 8501). Or stop the process using the port: lsof -ti:8501 | xargs kill
Data File Not Found: Ensure your CSV file exists with required columns (date, value). Use generate_sample_datasets.py to create sample data
Import Errors: Verify all dependencies installed: pip install -r requirements.txt. Check Python version (3.8+)
Date Format Errors: Ensure date column is in parseable format (YYYY-MM-DD). Use pd.to_datetime() to convert
Dashboard Not Rendering: Check browser console for JavaScript errors. Verify Plotly is loaded correctly
Slow Performance: Reduce data size, use resampling for large datasets, or process data in chunks
Memory Issues: Reduce number of data points, use data resampling, or process data in chunks
Export Not Working: Ensure kaleido is installed for image export: pip install kaleido
Prophet Installation Issues: Install Prophet: pip install prophet. May require additional dependencies on Windows
ARIMA Model Errors: Ensure statsmodels is installed: pip install statsmodels
Forecasting Not Working: Verify date column exists and is in datetime format. Check data has sufficient history
Decomposition Issues: Ensure data has sufficient periods for decomposition. Minimum 2 full seasonal cycles recommended
HTML Files Not Opening: Open HTML files in modern browser (Chrome, Firefox, Edge). Check file path is correct
Template Issues: Verify template name is valid. Use 'plotly', 'plotly_white', 'plotly_dark', 'ggplot2', etc.

Performance Optimization Tips

Data Size: Sample large datasets or use data resampling to reduce number of points
Visualization Type: Use simpler plots for large datasets (time series plots are faster than complex decompositions)
Window Adjustment: Adjust moving average window based on data frequency (smaller for daily, larger for monthly)
Caching: Cache processed data results to avoid repeated calculations
Data Preprocessing: Pre-process and validate data before creating visualizations
Date Validation: Validate date format early to avoid processing errors
HTML File Size: Large HTML files may load slowly. Consider exporting as images for sharing
Browser Performance: Use modern browsers for best performance. Clear cache if issues occur

Best Practices

Data Quality: Ensure data is clean, dates are valid, and value columns are numeric
Date Format: Always validate date format and convert to DatetimeIndex for proper time series analysis
Value Columns: Ensure value column contains numeric values. Handle missing values appropriately
Data Size: For large datasets (10K+ points), consider resampling or aggregation
Plot Templates: Choose appropriate plot templates for your visualization needs (light, dark, etc.)
Error Handling: Add error handling in visualization functions to prevent crashes
Data Validation: Validate data format and types before processing
Export Formats: Use HTML for interactive sharing, PNG/PDF for reports and presentations
Forecast Methods: Choose appropriate forecast methods (Prophet for seasonality, ARIMA for stationary data)
Documentation: Document custom modifications and data sources
Testing: Test with different data sizes and time ranges
Sharing: HTML files are standalone and portable. Share via email, cloud storage, or web hosting

Use Cases and Applications

Stock Price Analysis: Analyze stock price trends and forecast future prices
Sales Forecasting: Forecast sales trends and identify seasonal patterns
Temperature Analysis: Analyze temperature trends and annual seasonality
Website Traffic Analysis: Track website traffic trends and growth patterns
Outlier Detection: Identify anomalies in time series data automatically
ARIMA Modeling: Advanced time series modeling and forecasting
Seasonality Analysis: Compare data across different time periods and seasons
Trend Pattern Analysis: Identify patterns and trends in temporal data
Business Analytics: Analyze business metrics over time for insights
Time Series Reporting: Generate time series reports and presentations

Performance Benchmarks

Expected performance for different time series data sizes:

Data Size	Data Points	Load Time	Dashboard Render	Memory Usage
Small	100 - 1K	< 1 second	< 1 second	< 50 MB
Medium	1K - 10K	1-2 seconds	1-3 seconds	50-150 MB
Large	10K - 100K	2-5 seconds	3-8 seconds	150-400 MB
Very Large	100K+	5-15 seconds	8-20 seconds	400+ MB

Note: Performance depends on hardware, data complexity, and analysis type. Basic plots are faster than complex decompositions. Consider data resampling for very large datasets.

System Requirements

Recommended system requirements for optimal performance:

Component	Minimum	Recommended	Optimal
Python	3.8	3.9+	3.10+
RAM	4 GB	8 GB	16 GB+
CPU	2 cores	4 cores	8+ cores
Storage	100 MB	500 MB	1 GB+
Browser	Chrome 90+	Chrome 100+	Latest

Note: Time series dashboards run in browser. No GPU required. Performance scales with data size. HTML files are interactive and can be shared easily.

Real-World Examples & Use Cases | Time Series Dashboard Use Cases | Temporal Analysis Examples

Example 1: Stock Price Analysis

Analyze stock price trends and forecast future prices:

# 1. Load stock price data
from utils.data_loader import load_time_series_data
df = load_time_series_data('data/stock_prices.csv')
# Or generate: from utils.data_loader import generate_stock_price_data

# 2. Create time series plot
from utils.visualizations import plot_time_series
fig1 = plot_time_series(df, title='Stock Price Over Time')
fig1.show()

# 3. Analyze trend
from utils.visualizations import plot_trend_analysis
fig2 = plot_trend_analysis(df, window=30, title='Stock Price Trend')
fig2.show()

# 4. Forecast future prices
from utils.visualizations import plot_forecast
fig3 = plot_forecast(df, method='prophet', forecast_periods=30, title='Stock Price Forecast')
fig3.show()

# 5. Analyze patterns
# - Identify long-term trends
# - Detect seasonality
# - Forecast future values
# - Evaluate model performance

Example 2: Sales Data Analysis

Analyze sales trends and seasonal patterns:

# Use Case: Sales data analysis

# 1. Load sales data
from utils.data_loader import load_time_series_data
df = load_time_series_data('data/sales_data.csv')

# 2. Detect seasonality
from utils.visualizations import plot_seasonality
fig1 = plot_seasonality(df, period=7, title='Weekly Sales Patterns')
fig1.show()

# 3. Decompose time series
from utils.visualizations import plot_decomposition
fig2 = plot_decomposition(df, model='additive', period=7, title='Sales Decomposition')
fig2.show()

# 4. Forecast sales
from utils.visualizations import plot_forecast
fig3 = plot_forecast(df, method='prophet', forecast_periods=30, title='Sales Forecast')
fig3.show()

# 5. Analyze patterns
# - Identify weekly patterns
# - Understand seasonal effects
# - Forecast future sales
# - Plan inventory and resources

Example 3: Temperature Data Analysis

Analyze temperature trends and annual seasonality:

# Use Case: Temperature data analysis

# 1. Load temperature data
from utils.data_loader import load_time_series_data
df = load_time_series_data('data/temperature_data.csv')

# 2. Analyze annual seasonality
from utils.visualizations import plot_seasonality
fig1 = plot_seasonality(df, period=365, title='Annual Temperature Patterns')
fig1.show()

# 3. Detect outliers
from utils.advanced_visualizations import plot_outliers
fig2 = plot_outliers(df, method='iqr', title='Temperature Outliers')
fig2.show()

# 4. Rolling statistics
from utils.advanced_visualizations import plot_rolling_statistics
fig3 = plot_rolling_statistics(df, window=30, title='Rolling Temperature Statistics')
fig3.show()

# 5. Analyze patterns
# - Identify annual cycles
# - Detect extreme temperatures
# - Understand variability
# - Climate trend analysis

Example 4: ARIMA Forecasting

Advanced forecasting using ARIMA models:

# Use Case: ARIMA forecasting

# 1. Load time series data
from utils.data_loader import load_time_series_data
df = load_time_series_data('data/sample_data.csv')

# 2. ACF/PACF analysis for model selection
from utils.advanced_visualizations import plot_acf_pacf
fig1 = plot_acf_pacf(df, lags=40, title='ACF/PACF Analysis')
fig1.show()

# 3. ARIMA forecasting
from utils.advanced_visualizations import plot_arima_forecast
fig2, model = plot_arima_forecast(
    df,
    order=(1,1,1),  # ARIMA(p,d,q) parameters
    forecast_periods=30,
    title='ARIMA Forecast'
)
fig2.show()

# 4. Model evaluation
from utils.model_evaluation import calculate_metrics, print_metrics
metrics = calculate_metrics(df, model)
print_metrics(metrics)

# 5. Use cases:
# - Advanced forecasting
# - Model selection
# - Performance evaluation
# - Complex time series patterns

Example 5: Website Traffic Analysis

Analyze website traffic trends and growth patterns:

# Use Case: Website traffic analysis

# 1. Load website traffic data
from utils.data_loader import load_time_series_data
df = load_time_series_data('data/website_traffic.csv')

# 2. Analyze growth trends
from utils.visualizations import plot_trend_analysis
fig1 = plot_trend_analysis(df, window=30, title='Traffic Growth Trend')
fig1.show()

# 3. Detect weekly patterns
from utils.visualizations import plot_seasonality
fig2 = plot_seasonality(df, period=7, title='Weekly Traffic Patterns')
fig2.show()

# 4. Forecast future traffic
from utils.visualizations import plot_forecast
fig3 = plot_forecast(df, method='prophet', forecast_periods=30, title='Traffic Forecast')
fig3.show()

# 5. Use cases:
# - Growth trend analysis
# - Weekly pattern identification
# - Capacity planning
# - Marketing campaign evaluation

Integration Examples | Database Integration | API Integration | Web Integration

Integration with Database

Load time series data from SQL database:

# Load time series data from SQL database

import sqlite3
import pandas as pd
from utils.visualizations import plot_time_series

def load_time_series_from_db():
    """Load time series data from SQL database."""
    conn = sqlite3.connect('time_series_data.db')
    query = """
        SELECT 
            date,
            value
        FROM time_series
        ORDER BY date
    """
    df = pd.read_sql_query(query, conn, parse_dates=['date'], index_col='date')
    conn.close()
    
    return df

# Load and create dashboard
df = load_time_series_from_db()
fig = plot_time_series(df)
fig.write_html('dashboard_from_db.html')

# For MySQL/PostgreSQL:
# import mysql.connector
# conn = mysql.connector.connect(
#     host='localhost',
#     user='username',
#     password='password',
#     database='time_series_db'
# )

Integration with REST API

Load time series data from REST API endpoint:

# Load time series data from REST API

import requests
import pandas as pd
from utils.visualizations import plot_time_series

def load_time_series_from_api():
    """Load time series data from REST API."""
    response = requests.get(
        'https://api.example.com/timeseries',
        headers={'Authorization': 'Bearer YOUR_TOKEN'}
    )
    data = response.json()
    df = pd.DataFrame(data['timeseries'])
    
    # Ensure required columns exist
    df['date'] = pd.to_datetime(df['date'])
    df.set_index('date', inplace=True)
    
    return df

# Load and create dashboard
df = load_time_series_from_api()
fig = plot_time_series(df)
fig.write_html('dashboard_from_api.html')

# For real-time updates, refresh data periodically:
import time
while True:
    df = load_time_series_from_api()
    fig = plot_time_series(df)
    fig.write_html('dashboard_live.html')
    time.sleep(300)  # Update every 5 minutes

Embedding Dashboards in Web Pages

Embed interactive dashboards in existing websites:

# Embed Dashboard in Web Page:

# Option 1: Direct HTML embedding
# The generated HTML files are standalone and can be embedded:

<iframe src="path/to/dashboard.html" 
        width="100%" 
        height="700px" 
        frameborder="0">
</iframe>

# Option 2: Use Plotly's HTML output
from utils.visualizations import plot_time_series
fig = plot_time_series(df)

# Get HTML div and script
html_div = fig.to_html(include_plotlyjs='cdn', div_id='dashboard-div')

# Embed in your HTML page:
# <div id="dashboard-div"></div>
# <script>...plotly.js code...</script>

# Option 3: Serve HTML files via web server
# Place HTML files in web server directory
# Access via: https://yourdomain.com/dashboards/dashboard.html

# Option 4: Use Flask/Django to serve dashboards
from flask import Flask, send_file
from generate_dashboard import generate_html_dashboard
app = Flask(__name__)

@app.route('/dashboard')
def show_dashboard():
    generate_html_dashboard(df, output_file='static/dashboard.html')
    return send_file('static/dashboard.html')

Sharing Dashboards

Share interactive dashboards with others:

# Sharing Dashboard Options:

# 1. Share HTML files directly
# - HTML files are standalone and portable
# - Can be opened in any browser
# - No server required
# - Share via email, cloud storage, etc.

# 2. Upload to web hosting
# - Upload HTML files to web server
# - Share URL with team members
# - Files remain interactive

# 3. Export as images (for reports)
from utils.visualizations import plot_time_series
fig = plot_time_series(df)
fig.write_image('dashboard.png', width=1920, height=1080)
# Use in presentations, reports, documents

# 4. Use Plotly Chart Studio (optional)
# Upload to Plotly Chart Studio for cloud hosting
# fig.write_html('dashboard.html')
# Then upload to chart-studio.plotly.com

# 5. GitHub Pages
# - Push HTML files to GitHub repository
# - Enable GitHub Pages
# - Share public URL

Contact Information | Support | Get Help | Contact RSK World

Get in Touch

Developer: Molla Samser
Designer & Tester: Rima Khatun

rskworld.in

help@rskworld.in support@rskworld.in

+91 93305 39277

License | Open Source License | Project License

This project is for educational purposes only. See LICENSE file for more details.

Theme Settings

Color Scheme

Display Options

Font Size