RSK World - Stock Market Candlestick Charts Documentation | Plotly | Financial Data Visualization | Technical Analysis | Python | Interactive Charts | RSI | MACD | Bollinger Bands | Pattern Recognition | Backtesting | Portfolio Analysis | RSK World

Stock Market Candlestick Charts - Project Description | Plotly | Financial Data Visualization | Interactive Charts

This project creates comprehensive Stock Market Candlestick Charts using Plotly for financial data visualization and technical analysis. The project includes interactive candlestick charts with zoom and pan functionality, technical indicators (RSI, MACD, Bollinger Bands, Stochastic, ADX, ATR, CCI, OBV), pattern recognition to detect candlestick patterns (Doji, Hammer, Shooting Star, Engulfing patterns, Three White Soldiers, Three Black Crows), backtesting strategies (MA crossover, RSI, MACD) with performance metrics, portfolio analysis with correlation matrices and weighted returns, volume analysis with volume bars and volume SMA, support and resistance levels identification, price targets (Fibonacci, Pivot-based), alert system for RSI levels, price targets, volume spikes, and pattern detection, export functionality (HTML, PNG, PDF, CSV, Excel), real-time data fetching using yfinance, and data validation and cleaning functions. Perfect for stock market analysis, trading strategy development, technical analysis, and financial data visualization.

The Stock Market Candlestick Charts project features 3 comprehensive Jupyter notebooks covering basic candlestick charts (candlestick_charts.ipynb), advanced analysis (advanced_analysis.ipynb), and complete features demonstration (features_demo.ipynb). The project includes 13 Python modules (data_fetcher.py for stock data fetching, technical_indicators.py for indicator calculations, pattern_recognition.py for pattern detection, chart_builder.py for chart creation, chart_types.py for additional chart types, export_utils.py for export functionality, backtesting.py for strategy backtesting, alerts.py for alert system, portfolio.py for portfolio analysis, validation.py for data validation, utils.py for utility functions, and config.py for configuration). Built with Python 3.7+, Plotly 5.18.0+, Pandas 2.0.0+, NumPy 1.24.0+, yfinance 0.2.28+, Jupyter 1.0.0+, Notebook 7.0.0+, ipykernel 6.25.0+, scipy 1.11.0+, and optional kaleido 0.2.1+ for image export and openpyxl 3.1.0+ for Excel export. The project supports real-time stock data fetching for any ticker symbol. Default chart template is plotly_dark with height of 800 pixels.

Stock Market Candlestick Charts Screenshots | Plotly Candlestick Charts | Interactive Chart Examples

1 / 4

Stock Market Candlestick Charts Core Features | Plotly Candlestick Chart Features | Interactive Chart Features

Interactive Candlestick Charts

Interactive candlestick charts
Zoom and pan functionality
Hover tooltips with OHLC data
Customizable styling
Multiple timeframes

Technical Indicators (15+)

RSI (14), MACD (12,26,9), Stochastic (14)
Bollinger Bands (20,2), ADX (14), ATR (14)
Moving Averages: SMA (20,50), EMA (12,26)
Volume indicators: OBV, Volume SMA
Williams %R (14), CCI (20) - 15+ indicators

Pattern Recognition

Doji, Hammer, Shooting Star
Bullish/Bearish Engulfing patterns
Three White Soldiers
Three Black Crows
Pattern summary reports with counts

Backtesting Framework

MA Crossover Strategy
RSI-based Strategy
MACD Crossover Strategy
Performance metrics
Strategy comparison

Portfolio Analysis

Multi-stock portfolios
Correlation analysis
Weighted returns
Performance metrics
Holdings comparison

3 Jupyter Notebooks

candlestick_charts.ipynb
advanced_analysis.ipynb
features_demo.ipynb
Step-by-step examples
Interactive learning

Advanced Candlestick Charts Features | Pattern Recognition | Backtesting | Portfolio Analysis

Alert System

RSI alerts
Price target alerts
Volume spike detection
Pattern detection alerts

Support & Resistance

Automatic level detection
Price target calculation
Fibonacci retracements
Pivot-based targets

Export Functionality

HTML, PNG, PDF export
CSV and Excel export
Summary reports
Custom dimensions

Volume Analysis

Volume bars visualization
Volume moving averages
Volume trend analysis
Volume ratio calculations
OBV indicator

Analysis Types | Candlestick Chart Analysis Types | Interactive Chart Features

Analysis Type	Description	Use Case
Candlestick Charts	Interactive candlestick charts showing OHLC data over time	Visualize stock price movements, trends, and patterns
Technical Indicators (15+)	RSI (14), MACD (12,26,9), Bollinger Bands (20,2), Stochastic (14), ADX (14), ATR (14), CCI (20), OBV, SMA (20,50), EMA (12,26), Williams %R (14)	Identify trading signals and market conditions
Pattern Recognition	Detect candlestick patterns: Doji, Hammer, Shooting Star, Bullish/Bearish Engulfing, Three White Soldiers, Three Black Crows	Identify potential reversal or continuation patterns
Backtesting	Test trading strategies (MA crossover, RSI, MACD)	Evaluate strategy performance with historical data
Portfolio Analysis	Multi-stock portfolio with correlation and weighted returns	Analyze portfolio performance and diversification
Volume Analysis	Volume bars, volume SMA, OBV, volume trends	Understand market participation and volume patterns
Support & Resistance	Automatic identification of key price levels	Identify potential entry and exit points
Price Targets	Fibonacci retracements and pivot-based targets	Set price targets for trading decisions
Alert System	Automated alerts for RSI, price targets, volume, patterns	Get notified of important market events
Statistical Analysis	Volatility, Sharpe Ratio, Max Drawdown, Returns	Evaluate risk and return metrics

Technologies Used | Python Technologies | Financial Analysis Stack | Trading Tools

This Stock Market Candlestick Charts project is built using modern Python financial data visualization and technical analysis technologies. The core implementation uses Python 3.7+ as the primary programming language and Plotly 5.18.0+ for creating interactive candlestick charts. The project includes Pandas 2.0.0+ for data manipulation, NumPy 1.24.0+ for numerical computing, yfinance 0.2.28+ for real-time stock data fetching, Jupyter 1.0.0+ and Notebook 7.0.0+ for interactive development, ipykernel 6.25.0+ for Jupyter kernel support, scipy 1.11.0+ for scientific computing, and optional kaleido 0.2.1+ for image export and openpyxl 3.1.0+ for Excel export. The visualization library features interactive candlestick charts with zoom and pan, 15+ technical indicators (RSI 14, MACD 12/26/9, Bollinger Bands 20/2, Stochastic 14, ADX 14, ATR 14, CCI 20, OBV, SMA 20/50, EMA 12/26, Williams %R 14), pattern recognition (Doji, Hammer, Shooting Star, Engulfing patterns, Three White Soldiers, Three Black Crows), backtesting strategies, portfolio analysis, volume analysis, support and resistance levels, price targets, alert system, and export functionality for stock market analysis, trading strategy development, and technical analysis applications.

The project uses Plotly as the core visualization library for creating interactive candlestick charts with Python. It supports financial data visualization through interactive candlestick charts with plotly_dark as the default template and 800px default height, 15+ technical indicators (RSI 14, MACD 12/26/9, Bollinger Bands 20/2, Stochastic 14, ADX 14, ATR 14, CCI 20, OBV, SMA 20/50, EMA 12/26, Williams %R 14), pattern recognition (Doji, Hammer, Shooting Star, Bullish/Bearish Engulfing patterns, Three White Soldiers, Three Black Crows), backtesting strategies (MA crossover, RSI, MACD) with performance metrics, portfolio analysis with correlation matrices and weighted returns, volume analysis with volume bars and OBV, support and resistance levels, price targets (Fibonacci, Pivot-based), alert system, and export functionality (HTML, PNG, PDF, CSV, Excel). The project includes real-time stock data fetching using yfinance for any ticker symbol. The system includes interactive features such as zoom and pan, hover tooltips with OHLC data, customizable styling, multiple chart types (line, area, heatmaps, box plots, histograms), and HTML chart export capabilities for stock market analysis, trading strategy development, technical analysis, and financial data visualization applications.

Python 3.7+ Plotly 5.18.0+ yfinance 0.2.28+ Pandas 2.0.0+ NumPy 1.24.0+ Jupyter 1.0.0+ 15+ Technical Indicators Pattern Recognition Backtesting Portfolio Analysis scipy 1.11.0+

Installation & Usage Guide | How to Install Candlestick Charts | Setup Tutorial

Installation

Version: v1.0.0 (December 2025)

Install all required dependencies for the Stock Market Candlestick Charts 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 candlestick charts examples:

# Start Jupyter Notebook
jupyter notebook

# Or use JupyterLab
jupyter lab

# Open the notebooks:
# - candlestick_charts.ipynb - Main analysis notebook with basic features
#   * Interactive candlestick charts
#   * Technical indicators
#   * Volume analysis
#   * Multi-stock comparison
# - advanced_analysis.ipynb - Advanced features notebook
#   * Pattern recognition
#   * Advanced indicators
#   * Statistical analysis
#   * Export functionality
# - features_demo.ipynb - Complete features demonstration
#   * All features in one place
#   * Comprehensive examples

Running Example Scripts

Run Python scripts to generate candlestick charts:

# Run complete example (generates basic candlestick chart):
python example.py

# This will:
# - Fetch stock data using yfinance
# - Create interactive candlestick chart
# - Add technical indicators
# - Display the chart

# Example usage in Python:
from src.data_fetcher import fetch_stock_data
from src.chart_builder import create_candlestick_chart

# Fetch stock data
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# Create interactive chart
fig = create_candlestick_chart(data, ticker='AAPL')
fig.show()

Project Features

Explore the comprehensive candlestick charts features:

# Project Features (v1.0.0 - December 2025):
# 1. Interactive Candlestick Charts - Beautiful, interactive charts with Plotly (default: plotly_dark theme, 800px height)
# 2. Technical Indicators (15+) - RSI (14), MACD (12/26/9), Bollinger Bands (20/2), Stochastic (14), ADX (14), ATR (14), CCI (20), OBV, SMA (20/50), EMA (12/26), Williams %R (14)
# 3. Pattern Recognition - Doji, Hammer, Shooting Star, Bullish/Bearish Engulfing patterns, Three White Soldiers, Three Black Crows
# 4. Backtesting Strategies - MA crossover, RSI, MACD with performance metrics (Returns, Sharpe Ratio, Max Drawdown, Win Rate)
# 5. Portfolio Analysis - Multi-stock portfolios with correlation matrices and weighted returns
# 6. Volume Analysis - Volume bars, volume SMA, OBV, volume trends
# 7. Support & Resistance - Automatic identification of key price levels
# 8. Price Targets - Fibonacci retracements and pivot-based targets
# 9. Alert System - Automated alerts for RSI levels, price targets, volume spikes, pattern detection
# 10. Export Functionality - HTML (interactive), PNG, PDF (requires kaleido), CSV, Excel (requires openpyxl)
# 11. Real-time Data Fetching - Fetch live stock data using yfinance for any ticker symbol
# 12. Data Validation - Automatic data validation and cleaning functions
# 13. Multiple Chart Types - Line charts, area charts, correlation heatmaps, box plots, distribution histograms
# 14. Statistical Analysis - Volatility, Sharpe Ratio, Max Drawdown, Returns analysis
# 15. 3 Jupyter Notebooks - candlestick_charts.ipynb, advanced_analysis.ipynb, features_demo.ipynb
# 16. 13 Python Modules - data_fetcher, technical_indicators, pattern_recognition, chart_builder, chart_types, export_utils, backtesting, alerts, portfolio, validation, utils, config, __init__

# All features are demonstrated in the Jupyter notebooks

Basic Usage Example

Create candlestick charts with Python:

# Basic Usage Example:
from src.data_fetcher import fetch_stock_data
from src.chart_builder import create_candlestick_chart
from src.technical_indicators import add_all_indicators
from src.pattern_recognition import detect_all_patterns

# Fetch stock data
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# Create basic candlestick chart
fig1 = create_candlestick_chart(data, ticker='AAPL')
fig1.show()

# Add technical indicators
data_with_indicators = add_all_indicators(data)

# Detect patterns
data_complete = detect_all_patterns(data_with_indicators)

# Create advanced chart with indicators and patterns
fig2 = create_candlestick_chart(data_complete, ticker='AAPL', show_indicators=True, show_patterns=True)
fig2.show()

Project Structure | Candlestick Charts File Structure | Source Code Organization

                candlestick-charts/

                ├── README.md                          # Main documentation

                ├── FEATURES.md                        # Complete features list

                ├── RELEASE_NOTES.md                   # Release notes (v1.0.0 - Dec 2025)

                ├── requirements.txt                   # Python dependencies

                ├── .gitignore                         # Git ignore file

                ├── example.py                         # Quick start Python script

                │

                ├── candlestick_charts.ipynb           # Main analysis notebook

                │   # Basic candlestick charts, standard indicators

                │   # Volume analysis, multi-stock comparison

                │

                ├── advanced_analysis.ipynb            # Advanced features notebook

                │   # Pattern recognition, advanced indicators

                │   # Statistical analysis, export functionality

                │

                ├── features_demo.ipynb               # Complete features demo

                │   # All features in one place

                │

                ├── src/                               # Source modules (13 modules)

                │   ├── __init__.py                    # Package initialization

                │   ├── config.py                      # Configuration settings (defaults, periods, colors)

                │   ├── data_fetcher.py                # Stock data fetching (yfinance)

                │   ├── technical_indicators.py        # Technical indicators (15+ indicators)

                │   ├── pattern_recognition.py         # Pattern detection (6 patterns)

                │   ├── chart_builder.py               # Chart creation (Plotly)

                │   ├── chart_types.py                 # Additional chart types

                │   ├── export_utils.py                # Export functionality (HTML/PNG/PDF/CSV/Excel)

                │   ├── utils.py                       # Utility functions

                │   ├── backtesting.py                 # Strategy backtesting (MA/RSI/MACD)

                │   ├── alerts.py                      # Alert system

                │   ├── portfolio.py                   # Portfolio analysis

                │   └── validation.py                  # Data validation

                │

                └── exports/                           # Export directory (auto-created)

Configuration Options | Plotly Configuration | Candlestick Charts Customization Guide

Plotly Configuration

Version: v1.0.0 (December 2025) | Default Template: plotly_dark | Default Height: 800px

Customize candlestick charts visualization settings in Python code:

# Plotly Configuration for Candlestick Charts

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

# Default configuration in src/config.py and src/chart_builder.py functions:
# - template: 'plotly_dark' (can be 'plotly', 'plotly_white', 'plotly_dark', 'ggplot2', etc.)
# - height: 800 (figure height in pixels)
# - width: None (auto, can be set to specific pixels)
# - showlegend: True (show legend for indicators)

# Customize in function calls:
from src.chart_builder import create_candlestick_chart
from src.data_fetcher import fetch_stock_data

data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')
fig = create_candlestick_chart(
    data,
    ticker='AAPL',
    title='Custom Candlestick Chart',  # Custom title
    height=1000,                        # Adjust height (default: 800)
    template='plotly_white'            # Change template (default: plotly_dark)
)

# Modify default settings in src/config.py:
# - DEFAULT_CHART_TEMPLATE = 'plotly_dark'
# - DEFAULT_CHART_HEIGHT = 800
# - DEFAULT_RSI_PERIOD = 14
# - DEFAULT_MACD_FAST = 12, DEFAULT_MACD_SLOW = 26, DEFAULT_MACD_SIGNAL = 9
# - And many more configuration options

Configuration Tips:

TEMPLATE: Choose from 'plotly', 'plotly_white', 'plotly_dark', 'ggplot2', 'seaborn', 'simple_white', etc. Default: 'plotly_dark' (configured in src/config.py)
INDICATOR_PERIODS: Adjust indicator periods (RSI: 14, MACD: 12/26/9, SMA: 20/50, EMA: 12/26, Bollinger: 20/2, Stochastic: 14, ADX: 14, ATR: 14, Williams %R: 14, CCI: 20). Customize in src/config.py
SHOW_INDICATORS: Toggle technical indicators display (15+ indicators available). Default: True
SHOW_PATTERNS: Enable pattern recognition markers on chart (Doji, Hammer, Shooting Star, Engulfing, Three White Soldiers, Three Black Crows). Default: False
HEIGHT: Set figure height in pixels. Default: 800 (configured in src/config.py). Adjust for different screen sizes
EXPORT_FORMAT: HTML (interactive), PNG, PDF (requires kaleido 0.2.1+ package), CSV, Excel (requires openpyxl 3.1.0+)

Stock Data Format Requirements

Works with stock data from yfinance. Required structure:

# Supported data formats:
# - Pandas DataFrame with DatetimeIndex (from yfinance)
# - OHLCV data (Open, High, Low, Close, Volume columns)

# Required DataFrame structure from yfinance:
from src.data_fetcher import fetch_stock_data

# Fetch stock data (automatically returns proper format):
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# Required columns:
# - Date (DatetimeIndex)
# - Open (numeric)
# - High (numeric)
# - Low (numeric)
# - Close (numeric)
# - Volume (numeric)

# Example structure:
# Date       Open    High    Low     Close   Volume
# 2024-01-01 150.0   152.0   149.0   151.0   1000000
# 2024-01-02 151.0   153.0   150.0   152.0   1200000

# Works with:
# - Any stock ticker symbol (AAPL, GOOGL, MSFT, etc.)
# - Custom date ranges
# - Multiple timeframes (daily, weekly, monthly)

Customizing Chart Appearance

Modify chart configurations in src/chart_builder.py or src/config.py:

# Chart customization in Python:

from src.chart_builder import create_candlestick_chart
from src.data_fetcher import fetch_stock_data
import plotly.graph_objects as go

# Fetch stock data
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# Create candlestick chart
fig = create_candlestick_chart(data, ticker='AAPL')

# Customize layout:
fig.update_layout(
    title={
        'text': 'Custom Candlestick Chart',
        '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="Price",
    title_font=dict(size=16),
    tickfont=dict(size=12)
)

# Save customized chart
fig.write_html('custom_chart.html')

Adding Custom Candlestick Chart Visualizations

Add new candlestick chart visualizations using Plotly:

# Add new visualization function to src/chart_builder.py:

import plotly.graph_objects as go
import pandas as pd

def create_custom_candlestick_chart(data, ticker='', **kwargs):
    """Create a custom candlestick chart visualization."""
    
    fig = go.Figure()
    
    # Add candlestick trace
    fig.add_trace(go.Candlestick(
        x=data.index,
        open=data['Open'],
        high=data['High'],
        low=data['Low'],
        close=data['Close'],
        name=ticker or 'Stock',
        increasing_line_color='#26a69a',
        decreasing_line_color='#ef5350'
    ))
    
    # Update layout
    fig.update_layout(
        title=kwargs.get('title', f'Custom Candlestick Chart - {ticker}'),
        xaxis_title='Date',
        yaxis_title='Price',
        height=kwargs.get('height', 600),
        template=kwargs.get('template', 'plotly_white'),
        hovermode='x unified',
        xaxis_rangeslider_visible=False
    )
    
    # Save if output file provided
    if kwargs.get('output_file'):
        fig.write_html(kwargs['output_file'])
        print(f"Chart saved as '{kwargs['output_file']}'")
    
    return fig

# Use in your code:
from src.data_fetcher import fetch_stock_data
from src.chart_builder import create_custom_candlestick_chart

data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')
fig = create_custom_candlestick_chart(data, 
                                      ticker='AAPL',
                                      title='My Custom Candlestick Chart',
                                      output_file='custom_chart.html')

Project Architecture | Candlestick Charts Architecture | System Architecture | Technical Architecture

Candlestick Charts Architecture

1. Plotly Visualization Framework:

Built on Plotly for interactive candlestick charts
Uses Plotly Graph Objects for advanced customization
Candlestick charts with OHLC data visualization
Interactive HTML output with zoom, pan, and hover
Subplot support for indicators and volume panels

2. Data Processing Pipeline:

yfinance for real-time stock data fetching
Pandas DataFrame for OHLCV data manipulation
DatetimeIndex validation and conversion
Data validation and cleaning functions
Technical indicator calculations

3. Analysis Components:

Candlestick charts for price visualization
Technical indicators (RSI, MACD, Bollinger Bands, etc.)
Pattern recognition algorithms
Backtesting framework for trading strategies
Portfolio analysis with correlation matrices

Module Structure

The project is organized into focused modules:

# Module Structure:
# src/chart_builder.py - Chart creation functions
from src.chart_builder import (
    create_candlestick_chart,     # Main candlestick chart
    create_chart_with_indicators, # Chart with technical indicators
    create_chart_with_patterns,   # Chart with pattern markers
    create_multi_stock_chart      # Multi-stock comparison
)

# src/technical_indicators.py - Technical indicator calculations
from src.technical_indicators import (
    add_all_indicators,            # Add all indicators to data
    calculate_rsi,                # RSI calculation
    calculate_macd,                # MACD calculation
    calculate_bollinger_bands,    # Bollinger Bands calculation
    calculate_stochastic,          # Stochastic Oscillator
    calculate_adx                 # ADX calculation
)

# src/pattern_recognition.py - Pattern detection
from src.pattern_recognition import (
    detect_all_patterns,           # Detect all candlestick patterns
    get_pattern_summary,          # Get pattern summary
    detect_doji,                   # Doji pattern detection
    detect_hammer,                 # Hammer pattern detection
    detect_engulfing              # Engulfing pattern detection
)

# src/data_fetcher.py - Stock data fetching
from src.data_fetcher import (
    fetch_stock_data,              # Fetch stock data from yfinance
    fetch_multiple_stocks,         # Fetch multiple stocks
    validate_stock_data            # Validate fetched data
)

# src/backtesting.py - Strategy backtesting
from src.backtesting import (
    backtest_ma_crossover,         # MA crossover strategy
    backtest_rsi_strategy,         # RSI-based strategy
    backtest_macd_strategy,        # MACD crossover strategy
    calculate_performance_metrics  # Performance metrics
)

# src/portfolio.py - Portfolio analysis
from src.portfolio import (
    create_portfolio,              # Create portfolio
    calculate_portfolio_returns,   # Portfolio returns
    calculate_correlation_matrix,  # Correlation analysis
    analyze_portfolio_performance  # Portfolio performance
)

# src/export_utils.py - Export functionality
from src.export_utils import (
    export_chart_html,             # Export chart as HTML
    export_chart_image,            # Export chart as PNG/PDF
    export_data_csv,               # Export data as CSV
    export_data_excel,             # Export data as Excel
    export_summary_report          # Generate summary report
)

Data Format and Processing

How stock data is processed for analysis:

# Data Format Requirements:
# OHLCV data from yfinance (Open, High, Low, Close, Volume)

# Example data structure:
# Date       Open    High    Low     Close   Volume
# 2024-01-01 150.0   152.0   149.0   151.0   1000000
# 2024-01-02 151.0   153.0   150.0   152.0   1200000

# Data Processing Flow:
from src.data_fetcher import fetch_stock_data
from src.validation import validate_stock_data
from src.technical_indicators import add_all_indicators

# Fetch stock data
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')
# Automatically returns DataFrame with DatetimeIndex and OHLCV columns

# Validate data
data = validate_stock_data(data)

# Add technical indicators
data = add_all_indicators(data)

# Create visualization
from src.chart_builder import create_candlestick_chart
fig = create_candlestick_chart(data, ticker='AAPL')
fig.write_html('chart.html')

Analysis Types and Usage

Different candlestick chart analysis types and their use cases:

Candlestick Charts: Interactive OHLC charts using go.Candlestick()
Technical Indicators: RSI, MACD, Bollinger Bands using custom calculations
Pattern Recognition: Candlestick pattern detection using pattern matching algorithms
Volume Analysis: Volume bars and OBV using go.Bar() and volume calculations
Backtesting: Strategy testing using historical data and performance metrics
Portfolio Analysis: Multi-stock analysis using correlation matrices and weighted returns
Support & Resistance: Price level identification using pivot point calculations
Price Targets: Fibonacci and pivot-based targets using mathematical calculations
Statistical Analysis: Volatility, Sharpe Ratio, Max Drawdown using statistical functions
Alert System: Automated alerts using threshold detection and pattern matching

Advanced Features Usage | Candlestick Charts Usage Guide | How to Use Candlestick Charts

Using Basic Chart Functions

How to create different types of candlestick chart visualizations:

# Basic Chart Usage Examples:

from src.data_fetcher import fetch_stock_data
from src.chart_builder import create_candlestick_chart
from src.technical_indicators import add_all_indicators
from src.pattern_recognition import detect_all_patterns

# Fetch stock data
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# 1. Create Basic Candlestick Chart:
fig1 = create_candlestick_chart(data, ticker='AAPL', title='Candlestick Chart')
fig1.show()

# 2. Create Chart with Technical Indicators:
data_with_indicators = add_all_indicators(data)
fig2 = create_candlestick_chart(data_with_indicators, ticker='AAPL', 
                                show_indicators=True, title='Chart with Indicators')
fig2.show()

# 3. Create Chart with Pattern Recognition:
data_complete = detect_all_patterns(data_with_indicators)
fig3 = create_candlestick_chart(data_complete, ticker='AAPL', 
                                show_patterns=True, title='Chart with Patterns')
fig3.show()

# 4. Create Chart with Volume Analysis:
fig4 = create_candlestick_chart(data_with_indicators, ticker='AAPL',
                                show_volume=True, title='Chart with Volume')
fig4.show()

# 5. Create Multi-Stock Comparison:
from src.chart_builder import create_multi_stock_chart
stocks = ['AAPL', 'GOOGL', 'MSFT']
data_multi = fetch_stock_data(stocks, start_date='2024-01-01', end_date='2024-12-31')
fig5 = create_multi_stock_chart(data_multi, tickers=stocks, title='Multi-Stock Comparison')
fig5.show()

Using Advanced Features

Create advanced candlestick chart analysis visualizations:

# Advanced Features Usage:

from src.data_fetcher import fetch_stock_data
from src.backtesting import backtest_ma_crossover, backtest_rsi_strategy, backtest_macd_strategy
from src.portfolio import create_portfolio, calculate_portfolio_returns
from src.alerts import check_rsi_alerts, check_price_alerts
from src.chart_types import create_correlation_heatmap, create_distribution_chart

# Fetch stock data
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# 1. Backtesting Strategies:
results1 = backtest_ma_crossover(data, short_window=20, long_window=50)
print(f"MA Crossover Strategy: {results1}")

results2 = backtest_rsi_strategy(data, oversold=30, overbought=70)
print(f"RSI Strategy: {results2}")

results3 = backtest_macd_strategy(data)
print(f"MACD Strategy: {results3}")

# 2. Portfolio Analysis:
portfolio = create_portfolio(['AAPL', 'GOOGL', 'MSFT'], weights=[0.4, 0.3, 0.3])
portfolio_returns = calculate_portfolio_returns(portfolio, start_date='2024-01-01', end_date='2024-12-31')
print(f"Portfolio Returns: {portfolio_returns}")

# 3. Alert System:
rsi_alerts = check_rsi_alerts(data, oversold=30, overbought=70)
price_alerts = check_price_alerts(data, target_price=150.0)
print(f"RSI Alerts: {rsi_alerts}")
print(f"Price Alerts: {price_alerts}")

# 4. Correlation Heatmap:
stocks_data = fetch_stock_data(['AAPL', 'GOOGL', 'MSFT', 'AMZN'], 
                               start_date='2024-01-01', end_date='2024-12-31')
fig1 = create_correlation_heatmap(stocks_data, tickers=['AAPL', 'GOOGL', 'MSFT', 'AMZN'])
fig1.show()

# 5. Distribution Chart:
fig2 = create_distribution_chart(data, ticker='AAPL')
fig2.show()

Understanding Analysis Types

When to use different analysis types for stock market data:

# Analysis Type Usage Guide:

# 1. Candlestick Charts
#    - Use: Visualize stock price movements with OHLC data
#    - Shows: Candlestick chart with open, high, low, close prices
#    - Best for: Understanding price action, identifying trends
#    - Example: Stock price analysis, trading decisions, market trends

# 2. Technical Indicators
#    - Use: Identify trading signals and market conditions
#    - Shows: RSI, MACD, Bollinger Bands, Stochastic, ADX overlays
#    - Best for: Entry/exit signals, trend confirmation, momentum analysis
#    - Example: RSI oversold/overbought, MACD crossovers, Bollinger Band breakouts

# 3. Pattern Recognition
#    - Use: Identify potential reversal or continuation patterns
#    - Shows: Pattern markers on candlestick chart
#    - Best for: Trading signals, trend reversals, pattern-based trading
#    - Example: Doji reversal, Hammer bottom, Engulfing patterns

# 4. Backtesting
#    - Use: Test trading strategies with historical data
#    - Shows: Strategy performance metrics (returns, Sharpe Ratio, Max Drawdown)
#    - Best for: Strategy validation, performance evaluation, optimization
#    - Example: MA crossover strategy, RSI strategy, MACD strategy

# 5. Portfolio Analysis
#    - Use: Analyze multiple stocks in a portfolio
#    - Shows: Correlation matrix, weighted returns, portfolio performance
#    - Best for: Diversification, risk management, portfolio optimization
#    - Example: Multi-stock portfolios, correlation analysis, risk assessment

# 6. Volume Analysis
#    - Use: Understand market participation and volume patterns
#    - Shows: Volume bars, OBV, volume trends
#    - Best for: Confirming price movements, identifying accumulation/distribution
#    - Example: Volume spikes, OBV trends, volume-price divergence

# 7. Support & Resistance
#    - Use: Identify key price levels for entry/exit
#    - Shows: Support and resistance levels on chart
#    - Best for: Entry/exit points, stop-loss placement, price targets
#    - Example: Pivot points, price levels, breakout identification

# 8. Price Targets
#    - Use: Set price targets for trading decisions
#    - Shows: Fibonacci retracements, pivot-based targets
#    - Best for: Profit targets, risk-reward ratios, position sizing
#    - Example: Fibonacci levels, pivot point targets, extension levels

# 9. Statistical Analysis
#    - Use: Evaluate risk and return metrics
#    - Shows: Volatility, Sharpe Ratio, Max Drawdown, Returns
#    - Best for: Risk assessment, performance evaluation, comparison
#    - Example: Volatility analysis, risk-adjusted returns, drawdown analysis

# 10. Alert System
#    - Use: Get notified of important market events
#    - Shows: Alerts for RSI levels, price targets, volume spikes, patterns
#    - Best for: Automated monitoring, timely notifications, trade execution
#    - Example: RSI alerts, price breakouts, pattern detection alerts

Data Preparation and Customization

Prepare and customize your stock data for analysis:

# Data Preparation Examples:

from src.data_fetcher import fetch_stock_data
from src.validation import validate_stock_data, clean_stock_data
from src.technical_indicators import add_all_indicators
import pandas as pd

# 1. Fetch Stock Data:
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')
# Automatically returns DataFrame with DatetimeIndex and OHLCV columns

# 2. Validate Data:
data = validate_stock_data(data)
# Checks for required columns, data types, and missing values

# 3. Clean Data:
data = clean_stock_data(data)
# Handles missing values, removes invalid data points

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

# 5. Resample Data (daily to weekly/monthly):
data_weekly = data.resample('W').agg({
    'Open': 'first',
    'High': 'max',
    'Low': 'min',
    'Close': 'last',
    'Volume': 'sum'
})

# 6. Add Technical Indicators:
data = add_all_indicators(data)
# Adds RSI, MACD, Bollinger Bands, Stochastic, ADX, ATR, CCI, OBV

# 7. Filter by Volume (remove low volume days):
data_filtered = data[data['Volume'] > data['Volume'].quantile(0.1)]

# 8. Calculate Returns:
data['Returns'] = data['Close'].pct_change()
data['Log_Returns'] = np.log(data['Close'] / data['Close'].shift(1))

Exporting Charts

Export charts to different formats:

# Export Chart Examples:

from src.chart_builder import create_candlestick_chart
from src.data_fetcher import fetch_stock_data
from src.export_utils import export_chart_html, export_chart_image, export_data_csv, export_data_excel

# Fetch stock data
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# Create chart
fig = create_candlestick_chart(data, ticker='AAPL')

# 1. Export as HTML (interactive, default):
export_chart_html(fig, filename='chart.html')
# Or use: fig.write_html('chart.html')
# Opens in browser with full interactivity

# 2. Export as PNG (requires kaleido):
# Install: pip install kaleido
export_chart_image(fig, filename='chart.png', width=1920, height=1080)
# Or use: fig.write_image('chart.png', width=1920, height=1080)

# 3. Export as PDF (requires kaleido):
export_chart_image(fig, filename='chart.pdf')

# 4. Export Data as CSV:
export_data_csv(data, filename='stock_data.csv')

# 5. Export Data as Excel (requires openpyxl):
export_data_excel(data, filename='stock_data.xlsx', sheet_name='AAPL')

# 6. Generate Summary Report:
from src.export_utils import export_summary_report
export_summary_report(data, ticker='AAPL', filename='report.txt')

Complete Candlestick Charts Workflow | Step-by-Step Guide | Chart Tutorial

Step-by-Step Candlestick Charts 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: Fetch real-time stock data
from src.data_fetcher import fetch_stock_data

# Fetch data for any stock ticker
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')
# Automatically returns DataFrame with OHLCV columns

# Option 2: Fetch multiple stocks
stocks = ['AAPL', 'GOOGL', 'MSFT']
data_multi = fetch_stock_data(stocks, start_date='2024-01-01', end_date='2024-12-31')

# Option 3: Use your own OHLCV data
# Prepare CSV file with columns: Date, Open, High, Low, Close, Volume
# Load using pandas:
import pandas as pd
data = pd.read_csv('your_stock_data.csv', parse_dates=['Date'], index_col='Date')

# Data format:
# Date       Open    High    Low     Close   Volume
# 2024-01-01 150.0   152.0   149.0   151.0   1000000
# 2024-01-02 151.0   153.0   150.0   152.0   1200000

Step 3: Create Basic Charts

# Run complete example (generates basic candlestick chart):
python example.py

# This will:
# - Fetch stock data for AAPL
# - Create interactive candlestick chart
# - Add technical indicators
# - Display the chart

# Or create charts programmatically:
from src.data_fetcher import fetch_stock_data
from src.chart_builder import create_candlestick_chart

data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')
fig = create_candlestick_chart(data, ticker='AAPL')
fig.show()

# Export chart:
fig.write_html('chart.html')
# Open HTML file in browser to view interactive chart

Step 4: Explore Jupyter Notebooks

Open candlestick_charts.ipynb for basic tutorial
Open advanced_analysis.ipynb for advanced features
Open features_demo.ipynb for complete features demo
Run cells step-by-step to learn each analysis type
Modify code examples to use different stock tickers
Export charts as HTML, PNG, PDF, CSV, or Excel

Step 5: Customize Charts

# Customize charts in Python code:
from src.chart_builder import create_candlestick_chart
from src.data_fetcher import fetch_stock_data

data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# Change template
fig = create_candlestick_chart(data, ticker='AAPL')
fig.update_layout(template='plotly_dark')

# Adjust indicator periods (modify in src/config.py)
# RSI period: 14 (default)
# MACD: 12, 26, 9 (default)
# SMA: 20, 50 (default)

# Show/hide indicators
from src.technical_indicators import add_all_indicators
data = add_all_indicators(data)
fig = create_candlestick_chart(data, ticker='AAPL', show_indicators=True)

# Show pattern markers
from src.pattern_recognition import detect_all_patterns
data = detect_all_patterns(data)
fig = create_candlestick_chart(data, ticker='AAPL', show_patterns=True)

# Modify src/config.py for default settings
# Modify src/chart_builder.py for advanced configurations

Candlestick Charts Customization Examples | Customization Guide | Code Examples

Customizing Plot Templates

Change plot templates and styling for candlestick charts:

# Customize Plot Templates:

from src.chart_builder import create_candlestick_chart
from src.data_fetcher import fetch_stock_data

data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

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

# Example 1: Use light theme (change from default dark)
fig = create_candlestick_chart(data, ticker='AAPL')
fig.update_layout(template='plotly_white')

# 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')

# Note: Default template is 'plotly_dark' as configured in src/config.py

Adjusting Technical Indicator Periods

Control indicator sensitivity and responsiveness:

# Adjust Technical Indicator Periods:

from src.technical_indicators import calculate_rsi, calculate_macd, calculate_sma
from src.config import INDICATOR_PERIODS

# Modify indicator periods in src/config.py:
# DEFAULT_RSI_PERIOD = 14  # Default: 14 (smaller = more sensitive)
# DEFAULT_MACD_FAST = 12   # Default: 12
# DEFAULT_MACD_SLOW = 26   # Default: 26
# DEFAULT_MACD_SIGNAL = 9  # Default: 9
# DEFAULT_SMA_PERIODS = [20, 50]  # Default: [20, 50] (shorter = more responsive)
# DEFAULT_EMA_PERIODS = [12, 26]  # Default: [12, 26]
# DEFAULT_BOLLINGER_PERIOD = 20  # Default: 20
# DEFAULT_BOLLINGER_STD = 2  # Default: 2
# DEFAULT_STOCHASTIC_PERIOD = 14  # Default: 14
# DEFAULT_ATR_PERIOD = 14  # Default: 14
# DEFAULT_ADX_PERIOD = 14  # Default: 14
# DEFAULT_WILLIAMS_R_PERIOD = 14  # Default: 14
# DEFAULT_CCI_PERIOD = 20  # Default: 20

# Or customize in code:
from src.technical_indicators import add_custom_indicators

# Custom RSI with different period
data['RSI_9'] = calculate_rsi(data, period=9)  # More sensitive
data['RSI_21'] = calculate_rsi(data, period=21)  # Less sensitive

# Custom SMA periods
data['SMA_10'] = calculate_sma(data, period=10)  # Short-term
data['SMA_200'] = calculate_sma(data, period=200)  # Long-term

# Tip: Shorter periods = more responsive, longer periods = smoother

Changing Backtesting Strategies

Use different trading strategies for backtesting:

# Change Backtesting Strategies:

from src.backtesting import backtest_ma_crossover, backtest_rsi_strategy, backtest_macd_strategy
from src.data_fetcher import fetch_stock_data

data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# Available strategies:
# 'ma_crossover' - Moving Average Crossover (default)
# 'rsi' - RSI-based strategy
# 'macd' - MACD Crossover strategy

# Example 1: MA Crossover Strategy
results1 = backtest_ma_crossover(data, short_window=20, long_window=50)
print(f"MA Crossover: Returns={results1['returns']:.2%}, Sharpe={results1['sharpe_ratio']:.2f}")

# Example 2: RSI Strategy
results2 = backtest_rsi_strategy(data, oversold=30, overbought=70)
print(f"RSI Strategy: Returns={results2['returns']:.2%}, Win Rate={results2['win_rate']:.2%}")

# Example 3: MACD Strategy
results3 = backtest_macd_strategy(data)
print(f"MACD Strategy: Returns={results3['returns']:.2%}, Max Drawdown={results3['max_drawdown']:.2%}")

# Tip: MA Crossover works best in trending markets, RSI in ranging markets

Modifying Data Source

Load stock data from different sources:

# Load Stock Data from Different Sources:

from src.data_fetcher import fetch_stock_data
from src.chart_builder import create_candlestick_chart
import pandas as pd

# Option 1: Fetch from yfinance (recommended)
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# Option 2: Fetch multiple stocks
stocks = ['AAPL', 'GOOGL', 'MSFT', 'AMZN']
data_multi = fetch_stock_data(stocks, start_date='2024-01-01', end_date='2024-12-31')

# Option 3: Load from CSV file (OHLCV format)
data = pd.read_csv('your_stock_data.csv', parse_dates=['Date'], index_col='Date')
# Required columns: Date, Open, High, Low, Close, Volume

# Option 4: Load from Excel
data = pd.read_excel('your_stock_data.xlsx', parse_dates=['Date'], index_col='Date')

# Option 5: Load from database
import sqlite3
conn = sqlite3.connect('stock_data.db')
data = pd.read_sql_query("SELECT Date, Open, High, Low, Close, Volume FROM stocks WHERE Ticker='AAPL'", 
                         conn, parse_dates=['Date'], index_col='Date')
conn.close()

# Option 6: Load from API
import requests
response = requests.get('https://api.example.com/stock/AAPL')
api_data = response.json()
data = pd.DataFrame(api_data['ohlcv'])
data['Date'] = pd.to_datetime(data['Date'])
data.set_index('Date', inplace=True)

# Then create chart
fig = create_candlestick_chart(data, ticker='AAPL')
fig.write_html('chart.html')

Customizing Chart Layout

Modify chart appearance and layout settings:

# Customize Chart Layout:

from src.chart_builder import create_candlestick_chart
from src.data_fetcher import fetch_stock_data
import plotly.graph_objects as go

# Fetch stock data
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# Create chart
fig = create_candlestick_chart(data, ticker='AAPL')

# Customize layout
fig.update_layout(
    title={
        'text': 'Custom Candlestick Chart - AAPL',
        'x': 0.5,
        'font': {'size': 24, 'color': '#1e293b'}
    },
    height=1000,  # Adjust height (default: 800)
    width=1200,  # Adjust width (default: None/auto)
    margin=dict(l=50, r=50, t=80, b=50),
    template='plotly_dark'  # Default template (can change to 'plotly_white', etc.)
)

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

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

# Save customized chart
fig.write_html('custom_chart.html')

Stock Data Information | Data Format | OHLCV Format | Data Requirements

Data Format Requirements

The project works with OHLCV format for stock data:

Required columns: Date, Open, High, Low, Close, Volume
Date format: YYYY-MM-DD or any parseable date format
OHLCV: Numeric values for Open, High, Low, Close prices and Volume
Automatic date parsing and DatetimeIndex conversion
Real-time data fetching using yfinance for any stock ticker
Automatic data validation and cleaning

Sample Data Format

Your stock data CSV file should follow this structure:

# CSV file structure (stock_data.csv):
Date,Open,High,Low,Close,Volume
2024-01-01,150.0,152.0,149.0,151.0,1000000
2024-01-02,151.0,153.0,150.0,152.0,1200000
2024-01-03,152.0,154.0,151.0,153.0,1100000
2024-01-04,153.0,155.0,152.0,154.0,1300000
2024-01-05,154.0,156.0,153.0,155.0,1250000

# Column descriptions:
# - Date: Date in YYYY-MM-DD format or any parseable date format
# - Open: Opening price (numeric)
# - High: Highest price of the day (numeric)
# - Low: Lowest price of the day (numeric)
# - Close: Closing price (numeric)
# - Volume: Trading volume (numeric)

# For multiple stocks, use separate files or fetch multiple tickers:
# data = fetch_stock_data(['AAPL', 'GOOGL', 'MSFT'], start_date='2024-01-01', end_date='2024-12-31')

Fetching Stock Data

Use yfinance to fetch real-time stock data for any ticker:

# Fetch stock data using yfinance

from src.data_fetcher import fetch_stock_data

# Fetch single stock:
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# Fetch multiple stocks:
stocks = ['AAPL', 'GOOGL', 'MSFT', 'AMZN', 'TSLA']
data_multi = fetch_stock_data(stocks, start_date='2024-01-01', end_date='2024-12-31')

# Popular stock tickers:
# - AAPL (Apple)
# - GOOGL (Google)
# - MSFT (Microsoft)
# - AMZN (Amazon)
# - TSLA (Tesla)
# - META (Meta/Facebook)
# - NVDA (NVIDIA)
# - And many more...

# Customize data fetching:
# - Change date range (start_date, end_date)
# - Use different timeframes (daily, weekly, monthly)
# - Fetch specific periods (1 year, 5 years, etc.)

# Save fetched data:
data.to_csv('stock_data.csv')

Using Your Own Stock Data

Use your own stock data for analysis:

# Steps to use your own stock data:

# 1. Prepare your CSV file
#    - Required: Date, Open, High, Low, Close, Volume columns
#    - Date: YYYY-MM-DD format or any parseable date format
#    - OHLCV: Numeric values for prices and volume

# 2. Load and validate data
import pandas as pd
from src.validation import validate_stock_data

data = pd.read_csv('your_stock_data.csv', parse_dates=['Date'], index_col='Date')
# Automatically converts date column to DatetimeIndex

# Validate data
data = validate_stock_data(data)
# Checks for required columns, data types, and missing values

# 3. Create chart
from src.chart_builder import create_candlestick_chart
fig = create_candlestick_chart(data, ticker='YOUR_TICKER')
fig.write_html('chart.html')

# 4. Verify data format
#    - Check Date column is parseable
#    - Ensure no missing values in required columns
#    - Verify OHLCV columns contain numeric data
#    - Check for proper DatetimeIndex
#    - Ensure High >= Low and High >= Open/Close

# 5. Use with all analysis types
#    - All analysis types work with your data
#    - Technical indicators work automatically
#    - Pattern recognition works with OHLC data
#    - Backtesting and portfolio analysis work with validated data

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
Stock Data Not Found: Ensure ticker symbol is valid. Check internet connection for yfinance. Verify date range is valid
Import Errors: Verify all dependencies installed: pip install -r requirements.txt. Check Python version (3.7+)
Date Format Errors: Ensure date column is in parseable format (YYYY-MM-DD). Use pd.to_datetime() to convert
Chart Not Rendering: Check browser console for JavaScript errors. Verify Plotly is loaded correctly
Slow Performance: Reduce date range, 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
yfinance Connection Issues: Check internet connection. yfinance may have rate limits. Try again later or use cached data
Indicator Calculation Errors: Ensure data has sufficient periods for indicators. Minimum periods required (e.g., RSI needs 14+ periods)
Pattern Recognition Not Working: Verify data has OHLC columns. Check data quality and ensure no missing values
Backtesting Errors: Ensure data has sufficient history for backtesting. Minimum 100+ periods 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: Reduce date range or use data resampling to reduce number of points
Visualization Type: Use simpler charts for large datasets (basic candlestick charts are faster than complex multi-indicator charts)
Indicator Periods: Adjust indicator periods based on timeframe (shorter periods for intraday, longer for daily/weekly)
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 OHLCV columns are numeric
Date Format: Always validate date format and convert to DatetimeIndex for proper stock analysis
OHLCV Columns: Ensure OHLCV columns contain numeric values. Validate High >= Low, High >= Open/Close
Data Size: For large datasets (10K+ points), consider resampling or date range filtering
Chart Templates: Choose appropriate plot templates for your visualization needs (light, dark, etc.)
Error Handling: Add error handling in chart functions to prevent crashes
Data Validation: Always validate stock data format and types before processing
Export Formats: Use HTML for interactive sharing, PNG/PDF for reports and presentations
Backtesting Strategies: Choose appropriate strategies (MA crossover for trends, RSI for ranges)
Documentation: Document custom modifications and data sources
Testing: Test with different stock tickers and date 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 movements, trends, and patterns using candlestick charts
Trading Strategy Development: Develop and test trading strategies using backtesting framework
Technical Analysis: Perform comprehensive technical analysis with 15+ indicators
Pattern Recognition: Identify candlestick patterns for trading signals
Portfolio Management: Analyze multiple stocks in a portfolio with correlation and performance metrics
Risk Assessment: Evaluate risk using volatility, Sharpe Ratio, and Max Drawdown calculations
Entry/Exit Points: Identify support/resistance levels and price targets for trading decisions
Market Monitoring: Set up alerts for RSI levels, price targets, volume spikes, and patterns
Financial Reporting: Generate comprehensive stock analysis reports with charts and statistics
Educational Purposes: Learn technical analysis, pattern recognition, and trading strategies

Performance Benchmarks

Expected performance for different stock data sizes:

Data Size	Data Points	Load Time	Chart 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.7	3.8+	3.9+
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: Candlestick charts 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 | Candlestick Charts Use Cases | Stock Market Analysis Examples

Example 1: Basic Stock Analysis

Analyze stock price movements with candlestick charts and technical indicators:

# 1. Fetch stock data
from src.data_fetcher import fetch_stock_data
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# 2. Create basic candlestick chart
from src.chart_builder import create_candlestick_chart
fig1 = create_candlestick_chart(data, ticker='AAPL', title='AAPL Stock Price')
fig1.show()

# 3. Add technical indicators
from src.technical_indicators import add_all_indicators
data_with_indicators = add_all_indicators(data)
fig2 = create_candlestick_chart(data_with_indicators, ticker='AAPL', 
                                show_indicators=True, title='AAPL with Indicators')
fig2.show()

# 4. Detect patterns
from src.pattern_recognition import detect_all_patterns, get_pattern_summary
data_complete = detect_all_patterns(data_with_indicators)
patterns = get_pattern_summary(data_complete)
print(patterns)

# 5. Analyze patterns
# - Identify candlestick patterns (Doji, Hammer, Engulfing)
# - Detect support and resistance levels
# - Analyze volume trends
# - Evaluate trading signals

Example 2: Trading Strategy Backtesting

Test trading strategies with historical data:

# Use Case: Trading strategy backtesting

# 1. Fetch stock data
from src.data_fetcher import fetch_stock_data
data = fetch_stock_data('AAPL', start_date='2023-01-01', end_date='2024-12-31')

# 2. Backtest MA Crossover Strategy
from src.backtesting import backtest_ma_crossover
results1 = backtest_ma_crossover(data, short_window=20, long_window=50)
print(f"MA Crossover: Returns={results1['returns']:.2%}, Sharpe={results1['sharpe_ratio']:.2f}")

# 3. Backtest RSI Strategy
from src.backtesting import backtest_rsi_strategy
results2 = backtest_rsi_strategy(data, oversold=30, overbought=70)
print(f"RSI Strategy: Returns={results2['returns']:.2%}, Win Rate={results2['win_rate']:.2%}")

# 4. Backtest MACD Strategy
from src.backtesting import backtest_macd_strategy
results3 = backtest_macd_strategy(data)
print(f"MACD Strategy: Returns={results3['returns']:.2%}, Max Drawdown={results3['max_drawdown']:.2%}")

# 5. Analyze results
# - Compare strategy performance
# - Evaluate risk metrics (Sharpe Ratio, Max Drawdown)
# - Identify best entry/exit points
# - Optimize strategy parameters

Example 3: Portfolio Analysis

Analyze multiple stocks in a portfolio:

# Use Case: Portfolio analysis

# 1. Create portfolio
from src.portfolio import create_portfolio, calculate_portfolio_returns
portfolio = create_portfolio(['AAPL', 'GOOGL', 'MSFT', 'AMZN'], 
                             weights=[0.25, 0.25, 0.25, 0.25])

# 2. Calculate portfolio returns
portfolio_returns = calculate_portfolio_returns(portfolio, 
                                                start_date='2024-01-01', 
                                                end_date='2024-12-31')
print(f"Portfolio Returns: {portfolio_returns['total_return']:.2%}")

# 3. Correlation analysis
from src.portfolio import calculate_correlation_matrix
correlation = calculate_correlation_matrix(portfolio, 
                                          start_date='2024-01-01', 
                                          end_date='2024-12-31')
print(correlation)

# 4. Portfolio performance
from src.portfolio import analyze_portfolio_performance
performance = analyze_portfolio_performance(portfolio,
                                           start_date='2024-01-01',
                                           end_date='2024-12-31')
print(f"Sharpe Ratio: {performance['sharpe_ratio']:.2f}")
print(f"Max Drawdown: {performance['max_drawdown']:.2%}")

# 5. Analyze patterns
# - Portfolio diversification
# - Correlation between stocks
# - Risk-adjusted returns
# - Portfolio optimization

Example 4: Pattern Recognition & Alerts

Detect candlestick patterns and set up alerts:

# Use Case: Pattern recognition and alerts

# 1. Fetch stock data
from src.data_fetcher import fetch_stock_data
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# 2. Detect all patterns
from src.pattern_recognition import detect_all_patterns, get_pattern_summary
data_with_patterns = detect_all_patterns(data)
patterns = get_pattern_summary(data_with_patterns)
print(patterns)

# 3. Create chart with pattern markers
from src.chart_builder import create_candlestick_chart
from src.technical_indicators import add_all_indicators
data = add_all_indicators(data)
data = detect_all_patterns(data)
fig = create_candlestick_chart(data, ticker='AAPL', show_patterns=True)
fig.show()

# 4. Set up alerts
from src.alerts import check_rsi_alerts, check_price_alerts, check_pattern_alerts
rsi_alerts = check_rsi_alerts(data, oversold=30, overbought=70)
price_alerts = check_price_alerts(data, target_price=150.0)
pattern_alerts = check_pattern_alerts(data, pattern_types=['Doji', 'Hammer'])
print(f"RSI Alerts: {rsi_alerts}")
print(f"Price Alerts: {price_alerts}")
print(f"Pattern Alerts: {pattern_alerts}")

# 5. Use cases:
# - Pattern-based trading signals
# - Automated alert system
# - Entry/exit point identification
# - Risk management

Example 5: Advanced Technical Analysis

Comprehensive technical analysis with multiple indicators:

# Use Case: Advanced technical analysis

# 1. Fetch stock data
from src.data_fetcher import fetch_stock_data
data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')

# 2. Add all technical indicators
from src.technical_indicators import add_all_indicators
data = add_all_indicators(data)

# 3. Calculate support and resistance
from src.utils import calculate_support_resistance
support, resistance = calculate_support_resistance(data)
print(f"Support: ${support:.2f}, Resistance: ${resistance:.2f}")

# 4. Calculate price targets
from src.utils import calculate_fibonacci_targets, calculate_pivot_targets
fib_targets = calculate_fibonacci_targets(data)
pivot_targets = calculate_pivot_targets(data)
print(f"Fibonacci Targets: {fib_targets}")
print(f"Pivot Targets: {pivot_targets}")

# 5. Statistical analysis
from src.utils import get_statistics_summary
stats = get_statistics_summary(data)
print(f"Volatility: {stats['volatility']:.2%}")
print(f"Sharpe Ratio: {stats['sharpe_ratio']:.2f}")
print(f"Max Drawdown: {stats['max_drawdown']:.2%}")

# 6. Create comprehensive chart
from src.chart_builder import create_candlestick_chart
fig = create_candlestick_chart(data, ticker='AAPL', 
                               show_indicators=True, 
                               show_patterns=True,
                               show_volume=True)
fig.show()

# 7. Use cases:
# - Comprehensive technical analysis
# - Support/resistance identification
# - Price target calculation
# - Risk assessment

Integration Examples | Database Integration | API Integration | Web Integration

Integration with Database

Load stock data from SQL database:

# Load stock data from SQL database

import sqlite3
import pandas as pd
from src.chart_builder import create_candlestick_chart

def load_stock_data_from_db(ticker='AAPL'):
    """Load stock data from SQL database."""
    conn = sqlite3.connect('stock_data.db')
    query = """
        SELECT 
            Date,
            Open,
            High,
            Low,
            Close,
            Volume
        FROM stock_prices
        WHERE Ticker = ?
        ORDER BY Date
    """
    data = pd.read_sql_query(query, conn, params=[ticker], parse_dates=['Date'], index_col='Date')
    conn.close()
    
    return data

# Load and create chart
data = load_stock_data_from_db('AAPL')
fig = create_candlestick_chart(data, ticker='AAPL')
fig.write_html('chart_from_db.html')

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

Integration with REST API

Load stock 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 chart
data = load_stock_data_from_api()
fig = create_candlestick_chart(data, ticker='AAPL')
fig.write_html('chart_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('chart_live.html')
    time.sleep(300)  # Update every 5 minutes

Embedding Charts in Web Pages

Embed interactive charts in existing websites:

# Embed Chart in Web Page:

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

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

# Option 2: Use Plotly's HTML output
from src.chart_builder import create_candlestick_chart
from src.data_fetcher import fetch_stock_data

data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')
fig = create_candlestick_chart(data, ticker='AAPL')

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

# Embed in your HTML page:
# <div id="chart-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/charts/chart.html

# Option 4: Use Flask/Django to serve charts
from flask import Flask, send_file
from src.chart_builder import create_candlestick_chart
from src.data_fetcher import fetch_stock_data

app = Flask(__name__)

@app.route('/chart')
def show_chart():
    data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')
    fig = create_candlestick_chart(data, ticker='AAPL')
    fig.write_html('static/chart.html')
    return send_file('static/chart.html')

Sharing Charts

Share interactive charts with others:

# Sharing Chart 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 src.chart_builder import create_candlestick_chart
from src.data_fetcher import fetch_stock_data

data = fetch_stock_data('AAPL', start_date='2024-01-01', end_date='2024-12-31')
fig = create_candlestick_chart(data, ticker='AAPL')
fig.write_image('chart.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('chart.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