# Import necessary modules from separate folders

from config.settings import Settings

from config.api_keys import APIKeys

from data_collection.market_data.historical_data_fetcher import fetch_historical_data

from data_preprocessing.feature_engineering.custom_indicators import calculate_rsi,

from strategy_engine.traditional_strategies.supply_demand_trader import

from strategy_engine.machine_learning.deep_reinforcement_learning_trader import

from risk_management.position_sizing.dynamic_position_sizing import calculate_position_size

from trade_execution.order_handling.order_execution import execute_order

from backtesting.performance_analysis.backtest_final_report_generator import

from dashboard.backend_logic.live_event_tracker_dashboard import display_live_events

from learning_and_adaptation.adaptive_learning.online_learning_engine import update_model

# Initialize settings and API keys

settings = Settings()

api_keys = APIKeys()

# Main function

def main():

print("Starting AI-Based Trading System...")

# Step 1: Initialize databases

initialize_databases()
# Step 2: Fetch historical market data

symbol = 'EUR/USD'

timeframe = '1m'

historical_data = fetch_historical_data(symbol, timeframe)

# Step 3: Preprocess data

preprocessed_data = preprocess_data(historical_data)

# Step 4: Detect supply/demand zones using ICT concepts

zones = detect_supply_demand_zones(preprocessed_data)

print(f"Supply/Demand Zones Detected: {zones}")

# Step 5: Train machine learning models

ml_model = train_ml_model(preprocessed_data)

# Step 6: Train reinforcement learning agents

rl_model = train_rl_agent(preprocessed_data)

# Step 7: Execute trading loop

run_trading_loop(preprocessed_data, ml_model, rl_model, zones)

# Step 8: Generate backtest report

backtest_report = generate_final_backtest_report(get_backtested_trades())

print(f"Backtest Report: {backtest_report}")

start_dashboard()

print("Trading System Initialized Successfully.")

# Helper Functions

def initialize_databases():

"""Initialize all required databases."""

from databases.create_influxdb import create_market_data_db

from databases.create_postgresql_db import create_trade_history_db

create_market_data_db()

create_trade_history_db()

print("Databases Initialized.")

def preprocess_data(raw_data):

"""Preprocess raw market data."""

from data_preprocessing.cleaning_and_normalization.data_cleaning import clean_data

from data_preprocessing.feature_engineering.custom_indicators import calculate_rsi,

cleaned_data = clean_data(raw_data)

cleaned_data = calculate_rsi(cleaned_data)

cleaned_data = calculate_macd(cleaned_data)

return cleaned_data
def train_ml_model(data):

"""Train a machine learning model."""

from strategy_engine.machine_learning.neural_networks_forecasting import

X = data[['rsi', 'macd']]

y = data['target'] # Example target column

model = create_forecasting_model(input_shape=(X.shape[1],))

model.fit(X, y, epochs=10, batch_size=32, verbose=0)

print("Machine Learning Model Trained.")

return model

def train_rl_agent(data):

"""Train a reinforcement learning agent."""

from learning_and_adaptation.reinforcement_learning.reinforcement_learning_env import

from stable_baselines3 import PPO

env = TradingEnv(data)

model = PPO('MlpPolicy', env, verbose=1)

model.learn(total_timesteps=10000)

print("Reinforcement Learning Agent Trained.")

return model

def run_trading_loop(data, ml_model, rl_model, zones):

"""Run the main trading loop."""

from trade_execution.order_handling.order_execution import execute_order

account_balance = 10000

risk_percentage = settings.risk_percentage

max_drawdown = settings.max_drawdown

while True:

# Get latest price data

current_price = get_current_price(symbol='EUR/USD')

# Predict using ML and RL models

ml_signal = ml_model.predict(data[['rsi', 'macd']])[-1]

rl_signal = rl_model.predict(data[['close', 'volume']])[-1]

# Combine signals with ICT rules

if current_price > zones['supply'] and ml_signal == 1 and rl_signal == 1:

action = 'buy'

elif current_price < zones['demand'] and ml_signal == 0 and rl_signal == 0:

action = 'sell'

else:

action = 'hold'

# Calculate position size

stop_loss = calculate_stop_loss(data)
 position_size = calculate_position_size(account_balance, risk_percentage, stop_loss)

# Execute trade

if action != 'hold':

order = {'symbol': 'EUR/USD', 'side': action, 'quantity': position_size, 'price':

execute_order(order)

print(f"Trade Executed: {order}")

# Check drawdown and pause if necessary

if not check_max_drawdown(account_balance, max_drawdown):

print("Max Drawdown Exceeded. Pausing Trading.")

break

# Update models with new data

update_model(ml_model, get_new_data())

def calculate_stop_loss(data):

"""Calculate stop-loss level."""

from risk_management.stop_loss.volatility_based_stop_ict import calculate_ict_stop_loss

return calculate_ict_stop_loss(data)

def check_max_drawdown(account_balance, max_drawdown):

"""Check if max drawdown has been exceeded."""

from risk_management.position_sizing.max_drawdown_monitor import

current_balance = get_current_account_balance()
 return monitor_max_drawdown(account_balance, current_balance, max_drawdown)

def get_current_price(symbol):

"""Fetch current price for a given symbol."""

from data_collection.market_data.real_time_data_fetcher import stream_real_time_data

return stream_real_time_data(symbol=symbol)[-1]['close']

def get_new_data():

"""Fetch new data for online learning."""

from data_collection.market_data.high_frequency_data_enrichment import

ticks = fetch_tick_data(symbol='EUR/USD')

order_book = fetch_order_book(symbol='EUR/USD')

return enrich_high_frequency_data(ticks, order_book)

def get_current_account_balance():

"""Fetch current account balance."""

from trade_execution.order_handling.order_routing import get_account_balance

return get_account_balance(api_keys.get_binance_client())

def get_backtested_trades():

"""Fetch backtested trades for reporting."""

from backtesting.strategy_testing.strategy_tester import backtest_strategy

strategy = load_strategy()

data = load_backtest_data()

return backtest_strategy(strategy, data)

"""Load a predefined strategy for backtesting."""

from strategy_engine.traditional_strategies.trend_following import trend_following_strategy

return trend_following_strategy

def load_backtest_data():

"""Load historical data for backtesting."""

from data_collection.market_data.historical_data_fetcher import fetch_historical_data

return fetch_historical_data(symbol='EUR/USD', timeframe='1h', limit=1000)

def start_dashboard():

"""Start the dashboard server."""

from dashboard.backend_logic.ui_backend import app

import threading

def run_dashboard():

app.run(debug=True)

dashboard_thread = threading.Thread(target=run_dashboard)

dashboard_thread.start()

print("Dashboard Started.")

if __name__ == '__main__':

main()