MYM-A MODO CICLOPE

import tkinter as tk

from tkinter import messagebox

import MetaTrader5 as mt5

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg

from sklearn.preprocessing import MinMaxScaler

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import LSTM, Dense

def main():

    # Create the main window

    root = tk.Tk()

    root.title("MT5MYM-A")

    root.geometry("1200x800")

    # Create a frame for the login UI

    login_frame = tk.Frame(root, width=400, height=600, bg="lightgrey")

    login_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

    # Title for the login UI

    login_title = tk.Label(login_frame, text="🏧MYM-A", font=("Helvetica", 20), bg="lightgrey")

    login_title.pack(pady=20)

    # Login fields

    login_label = tk.Label(login_frame, text="Login:", font=("Helvetica", 14), bg="lightgrey")

    login_label.pack(pady=5)

    login_entry = tk.Entry(login_frame, font=("Helvetica", 14))

    login_entry.pack(pady=5)

    login_entry.insert(0, "5027341082")  # Pre-fill with your login

    password_label = tk.Label(login_frame, text="Password:", font=("Helvetica", 14), bg="lightgrey")

    password_label.pack(pady=5)

    password_entry = tk.Entry(login_frame, show="*", font=("Helvetica", 14))

    password_entry.pack(pady=5)

    password_entry.insert(0, "IxS@Po1b")  # Pre-fill with your password

    server_label = tk.Label(login_frame, text="Server:", font=("Helvetica", 14), bg="lightgrey")

    server_label.pack(pady=5)

    server_entry = tk.Entry(login_frame, font=("Helvetica", 14))

    server_entry.pack(pady=5)

    server_entry.insert(0, "MetaQuotes-Demo")  # Pre-fill with your server

    # Connect button

    connect_button = tk.Button(login_frame, text="Connect", font=("Helvetica", 14),

                               command=lambda: connect_to_mt5(login_entry.get(), password_entry.get(), server_entry.get(), root, trend_label))

    connect_button.pack(pady=20)

    # Create a frame for the main content

    main_frame = tk.Frame(root, width=800, height=600)

    main_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)

    # Create a label with the text "USD/MXN"

    label = tk.Label(main_frame, text="USD/MXN", font=("Helvetica", 24))

    label.pack(expand=True)

    # Create a label to display the market trend

    trend_label = tk.Label(main_frame, text="", font=("Helvetica", 18))

    trend_label.pack(expand=True)

    # Create a label with the text "Loading..." at the bottom

    loading_label = tk.Label(main_frame, text="Loading...", font=("Helvetica", 14))

    loading_label.pack(side=tk.BOTTOM, pady=10)

    # Start the Tkinter event loop

    root.mainloop()

def connect_to_mt5(login, password, server, root, trend_label):

    # Initialize MetaTrader 5

    if not mt5.initialize():

        messagebox.showerror("Error", "initialize() failed")

        mt5.shutdown()

        return

    # Log in to the MetaTrader 5 account

    authorized = mt5.login(login=int(login), password=password, server=server)

    if authorized:

        print("Connected to MetaTrader 5")

        display_account_info(root)

        fetch_and_display_chart(root, trend_label)

    else:

        messagebox.showerror("Error", "Failed to connect to MetaTrader 5")

def display_account_info(root):

    # Get account info

    account_info = mt5.account_info()

    if account_info is None:

        messagebox.showerror("Error", "Failed to get account info")

        return

    # Create a new window for account information

    info_window = tk.Toplevel(root)

    info_window.title("Account Information")

    info_window.geometry("400x300")

    # Display account information

    info_labels = [

        f"Account ID: {account_info.login}",

        f"Balance: {account_info.balance}",

        f"Equity: {account_info.equity}",

        f"Margin: {account_info.margin}",

        f"Free Margin: {account_info.margin_free}",

        f"Leverage: {account_info.leverage}"

    ]

    for info in info_labels:

        label = tk.Label(info_window, text=info, font=("Helvetica", 14))

        label.pack(pady=5)

def fetch_and_display_chart(root, trend_label):

    symbol = "USDMXN"

    timeframe = mt5.TIMEFRAME_D1

    days = 600  # Fetch 600 days of data

    data = fetch_historical_data(symbol, timeframe, days)

    scaled_data, scaler = preprocess_data(data)

    # Train the LSTM model

    model = train_lstm_model(scaled_data)

    # Predict the future prices

    future_days = 60

    predicted_prices = predict_future(model, scaled_data, future_days)

    predicted_prices = scaler.inverse_transform(np.array(predicted_prices).reshape(-1, 1))

    # Append predicted prices to the original data

    predicted_dates = pd.date_range(start=data['time'].iloc[-1], periods=future_days + 1, closed='right')

    predicted_df = pd.DataFrame({'time': predicted_dates, 'close': predicted_prices.flatten()})

    # Plot and display the chart with peaks and predictions

    plot_predictions(data, predicted_df, root)

    # Determine and display the trend

    trend = determine_trend(predicted_prices)

    display_trend(trend_label, trend)

def fetch_historical_data(symbol, timeframe, days):

    rates = mt5.copy_rates_from_pos(symbol, timeframe, 0, days)

    if rates is None or len(rates) == 0:

        raise Exception("Failed to retrieve rates")

    df = pd.DataFrame(rates)

    df['time'] = pd.to_datetime(df['time'], unit='s')

    return df[['time', 'close']]

def preprocess_data(data):

    scaler = MinMaxScaler(feature_range=(0, 1))

    scaled_data = scaler.fit_transform(data['close'].values.reshape(-1, 1))

    return scaled_data, scaler

def train_lstm_model(scaled_data):

    time_step = 60

    X_train, y_train = create_train_data(scaled_data, time_step)

    model = Sequential()

    model.add(LSTM(100, return_sequences=True, input_shape=(X_train.shape[1], 1)))

    model.add(LSTM(100, return_sequences=False))

    model.add(Dense(50))

    model.add(Dense(1))

    model.compile(optimizer='adam', loss='mean_squared_error')

    model.fit(X_train, y_train, batch_size=32, epochs=50)  # Increased epochs for better training

    return model

def create_train_data(scaled_data, time_step):

    X_train, y_train = [], []

    for i in range(time_step, len(scaled_data)):

        X_train.append(scaled_data[i-time_step:i, 0])

        y_train.append(scaled_data[i, 0])

    X_train, y_train = np.array(X_train), np.array(y_train)

    X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))

    return X_train, y_train

def predict_future(model, data, future_days):

    predictions = []

    time_step = 60

    input_seq = data[-time_step:]

    for _ in range(future_days):

        input_seq = input_seq.reshape((1, input_seq.shape[0], 1))

        predicted_price = model.predict(input_seq)[0]

        predictions.append(predicted_price)

        input_seq = np.append(input_seq[:, 1:], predicted_price)

    return predictions

def determine_trend(predicted_prices):

    start_price = predicted_prices[0]

    end_price = predicted_prices[-1]

    if end_price > start_price:

        return "Bull"

    elif end_price < start_price:

        return "Bear"

    else:

        return "Neutral"

def display_trend(trend_label, trend):

    trend_label.config(text=trend)

def plot_predictions(data, predicted_df, root):

    combined_df = pd.concat([data, predicted_df])

    fig, ax = plt.subplots()

    ax.plot(combined_df['time'], combined_df['close'], label="USD/MXN")

    ax.plot(predicted_df['time'], predicted_df['close'], 'r--', label="Predicted USD/MXN")

    ax.set_xlabel("Date")

    ax.set_ylabel("Price")

    ax.set_title("USD/MXN Daily Chart with Predictions")

    ax.legend()

    chart_frame = tk.Frame(root)

    chart_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)

    canvas = FigureCanvasTkAgg(fig, master=chart_frame)

    canvas.draw()

    canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)

if __name__ == "__main__":

    main()

 MYM-A MODO DADOCASIO import tkinter as tk

import threading

import time

import random

# Function to start the loading animation and display the dice result

def roll_dice():

    def loading_animation():

        loading_text = ["", ".", "..", "..."]

        for _ in range(3):

            for text in loading_text:

                display_var.set(text)

                time.sleep(0.5)

    # Run the loading animation

    loading_animation()

    # Display the dice result

    dice_result = random.randint(1, 3)

    display_var.set(dice_result)

    if dice_result == 3:

        message_label.config(text="Click Connect")

        root.after(10000, reset)  # Re-enable after 10 seconds for celebration

    else:

        root.after(500, enable_button)  # Re-enable shortly after result display

# Function to reset the display and button after celebration

def reset():

    message_label.config(text="")

    display_var.set("")

    enable_button()

# Function to handle button click event

def on_button_click():

    threading.Thread(target=roll_dice).start()

    click_button.config(state="disabled")

# Function to enable the button

def enable_button():

    click_button.config(state="normal")

# Function to automatically click the button every 10 seconds

def auto_click():

    while True:

        time.sleep(10)

        if click_button["state"] == "normal":  # Ensure it only clicks if button is enabled

            root.after(0, on_button_click)  # Use root.after to schedule the click in the main thread

# Initialize the main window

root = tk.Tk()

root.title("3 FACE DICE")

root.geometry("300x250")

# Create the UI elements

title_label = tk.Label(root, text="3 FACE DICE", font=("Helvetica", 16))

title_label.pack(pady=10)

display_var = tk.StringVar()

display_label = tk.Label(root, textvariable=display_var, font=("Helvetica", 24), width=5, height=2, relief="solid")

display_label.pack(pady=20)

click_button = tk.Button(root, text="Click", font=("Helvetica", 14), command=on_button_click)

click_button.pack(pady=10)

message_label = tk.Label(root, text="", font=("Helvetica", 14), fg="green")

message_label.pack(pady=10)

# Start the automatic clicking in a separate thread

threading.Thread(target=auto_click, daemon=True).start()

# Start the Tkinter event loop

root.mainloop()

 MYM-A MODO DADOROJO

import tkinter as tk

import threading

import time

import random

# Function to start the loading animation and display the dice result

def roll_dice():

    def loading_animation():

        loading_text = ["", ".", "..", "..."]

        for _ in range(3):

            for text in loading_text:

                display_var.set(text)

                time.sleep(0.5)

    # Run the loading animation

    loading_animation()

    # Display the dice result

    dice_result = random.randint(1, 3)

    display_var.set(dice_result)

    if dice_result == 3:

        display_confetti()

        root.after(10000, enable_button)  # Re-enable after 10 seconds for celebration

    else:

        root.after(500, enable_button)  # Re-enable shortly after result display

# Function to handle button click event

def on_button_click():

    threading.Thread(target=roll_dice).start()

    click_button.config(state="disabled")

# Function to enable the button

def enable_button():

    click_button.config(state="normal")

# Function to display confetti

def display_confetti():

    confetti = ["🎉", "🎊", "🎈"]

    for _ in range(10):  # Number of confetti flashes

        for c in confetti:

            display_var.set(c)

            time.sleep(0.1)

        display_var.set("3")

        time.sleep(0.1)

# Initialize the main window

root = tk.Tk()

root.title("3 FACE DICE")

root.geometry("300x200")

# Create the UI elements

title_label = tk.Label(root, text="3 FACE DICE", font=("Helvetica", 16))

title_label.pack(pady=10)

display_var = tk.StringVar()

display_label = tk.Label(root, textvariable=display_var, font=("Helvetica", 24), width=5, height=2, relief="solid")

display_label.pack(pady=20)

click_button = tk.Button(root, text="Click", font=("Helvetica", 14), command=on_button_click)

click_button.pack(pady=10)

# Start the Tkinter event loop

root.mainloop()

MYM-A MODO PRIMEROSPASOS

import tkinter as tk

from tkinter import messagebox

import MetaTrader5 as mt5

import pandas as pd

import numpy as np

from sklearn.preprocessing import MinMaxScaler

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import LSTM, Dense

import threading

import time

import random

# Global variables

is_first_login = True

dice_roll_result = 0

def main():

    global root, connect_button, display_var

    root = tk.Tk()

    root.title("MT5MYM-A with Dice")

    root.geometry("1270x600")

    # Create frames for the UI

    login_frame = tk.Frame(root, width=400, height=600, bg="lightgrey")

    login_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

   

    main_frame = tk.Frame(root, width=800, height=600)

    main_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)

    # Login UI

    login_title = tk.Label(login_frame, text="🏧MYM-A", font=("Helvetica", 20), bg="lightgrey")

    login_title.pack(pady=20)

    login_label = tk.Label(login_frame, text="Login:", font=("Helvetica", 14), bg="lightgrey")

    login_label.pack(pady=5)

    login_entry = tk.Entry(login_frame, font=("Helvetica", 14))

    login_entry.pack(pady=5)

    login_entry.insert(0, "312128713")

    password_label = tk.Label(login_frame, text="Password:", font=("Helvetica", 14), bg="lightgrey")

    password_label.pack(pady=5)

    password_entry = tk.Entry(login_frame, show="*", font=("Helvetica", 14))

    password_entry.pack(pady=5)

    password_entry.insert(0, "Sexo247420@")

    server_label = tk.Label(login_frame, text="Server:", font=("Helvetica", 14), bg="lightgrey")

    server_label.pack(pady=5)

    server_entry = tk.Entry(login_frame, font=("Helvetica", 14))

    server_entry.pack(pady=5)

    server_entry.insert(0, "XMGlobal-MT5 7")

    connect_button = tk.Button(login_frame, text="Connect", font=("Helvetica", 14),

                               command=lambda: connect_to_mt5(login_entry.get(), password_entry.get(), server_entry.get()))

    connect_button.pack(pady=20)

    # Dice Roll UI

    title_label = tk.Label(main_frame, text="3 FACE DICE", font=("Helvetica", 16))

    title_label.pack(pady=10)

    display_var = tk.StringVar()

    display_label = tk.Label(main_frame, textvariable=display_var, font=("Helvetica", 24), width=5, height=2, relief="solid")

    display_label.pack(pady=20)

    click_button = tk.Button(main_frame, text="Roll Dice", font=("Helvetica", 14), command=on_dice_button_click)

    click_button.pack(pady=10)

    root.mainloop()

def on_dice_button_click():

    threading.Thread(target=roll_dice).start()

def roll_dice():

    global dice_roll_result

    loading_animation()

    dice_roll_result = random.randint(1, 3)

    display_var.set(dice_roll_result)

    if dice_roll_result == 3:

        root.after(1000, connect_button.invoke)  # Simulate a click on the connect button

def loading_animation():

    loading_text = ["", ".", "..", "..."]

    for _ in range(3):

        for text in loading_text:

            display_var.set(text)

            time.sleep(0.5)

def connect_to_mt5(login, password, server):

    global is_first_login

    if not mt5.initialize():

        messagebox.showerror("Error", "initialize() failed")

        mt5.shutdown()

        return

    authorized = mt5.login(login=int(login), password=password, server=server)

    if authorized:

        print("Connected to MetaTrader 5")

        if is_first_login:

            display_account_info()

            start_automation()

            is_first_login = False

    else:

        messagebox.showerror("Error", "Failed to connect to MetaTrader 5")

def display_account_info():

    account_info = mt5.account_info()

    if account_info is None:

        messagebox.showerror("Error", "Failed to get account info")

        return

    info_labels = [

        f"Account ID: {account_info.login}",

        f"Balance: {account_info.balance}",

        f"Equity: {account_info.equity}",

        f"Margin: {account_info.margin}",

        f"Free Margin: {account_info.margin_free}",

        f"Leverage: {account_info.leverage}"

    ]

    for info in info_labels:

        label = tk.Label(root, text=info, font=("Helvetica", 14))

        label.pack(pady=5)

def start_automation():

    def automation_loop():

        while True:

            symbol = "BTCUSD"

            timeframe = mt5.TIMEFRAME_D1

            days = 600

            data = fetch_historical_data(symbol, timeframe, days)

            scaled_data, scaler = preprocess_data(data)

            model = train_lstm_model(scaled_data)

            future_days = 60

            predicted_prices = predict_future(model, scaled_data, future_days)

            predicted_prices = scaler.inverse_transform(np.array(predicted_prices).reshape(-1, 1))

            trend = determine_trend(predicted_prices)

            if trend == "Bull":

                place_trade(mt5.ORDER_TYPE_BUY)

            elif trend == "Bear":

                place_trade(mt5.ORDER_TYPE_SELL)

            time.sleep(3600)  # Run the prediction and trading every hour

    threading.Thread(target=automation_loop, daemon=True).start()

def fetch_historical_data(symbol, timeframe, days):

    rates = mt5.copy_rates_from_pos(symbol, timeframe, 0, days)

    if rates is None or len(rates) == 0:

        raise Exception("Failed to retrieve rates")

    df = pd.DataFrame(rates)

    df['time'] = pd.to_datetime(df['time'], unit='s')

    return df[['time', 'close']]

def preprocess_data(data):

    scaler = MinMaxScaler(feature_range=(0, 1))

    scaled_data = scaler.fit_transform(data['close'].values.reshape(-1, 1))

    return scaled_data, scaler

def train_lstm_model(scaled_data):

    time_step = 60

    X_train, y_train = create_train_data(scaled_data, time_step)

    model = Sequential()

    model.add(LSTM(100, return_sequences=True, input_shape=(X_train.shape[1], 1)))

    model.add(LSTM(100, return_sequences=False))

    model.add(Dense(50))

    model.add(Dense(1))

    model.compile(optimizer='adam', loss='mean_squared_error')

    model.fit(X_train, y_train, batch_size=32, epochs=50)

    return model

def create_train_data(scaled_data, time_step):

    X_train, y_train = [], []

    for i in range(time_step, len(scaled_data)):

        X_train.append(scaled_data[i-time_step:i, 0])

        y_train.append(scaled_data[i, 0])

    X_train, y_train = np.array(X_train), np.array(y_train)

    X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))

    return X_train, y_train

def predict_future(model, data, future_days):

    predictions = []

    time_step = 60

    input_seq = data[-time_step:]

    for _ in range(future_days):

        input_seq = input_seq.reshape((1, input_seq.shape[0], 1))

        predicted_price = model.predict(input_seq)[0]

        predictions.append(predicted_price)

        input_seq = np.append(input_seq[:, 1:], predicted_price)

    return predictions

def determine_trend(predicted_prices):

    start_price = predicted_prices[0]

    end_price = predicted_prices[-1]

    if end_price > start_price:

        return "Bull"

    elif end_price < start_price:

        return "Bear"

    else:

        return "Neutral"

def place_trade(order_type):

    symbol = "BTCUSD"

    lot_size = 0.1

    price = mt5.symbol_info_tick(symbol).ask if order_type == mt5.ORDER_TYPE_BUY else mt5.symbol_info_tick(symbol).bid

    request = {

        "action": mt5.TRADE_ACTION_DEAL,

        "symbol": symbol,

        "volume": lot_size,

        "type": order_type,

        "price": price,

        "deviation": 10,

        "magic": 234000,

        "comment": "Automated trade",

        "type_time": mt5.ORDER_TIME_GTC,

        "type_filling": mt5.ORDER_FILLING_IOC,

    }

    result = mt5.order_send(request)

    if result.retcode == mt5.TRADE_RETCODE_DONE:

        print("Trade successfully placed")

        monitor_trade(result.order)

    else:

        messagebox.showerror("Trade Error", f"Failed to place trade: {result.retcode}")

def monitor_trade(order_id):

    while True:

        position = mt5.positions_get(ticket=order_id)

        if position:

            position = position[0]

            profit = position.profit

            if profit >= 0.01:

                close_trade(order_id, position.type)

                break

        time.sleep(5)

def close_trade(order_id, order_type):

    symbol = "BTCUSD"

    price = mt5.symbol_info_tick(symbol).bid if order_type == mt5.ORDER_TYPE_BUY else mt5.symbol_info_tick(symbol).ask

    request = {

        "action": mt5.TRADE_ACTION_DEAL,

        "symbol": symbol,

        "volume": 0.1,

        "type": mt5.ORDER_TYPE_SELL if order_type == mt5.ORDER_TYPE_BUY else mt5.ORDER_TYPE_BUY,

        "position": order_id,

        "price": price,

        "deviation": 10,

        "magic": 234000,

        "comment": "Automated trade close",

        "type_time": mt5.ORDER_TIME_GTC,

        "type_filling": mt5.ORDER_FILLING_IOC,

    }

    result = mt5.order_send(request)

    if result.retcode == mt5.TRADE_RETCODE_DONE:

        print("Trade successfully closed")

        on_dice_button_click()  # Trigger dice roll after closing a trade

    else:

        messagebox.showerror("Trade Close Error", f"Failed to close trade: {result.retcode}")

if __name__ == "__main__":

    main()

 MYM-A MODO DIVINIDAD





 QUE CHATGPT ADMINISTRE LA CONTABILIDAD DEL ROBOT Y SU BACKTESTING 

 I'm about to reveal exactly how smart

money are building their positions and

hunt for liquidity by the end of the

video you'll learn how to avoid being a

victim of Market manipulation and you

also discover the sneaky traps set by

big players to hunt your orders you know

the drill like subscribe and stick

around for the full video

imagine for a second that you are the

biggest player in the market what would

you need to do to trap Traders and make

your profits at their expense

well you need to consider where is the

liquidity what might determine retail

traders to take certain positions and

then consider the methods that need to

be applied to seduce the average Trader

to actually enter a position

this is a three-step process

first you need to convince retail

traders to take positions

this technique is done by using a range

of price movements to trick Traders into

taking a position in a given Direction

this is basically setting up a trap

we'll talk about these traps later

then you instigate traders to become

emotional and think irrationally

this involves quick price moves spy

candles were fast and random price

movements

and after retail Traders are trapped you

then hunt their stops and reverse the

price

this is the simplest definition of a

market Maker's activity

now remember what happened the last time

your stops were hunted

you were induced to take a position

thinking price is going to move in a

certain direction or maybe you were

triggered by the speed of a price

movement

then once the Trap has been set and you

took the bait price moved against you

so how to avoid this let's discuss the

most common traps used by smart money

the Asian trading session is one of the

main zones targeted by the smart money

in this example we highlighted the Asian

sessions

we see that the Asian session is not as

liquid and volatile as other major

trading sessions

and one of the most common strategies

used by retail Traders is to identify

the trend and wait for the breakout

outside of the Tokyo range

but if we look closer we'll see that

this is not a viable strategy

if we analyze these three consecutive

Tokyo sessions

we see an interesting pattern

range traders who have taken short

positions at the top of the Asian range

had their stop losses hunted outside of

the range

each time the market reversed

aggressively in the opposite direction

the upward movement outside of the range

also enticed traders to take long

positions

hoping for a breakout trade

so there's a second batch of traders who

were trapped long breakout Traders

when you have a cluster of orders in a

similar Price Zone this Zone will be

targeted by Big Market players

so if range trading could lead to your

stops being hunted and breakout trades

are also risky how do you actually avoid

the Tokyo trap the good news is that

when you know how a stop Hunt works you

can employ strategies to prevent being

hunted in the first place

remember one of the key ingredients to

stop hunting is a cluster of stop-loss

orders near a similar price

stop loss orders might be clustered

together for two reasons the Market's

pattern points people to place a stop

loss near similar levels

or Traders Place orders hoping for a

Breakout

the safest way is to enter after you

spot a liquidity clear out a move

outside the range and a quick

retracement back inside of it

buying at the top of the Tokyo range or

selling at the bottom of the range is

outdated and should be avoided

[Music]

smart money also induce traders to take

the wrong direction by using sharp and

aggressive moves near the high or low of

the day

one of the ways of identifying that you

are in the right place is that the

market will seem to be quiet in

consolidation and make a sharp move out

of the range faking the Breakout

if you were to take a trade in the area

of the high or the low of the day

you might notice that price has some

activity

you'll see the quotations changing

but the actual movement is little

ticks are moving up and down suggesting

that there's lots of activity

but in fact there is little movement

in this case a reversal might be on the

cards

the stop hunt involves a deliberate

movement outside of the range to what

will become the new high or low of the

day

the stop hunt has two major objectives

to take out existing stops

and to encourage traders to commit to

new positions in a direction that is

opposite to where the real trend is

going to be

it is common to see price undergo a

further price of accumulation which

induced traders to take further

positions

and when there are enough positions the

price is moved in the direction of the

true trend

and their stops will be triggered

also there is often a second move to the

high or low of the day and most of the

time it will fail to take it out

face forms the typical M and W patterns

a wedge or a triangle is a common

pattern which allows smart money to trap

traders in both directions

in this example you can observe that on

the lower boundary of the wedge

the lows become slightly higher each

time it comes down to the line

this has the effect of ensuring that

none of the traders that are taking

short positions in these regions can

turn a profit

similarly on the upper boundary of the

wedge the same thing is happening with

each of the highs becoming progressively

lower and trapping the higher level

lungs and pulling them down

there is no way of predicting which

direction the price will break

this is determined by the net volumes

that occur

in other words if there is a greater

buildup of short positions over the long

positions then the wedge will break up

[Music]

during Market open the smart money

trapped novice traders to believe Market

is moving in One Direction

but in fact reversal is just around the

corner

I call them morning reversals

often you will see prices moving in One

Direction very strongly from the opening

bell

the momentum is so strong it creates a

parabolic curve

it makes you regret not entering early

but don't get trapped these parabolic

moves often get reversed

the psychology behind this is simple

the trend is healthy when it's made of

average Trend bars consecutive Trend

bars and small Corrections but when the

momentum gets out of control with such a

parabolic curve with large bars and

without pullbacks the market control has

to be restored

price is only favoring one side

resistance will be met

keep this in mind when you see volatile

movements in the early morning

when you see clear signs of failure or

exhaustion counter it

[Music]

accumulation and distribution periods in

the market are a constant process of

Exchange

the difficulty is to find what variables

might indicate that the market is in the

accumulation or a distribution phase

it's all very clear after the fact but

find variables in the live market it's a

harder task

this phase starts with the resetting of

a daily high or low

then follows a period where tends to be

legal activity

and the market just Cycles back and

forth between two price points

after a while the range begins to widen

this has the effect of triggering

bending orders placed by breakout

Traders

smart money gradually accumulates as

more and more Traders begin to Take

debate

however

when they are triggered the price is

quickly pulled away and they will often

be stopped out on the other side of the

range which is also widening

your play here should be in the first

place to find the spring the fake

breakout out of the accumulation phase

and then to trade in the opposite

direction of this failed breakout

the move out of the consolidation area

tends to be very sharp and short

the first thing you need to see is a

large sideways consolidation area

generally the longer the consolidation

the more powerful the resulting thrust

once the consolidation is underway you

look for the spring pattern the spring

is simply a false breakout of the

accumulation area where weaker hands

expand expect a larger retracement or a

Breakout

the market breaks out of the

consolidation only to return inside the

range

in a consolidation area after an uptrend

the spring would appear on the lower

side of the range

in a consolidation area after a

downtrend the spring would appear on the

upper side of the range

in the case of a bullish spring a false

breakout on the lower side of a

consolidation area the entry is when the

market swings higher from the spring

candle

I like this approach because you can

even place a buy stop above the spring

area

and any swing higher will activate the

entry

foreign

[Music]

bars within a trading range

often you will see a large body

Candlestick with little or non-wick

taking a lot of space within a range

it looks very strong but it can also

trap a lot of traders to enter

price is rotating inside the range

sometimes breaks out for a bit flushing

out weak players out of the market

but it is usually contained within an

approximate range if a large bar is

taking all the space there is actually

no more room to move

price has Traverse

therefore when you see a large body

candle in the middle of the range don't

enter it's a possible trap so faded

if you look in your chart history you'll

see that most large bars inside of the

range are countered instead of being

followed up

one other aspect to keep in mind there

are always Traders on the other end of

the giant bar ready to counter it and

scalp for a quick profit

if you pull up a chart you can see large

range bars are usually not followed up

with continuation during a range

psychology behind this is simple traders

who profited from this large range

candle are exiting

therefore there are more circumstances

where a large body bar is followed with

a small pause or even a pullback before

it's continuing its trend

here are other failed large Body candles

inside of a range

they are huge in size but they are not

representing any strength

they have no follow-up and are being

countered one after another

as a side note not all high spread bars

are fake the key is analyzing them

within context

so be aware of the size of the range

when scalping against These Bars

if you want to see more videos like this

one give us a like And subscribe

and check out our Academy program if you

want to further level up your Trading

until next time