generate_graphs.py

import os
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import math

os.makedirs('images', exist_ok=True)

candle_types = ['Bull_1', 'Bull_2', 'Bull_3', 'Bull_4', 'Bear_1', 'Bear_2', 'Bear_3', 'Bear_4']

alignments = ['GAP_UP', 'GAP_DOWN', 'ENGULFING', 'HARAMI', 'EQUAL_HIGH', 'EQUAL_LOW', 'MEETING_LINES', 'OVERLAP_UPPER', 'OVERLAP_LOWER', 'PIERCING_CLOUD', 'CONTINUATION']

def get_base_candle(c_type, base_y=50.0, body_size=10.0, wick_size=5.0):
    half_body = body_size / 2.0
    top_body = base_y + half_body
    bot_body = base_y - half_body
    
    if c_type == 'Bull_1': # H > C > O > L
        return (bot_body, top_body + wick_size, bot_body - wick_size, top_body)
    elif c_type == 'Bull_2': # C=H > O > L
        return (bot_body, top_body, bot_body - wick_size, top_body)
    elif c_type == 'Bull_3': # H > C > O=L
        return (bot_body, top_body + wick_size, bot_body, top_body)
    elif c_type == 'Bull_4': # C=H > O=L
        return (bot_body, top_body, bot_body, top_body)
    elif c_type == 'Bear_1': # H > O > C > L
        return (top_body, top_body + wick_size, bot_body - wick_size, bot_body)
    elif c_type == 'Bear_2': # H > O > C=L
        return (top_body, top_body + wick_size, bot_body, bot_body)
    elif c_type == 'Bear_3': # H=O > C > L
        return (top_body, top_body, bot_body - wick_size, bot_body)
    elif c_type == 'Bear_4': # H=O > C=L
        return (top_body, top_body, bot_body, bot_body)

def get_c2(type1, align, type2):
    c1_body_size = 10.0
    c1_wick_size = 5.0
    O1, H1, L1, C1 = get_base_candle(type1, 50.0, c1_body_size, c1_wick_size)
    top1 = max(O1, C1)
    bot1 = min(O1, C1)
    mid1 = (O1 + C1) / 2.0
    
    c2_body_size = 10.0
    c2_wick_size = 5.0
    base_y = 50.0
    
    if align == 'GAP_UP':
        base_y = H1 + c2_body_size/2.0 + c2_wick_size + 2.0
    elif align == 'GAP_DOWN':
        base_y = L1 - c2_body_size/2.0 - c2_wick_size - 2.0
    elif align == 'ENGULFING':
        c2_body_size = c1_body_size * 1.5
        c2_wick_size = c1_wick_size * 1.5
        base_y = mid1
    elif align == 'HARAMI':
        c2_body_size = c1_body_size * 0.5
        c2_wick_size = c1_wick_size * 0.5
        base_y = mid1
    elif align == 'EQUAL_HIGH':
        _, H2_test, _, _ = get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)
        base_y = 50.0 + (H1 - H2_test)
    elif align == 'EQUAL_LOW':
        _, _, L2_test, _ = get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)
        base_y = 50.0 + (L1 - L2_test)
    elif align == 'MEETING_LINES':
        _, _, _, C2_test = get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)
        base_y = 50.0 + (C1 - C2_test)
    elif align == 'OVERLAP_UPPER':
        base_y = top1
    elif align == 'OVERLAP_LOWER':
        base_y = bot1
    elif align == 'PIERCING_CLOUD':
        c2_body_size = 18.0
        base_y = mid1 + 4.0
    elif align == 'CONTINUATION':
        O2_test, _, _, _ = get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)
        base_y = 50.0 + (C1 - O2_test)
        
    return get_base_candle(type2, base_y, c2_body_size, c2_wick_size)

def is_bullish(O, C): return C > O
def is_bearish(O, C): return C < O

def determine_standard_name(c1_type, O1, H1, L1, C1, c2_type, O2, H2, L2, C2):
    is_bull1 = is_bullish(O1, C1)
    is_bear1 = is_bearish(O1, C1)
    is_bull2 = is_bullish(O2, C2)
    is_bear2 = is_bearish(O2, C2)

    mid1 = (O1 + C1) / 2.0
    names = []

    if is_bear1 and is_bull2 and (O2 <= C1 and C2 >= O1) and (O2 < C1 or C2 > O1): 
        names.append("Bullish Engulfing")
    elif is_bull1 and is_bear2 and (O2 >= C1 and C2 <= O1) and (O2 > C1 or C2 < O1):
        names.append("Bearish Engulfing")
        
    if is_bear1 and is_bull2 and (O2 >= C1 and C2 <= O1) and (O2 > C1 or C2 < O1):
        names.append("Bullish Harami")
    elif is_bull1 and is_bear2 and (O2 <= C1 and C2 >= O1) and (O2 < C1 or C2 > O1):
        names.append("Bearish Harami")
        
    if is_bear1 and is_bull2 and O2 < L1 and C2 > mid1 and C2 < O1:
        names.append("Piercing Line")
        
    if is_bull1 and is_bear2 and O2 > H1 and C2 < mid1 and C2 > O1:
        names.append("Dark Cloud Cover")
        
    if is_bear1 and is_bull2 and O2 > O1 and L2 > H1 and c1_type == 'Bear_4' and c2_type == 'Bull_4':
        names.append("Bullish Kicking")
    if is_bull1 and is_bear2 and O2 < O1 and H2 < L1 and c1_type == 'Bull_4' and c2_type == 'Bear_4':
        names.append("Bearish Kicking")
        
    if is_bear1 and is_bull2 and abs(L1 - L2) < 0.05:
        names.append("Tweezer Bottom")
    if is_bull1 and is_bear2 and abs(H1 - H2) < 0.05:
        names.append("Tweezer Top")
        
    if is_bear1 and is_bull2 and abs(C1 - C2) < 0.05 and O2 < C1:
        names.append("Bullish Meeting Lines")
    if is_bull1 and is_bear2 and abs(C1 - C2) < 0.05 and O2 > C1:
        names.append("Bearish Meeting Lines")
        
    if is_bear1 and is_bull2 and O2 < L1 and C2 < mid1 and C2 > C1:
        names.append("Thrusting")
        
    if is_bear1 and is_bull2 and O2 < L1 and abs(C2 - C1) < 0.05:
        names.append("In Neck")
        
    if is_bear1 and is_bull2 and O2 < L1 and abs(C2 - L1) < 0.05:
        names.append("On Neck")
        
    return ", ".join(names) if names else "-"

def draw_candle(ax, x, O, H, L, C):
    color = 'green' if C > O else 'red'
    ax.plot([x, x], [L, H], color=color, linewidth=2)
    top = max(O, C)
    bottom = min(O, C)
    height = top - bottom
    rect = patches.Rectangle((x - 0.3, bottom), 0.6, height, linewidth=1, edgecolor=color, facecolor=color)
    ax.add_patch(rect)

def get_pattern_desc(align):
    descriptions = {
        'GAP_UP': 'C2 completely above C1',
        'GAP_DOWN': 'C2 completely below C1',
        'ENGULFING': 'C2 body engulfs C1 body',
        'HARAMI': 'C2 body inside C1 body',
        'EQUAL_HIGH': 'Higher shadow matches exactly',
        'EQUAL_LOW': 'Lower shadow matches exactly',
        'MEETING_LINES': 'Close of C2 matches Close of C1',
        'OVERLAP_UPPER': 'C2 centered on C1 High/Open',
        'OVERLAP_LOWER': 'C2 centered on C1 Low/Close',
        'PIERCING_CLOUD': 'Large gap and heavy overlap',
        'CONTINUATION': 'Open of C2 matches Close of C1'
    }
    return descriptions.get(align, align)

def get_candle_logic(c_type, suffix):
    if c_type == 'Bull_1':
        return f"H{suffix} > C{suffix} & O{suffix} & L{suffix} <br> C{suffix} > O{suffix} & L{suffix} <br> O{suffix} > L{suffix}"
    elif c_type == 'Bull_2':
        return f"(C{suffix} = H{suffix}) > O{suffix} & L{suffix} <br> C{suffix} > O{suffix} & L{suffix} <br> O{suffix} > L{suffix}"
    elif c_type == 'Bull_3':
        return f"H{suffix} > C{suffix} & O{suffix} & L{suffix} <br> C{suffix} > O{suffix} & L{suffix} <br> O{suffix} = L{suffix}"
    elif c_type == 'Bull_4':
        return f"(C{suffix} = H{suffix}) > O{suffix} & L{suffix} <br> C{suffix} > O{suffix} & L{suffix} <br> O{suffix} = L{suffix}"
    elif c_type == 'Bear_1':
        return f"L{suffix} < C{suffix} & O{suffix} & H{suffix} <br> C{suffix} < O{suffix} & H{suffix} <br> O{suffix} < H{suffix}"
    elif c_type == 'Bear_2':
        return f"(C{suffix} = L{suffix}) < O{suffix} & H{suffix} <br> C{suffix} < O{suffix} & H{suffix} <br> O{suffix} < H{suffix}"
    elif c_type == 'Bear_3':
        return f"L{suffix} < C{suffix} & O{suffix} & H{suffix} <br> C{suffix} < O{suffix} & H{suffix} <br> O{suffix} = H{suffix}"
    elif c_type == 'Bear_4':
        return f"(C{suffix} = L{suffix}) < O{suffix} & H{suffix} <br> C{suffix} < O{suffix} & H{suffix} <br> O{suffix} = H{suffix}"
    return ""

def get_alignment_logic(align):
    if align == 'GAP_UP': return "L_C0 > H_C-1"
    if align == 'GAP_DOWN': return "H_C0 < L_C-1"
    if align == 'ENGULFING': return "(max(O_C0, C_C0) > max(O_C-1, C_C-1)) & (min(O_C0, C_C0) < min(O_C-1, C_C-1))"
    if align == 'HARAMI': return "(max(O_C0, C_C0) < max(O_C-1, C_C-1)) & (min(O_C0, C_C0) > min(O_C-1, C_C-1))"
    if align == 'EQUAL_HIGH': return "H_C0 = H_C-1"
    if align == 'EQUAL_LOW': return "L_C0 = L_C-1"
    if align == 'MEETING_LINES': return "C_C0 = C_C-1"
    if align == 'OVERLAP_UPPER': return "((O_C0 + C_C0) / 2) = max(O_C-1, C_C-1)"
    if align == 'OVERLAP_LOWER': return "((O_C0 + C_C0) / 2) = min(O_C-1, C_C-1)"
    if align == 'PIERCING_CLOUD': return "(O_C0 > H_C-1) & (C_C0 < ((O_C-1 + C_C-1)/2))"
    if align == 'CONTINUATION': return "O_C0 = C_C-1"
    return ""

def get_logic_string(c1_type, align, c2_type):
    lines1 = get_candle_logic(c1_type, "_C-1")
    lines2 = get_candle_logic(c2_type, "_C0")
    align_rule = get_alignment_logic(align)
    return f"{{ <br> {lines1} <br> {lines2} <br> {align_rule} <br> }}"

patterns = []

# Generate all patterns
for t1 in candle_types:
    for align in alignments:
        for t2 in candle_types:
            patterns.append((t1, align, t2))

total_patterns = len(patterns)
patterns_per_img = 10

markdown_lines = []
markdown_lines.append("# Complete 2-Candle Patterns")
markdown_lines.append("")
markdown_lines.append("| Code_Name | Pattern_Description | Pattern_Logic | Standard_Name | Image Reference |")
markdown_lines.append("|---|---|---|---|---|")

for i in range(0, total_patterns, patterns_per_img):
    batch = patterns[i:i+patterns_per_img]
    
    fig, axes = plt.subplots(2, 5, figsize=(20, 8))
    fig.subplots_adjust(hspace=0.4, wspace=0.3)
    axes = axes.flatten()
    
    for ax in axes:
        ax.set_visible(False)
        
    for j, (t1, align, t2) in enumerate(batch):
        ax = axes[j]
        ax.set_visible(True)
        
        O1, H1, L1, C1 = get_base_candle(t1, 50.0, 10.0, 5.0)
        O2, H2, L2, C2 = get_c2(t1, align, t2)
        
        draw_candle(ax, 1, O1, H1, L1, C1)
        draw_candle(ax, 2, O2, H2, L2, C2)
        
        min_y = min(L1, L2) - 5
        max_y = max(H1, H2) + 5
        ax.set_ylim(min_y, max_y)
        ax.set_xlim(0, 3)
        ax.set_xticks([])
        ax.set_yticks([])
        
        code_name = f"{t1}_{align}_{t2}"
        std_name = determine_standard_name(t1, O1, H1, L1, C1, t2, O2, H2, L2, C2)
        desc = get_pattern_desc(align)
        
        ax.set_title(f"{code_name}\n({std_name})", fontsize=9)
        
        img_name = f"plot_{i//patterns_per_img + 1}.png"
        logic_str = get_logic_string(t1, align, t2)
        markdown_lines.append(f"| {code_name} | {desc} | {logic_str} | {std_name} | {img_name} |")
        
    img_path = os.path.join('images', img_name)
    plt.savefig(img_path, bbox_inches='tight')
    plt.close(fig)

with open('2C_patterns.md', 'w') as f:
    f.write("\n".join(markdown_lines))

print(f"Generated {total_patterns} patterns and saved to images folder. MD written to 2C_patterns.md")