Upload 335 files

1C_patterns.md

@@ -0,0 +1,81 @@
+# Complete 1-Candle Patterns
+
+Based on the core definitions, here are all the possible configurations for a single 1-candle pattern (Bullish and Bearish).
+
+## Bullish Patterns (C > O)
+
+### Bull_1
+- **Definition**: High > Close > Open > Low. A standard bullish candle with both an upper and lower shadow (wick).
+- **Logic**:
+  ```text
+  H > C & O & L
+  C > O & L
+  O > L
+  ```
+
+### Bull_2
+- **Definition**: Close = High > Open > Low. A bullish candle that closes precisely at its highest price, indicating strong upward momentum into the close (no upper wick).
+- **Logic**:
+  ```text
+  (C = H) > O & L
+  C > O & L
+  O > L
+  ```
+
+### Bull_3
+- **Definition**: High > Close > Open = Low. A bullish candle that opened at its absolute lowest point, showing buyers dominated continually from the very beginning (no lower wick).
+- **Logic**:
+  ```text
+  H > C & O & L
+  C > O & L
+  O = L
+  ```
+
+### Bull_4
+- **Definition**: (Close = High) > (Open = Low). A perfectly strong "Marubozu" bullish candle that opened at its low and closed perfectly at its high, without wicks.
+- **Logic**:
+  ```text
+  (C = H) > O & L
+  C > O & L
+  O = L
+  ```
+
+---
+
+## Bearish Patterns (C < O)
+
+### Bear_1
+- **Definition**: High > Open > Close > Low. A standard bearish candle where the price varied heavily but ended below where it opened.
+- **Logic**:
+  ```text
+  L < C & O & H
+  C < O & H
+  O < H
+  ```
+
+### Bear_2
+- **Definition**: High > Open > Close = Low. A bearish candle that closes exactly at its lowest point, showing selling pressure all the way through the end of the session (no lower wick).
+- **Logic**:
+  ```text
+  (C = L) < O & H
+  C < O & H
+  O < H
+  ```
+
+### Bear_3
+- **Definition**: High = Open > Close > Low. A bearish candle that opens precisely at its high, suggesting selling pressure began instantly, producing no upper wick.
+- **Logic**:
+  ```text
+  L < C & O & H
+  C < O & H
+  O = H
+  ```
+
+### Bear_4
+- **Definition**: (Open = High) > (Close = Low). A perfectly strong bearish "Marubozu" candle opening at its absolute high and closing at its absolute low, showing maximal bearish momentum and no wicks.
+- **Logic**:
+  ```text
+  (C = L) < O & H
+  C < O & H
+  O = H
+  ```

generate_graphs.py

@@ -0,0 +1,276 @@
+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',
+    'Doji_1', 'Doji_2', 'Doji_3', 'Doji_4'
+]
+
+alignments = [
+    'GAP_UP', 'GAP_DOWN', 'ENGULFING', 'HARAMI', 
+    'OVERLAP_UPPER', 'OVERLAP_LOWER', 'PIERCING_CLOUD',
+    'EQUAL_OPEN', 'OPEN_EQUALS_HIGH', 'OPEN_EQUALS_LOW', 'CONTINUATION',
+    'CLOSE_EQUALS_OPEN', 'CLOSE_EQUALS_HIGH', 'CLOSE_EQUALS_LOW', 'MEETING_LINES',
+    'HIGH_EQUALS_OPEN', 'EQUAL_HIGH', 'HIGH_EQUALS_LOW', 'HIGH_EQUALS_CLOSE',
+    'LOW_EQUALS_OPEN', 'LOW_EQUALS_HIGH', 'EQUAL_LOW', 'LOW_EQUALS_CLOSE'
+]
+
+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)
+    elif c_type == 'Doji_1':
+        return (base_y, base_y + wick_size + half_body, base_y - wick_size - half_body, base_y)
+    elif c_type == 'Doji_2':
+        return (base_y, base_y, base_y - wick_size - half_body, base_y)
+    elif c_type == 'Doji_3':
+        return (base_y, base_y + wick_size + half_body, base_y, base_y)
+    elif c_type == 'Doji_4':
+        return (base_y, base_y, base_y, base_y)
+
+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 == '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 == 'EQUAL_OPEN':
+        base_y += (O1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[0])
+    elif align == 'OPEN_EQUALS_HIGH':
+        base_y += (H1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[0])
+    elif align == 'OPEN_EQUALS_LOW':
+        base_y += (L1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[0])
+    elif align == 'CONTINUATION':
+        base_y += (C1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[0])
+    elif align == 'CLOSE_EQUALS_OPEN':
+        base_y += (O1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[3])
+    elif align == 'CLOSE_EQUALS_HIGH':
+        base_y += (H1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[3])
+    elif align == 'CLOSE_EQUALS_LOW':
+        base_y += (L1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[3])
+    elif align == 'MEETING_LINES':
+        base_y += (C1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[3])
+    elif align == 'HIGH_EQUALS_OPEN':
+        base_y += (O1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[1])
+    elif align == 'EQUAL_HIGH':
+        base_y += (H1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[1])
+    elif align == 'HIGH_EQUALS_LOW':
+        base_y += (L1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[1])
+    elif align == 'HIGH_EQUALS_CLOSE':
+        base_y += (C1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[1])
+    elif align == 'LOW_EQUALS_OPEN':
+        base_y += (O1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[2])
+    elif align == 'LOW_EQUALS_HIGH':
+        base_y += (H1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[2])
+    elif align == 'EQUAL_LOW':
+        base_y += (L1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[2])
+    elif align == 'LOW_EQUALS_CLOSE':
+        base_y += (C1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[2])
+        
+    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):
+    # This remains simple heuristic, exact namings aren't fully robust for 3000+ combinations
+    return "-"
+
+def draw_candle(ax, x, O, H, L, C):
+    if C > O: color = 'green'
+    elif C < O: color = 'red'
+    else: color = 'black'
+    
+    ax.plot([x, x], [L, H], color=color, linewidth=2)
+    top = max(O, C)
+    bottom = min(O, C)
+    height = max(top - bottom, 0.2) if top == bottom else (top - bottom)
+    rect = patches.Rectangle((x - 0.3, bottom if top != bottom else bottom - 0.1), 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',
+        'OVERLAP_UPPER': 'C2 centered on C1 High/Open',
+        'OVERLAP_LOWER': 'C2 centered on C1 Low/Close',
+        'PIERCING_CLOUD': 'Large gap and heavy overlap',
+        'EQUAL_OPEN': 'O2 = O1',
+        'OPEN_EQUALS_HIGH': 'O2 = H1',
+        'OPEN_EQUALS_LOW': 'O2 = L1',
+        'CONTINUATION': 'O2 = C1',
+        'CLOSE_EQUALS_OPEN': 'C2 = O1',
+        'CLOSE_EQUALS_HIGH': 'C2 = H1',
+        'CLOSE_EQUALS_LOW': 'C2 = L1',
+        'MEETING_LINES': 'C2 = C1',
+        'HIGH_EQUALS_OPEN': 'H2 = O1',
+        'EQUAL_HIGH': 'H2 = H1',
+        'HIGH_EQUALS_LOW': 'H2 = L1',
+        'HIGH_EQUALS_CLOSE': 'H2 = C1',
+        'LOW_EQUALS_OPEN': 'L2 = O1',
+        'LOW_EQUALS_HIGH': 'L2 = H1',
+        'EQUAL_LOW': 'L2 = L1',
+        'LOW_EQUALS_CLOSE': 'L2 = 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}"
+    elif c_type == 'Doji_1': return f"H{suffix} > C{suffix} & O{suffix} <br> C{suffix} = O{suffix} <br> C{suffix} & O{suffix} > L{suffix}"
+    elif c_type == 'Doji_2': return f"H{suffix} = C{suffix} & O{suffix} <br> C{suffix} = O{suffix} <br> C{suffix} & O{suffix} > L{suffix}"
+    elif c_type == 'Doji_3': return f"H{suffix} > C{suffix} & O{suffix} <br> C{suffix} = O{suffix} <br> C{suffix} & O{suffix} = L{suffix}"
+    elif c_type == 'Doji_4': return f"H{suffix} = C{suffix} & O{suffix} <br> C{suffix} = O{suffix} <br> C{suffix} & O{suffix} = L{suffix}"
+    return ""
+
+def get_alignment_logic(align):
+    logic_map = {
+        'GAP_UP': 'L_C0 > H_C-1',
+        'GAP_DOWN': 'H_C0 < L_C-1',
+        'ENGULFING': '(max(O_C0, C_C0) > max(O_C-1, C_C-1)) & (min(O_C0, C_C0) < min(O_C-1, C_C-1))',
+        'HARAMI': '(max(O_C0, C_C0) < max(O_C-1, C_C-1)) & (min(O_C0, C_C0) > min(O_C-1, C_C-1))',
+        'OVERLAP_UPPER': '((O_C0 + C_C0) / 2) = max(O_C-1, C_C-1)',
+        'OVERLAP_LOWER': '((O_C0 + C_C0) / 2) = min(O_C-1, C_C-1)',
+        'PIERCING_CLOUD': '(O_C0 > H_C-1) & (C_C0 < ((O_C-1 + C_C-1)/2))',
+        'EQUAL_OPEN': 'O_C0 = O_C-1',
+        'OPEN_EQUALS_HIGH': 'O_C0 = H_C-1',
+        'OPEN_EQUALS_LOW': 'O_C0 = L_C-1',
+        'CONTINUATION': 'O_C0 = C_C-1',
+        'CLOSE_EQUALS_OPEN': 'C_C0 = O_C-1',
+        'CLOSE_EQUALS_HIGH': 'C_C0 = H_C-1',
+        'CLOSE_EQUALS_LOW': 'C_C0 = L_C-1',
+        'MEETING_LINES': 'C_C0 = C_C-1',
+        'HIGH_EQUALS_OPEN': 'H_C0 = O_C-1',
+        'EQUAL_HIGH': 'H_C0 = H_C-1',
+        'HIGH_EQUALS_LOW': 'H_C0 = L_C-1',
+        'HIGH_EQUALS_CLOSE': 'H_C0 = C_C-1',
+        'LOW_EQUALS_OPEN': 'L_C0 = O_C-1',
+        'LOW_EQUALS_HIGH': 'L_C0 = H_C-1',
+        'EQUAL_LOW': 'L_C0 = L_C-1',
+        'LOW_EQUALS_CLOSE': 'L_C0 = C_C-1'
+    }
+    return logic_map.get(align, "")
+
+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(f"# Complete Exhaustive Set of 2-Candle Patterns (Total: {total_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}", 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")