Python in algorithmic trading - page 4

[MetaQuotes]

Build Your Own MetaTrader 5 Python Trading Bot: EMA Indicator

Get the code at GitHub: https://github.com/jimtin/algorithmic_trading_bot

Build Your Own MetaTrader 5 Python Trading Bot: EMA Indicator

This section of the video demonstrates how to create a function for calculating exponential moving average (EMA) indicator in Python. The video provides step-by-step instructions for creating the function, which calculates the average value of previous trades with a multiplier applied to the most recent trade, and how to add a column for the EMA to each row of the data frame. The video also emphasizes the importance of commenting functions and using a pseudo-library to make the code reusable and conform to the "don't repeat yourself" principle. The video concludes by demonstrating how to calculate different types of EMAs that will be used in the upcoming EMA crossover strategy.

• 00:00:00 In this section, the video discusses the process of building an EMA indicator for your algorithmic trading bot. The exponential moving average (EMA) calculates the average value of previous trades with a multiplier applied to the most recent trade. The multiplier weighs the most recent trades to have a greater impact on the EMA value, making it more sensitive to price movements. The video provides the pseudocode and step-by-step instructions for creating the function that calculates the EMA value, as well as how to add a column for the EMA to each row of the data frame. The video emphasizes the importance of commenting functions and using a pseudo-library to make the code re-usable and conform to the "don't repeat yourself" principle.
  
  
• 00:05:00 In this section, the video explains how to create a function for calculating the Exponential Moving Average (EMA) indicator in Python. The function can be used to add a new EMA to a data frame, which is important for the EMA cross strategy that will be discussed in the next episode. The function sets up a multiplier which can be adjusted based on the desired weighting of the EMA, and iterates through the data frame row by row to unpack and calculate the EMA. The video advises against using this method on large data frames and recommends using the TA lib function instead for faster computation. The section ends by returning to main.py and demonstrating how to calculate different types of EMAs which will be used in the upcoming EMA crossover strategy.
  
  
• 00:10:00 In this section of the video on building a MetaTrader 5 Python Trading Bot, the speaker explains how to calculate and print EMA 50, EMA 20, and EMA 200 by passing the candlestick dataframe to the iterative method, and setting values accordingly. Removing the print statement can be done, as per the speaker, to check for the EMA 50 and EMA 20 rows, while calculating EMA 200. All three values can then be viewed separately.

[MetaQuotes]

Build Your Own MetaTrader 5 Python Trading Bot: EMA Cross Strategy

Get the code at GitHub: https://github.com/jimtin/algorithmic_trading_bot

Build Your Own MetaTrader 5 Python Trading Bot: EMA Cross Strategy

In this video tutorial, the presenter explains and implements the EMA cross strategy to build a trading bot to place trades automatically. The strategy involves using two EMAs, EMA 50 and EMA 200, and generates buy or sell signals when EMA 50 crosses over or below EMA 200, respectively. He also discusses stop loss, entry price, and take profit for each trade and how to create a separate function to design a library. The presenter updates the EMA cross strategy function to integrate with the get_data function created in a previous episode, and the indicators function returns all the necessary information to the calling function. The code is simplified by extracting the timeframe, making it easier to manage and maintain for algorithmic traders.

• 00:00:00 In this section of the video, the presenter explains the EMA cross strategy and how it works. He mentions that the strategy involves using two EMAs, specifically the EMA 50 and EMA 200, and how a Buy Signal is generated when the EMA 50 crosses above the EMA 200, indicating an upward trend, while a Sell Signal is generated when the EMA 50 crosses below the EMA 200, indicating a downward trend. He also talks about the stop loss, entry price, and take profit for each trade, highlighting that the stop loss is always the corresponding highest EMA, while the entry price is the high or low of the previously completed candle depending on the signal generated. Finally, he discusses how to extract and abstract away the strategy into a separate function to create a library.
  
  
• 00:05:00 In this section of the video, the presenter outlines a pseudo code of the steps involved in building a trading bot based on the EMA cross strategy. The first step is to retrieve the data, which can come from various sources. The function created for this purpose has two parameters, symbol and time frame. In this episode, the data is retrieved from MT5 using a library created in a previous episode that returns a data frame. The second step involves calculating the indicators, which for this strategy are EMA 50 and EMA 200.
  
  
• 00:10:00 In this section of the video, the focus is on updating the EMA cross strategy function to take advantage of the get_data function previously created. The first step is to retrieve the data by creating a variable and using the get_data function to store the data in it. The second step involves calculating the EMA indicators and EMA cross, which is done by creating a function called calc_indicators that takes a data frame and calculates the EMA 50, EMA 200, and EMA cross. This algorithm is designed in such a way that it can easily be updated to work with different exchanges in the future. The data frame is passed to each of the EMA calculators and EMA cross calculators, and the resulting data frame with all the necessary information is returned to the function. This data is then used to update the EMA cross strategy function before being added back into the main.pi file.
  
  
• 00:15:00 In this section, the presenter updates the indicators function to return all the information back to the calling function. The updated function can be used over and over again, making it easier to manage the code. The presenter imports the EMA cross strategy into Main and passes in the symbol, time frame, and EMA values to see what comes out. The code is simplified by extracting the time frame, making it easier to manage, typically breaking down less and ultimately making the life of an algorithmic trader a lot easier.

[MetaQuotes]

Build Your Own MetaTrader 5 Python Trading Bot: EMA Cross Detector

Get the code at GitHub: https://github.com/jimtin/algorithmic_trading_bot

Build Your Own MetaTrader 5 Python Trading Bot: EMA Cross Detector

The video tutorial teaches how to create an EMA cross detector using Python, discussing the process of creating two different EMAs and identifying potential trends in the market, and walking through how to construct the EMA crossover detector function. The function creates two new columns, position and pre-position, and checks whether a cross event has occurred to create a column that sets True if a crossover has occurred; it also demonstrates how to use the EMA cross detector in main.py by extracting only the rows that have a true crossover event. The tutorial also hints at the next episode where it will demonstrate how to calculate a personal EMA cross strategy.

• 00:00:00 In this section, the video tutorial discusses the process of creating an EMA cross detector using Python. The host advises having the ability to calculate exponential moving averages (EMA) and the pandas library installed. An EMA cross involves plotting two different EMAs on a chart to identify potential trends in the market. To use an EMA cross strategy, a shorter-term EMA and a longer-term EMA are plotted, and when the shorter-term EMA crosses above the longer-term EMA, it's a bullish signal, and when it crosses below, it's a bearish signal. The tutorial then proceeds to walk through how to construct the EMA crossover detector function, which accepts three different variables, and advises the importance of commenting code as you work through it.
  
  
• 00:05:00 In this section, the speaker explains how the EMA cross detector works by creating two new columns called position and pre-position. By comparing the two EMA columns, the function checks whether a cross event has occurred, and then creates a column that sets True if a crossover has occurred, and False for everything else. The function also utilizes numpy and a Lambda function to quickly perform these operations, and then removes the position and pre-position columns before returning the EMA detector results to the user. The speaker then demonstrates how to use the EMA cross detector in main.py by extracting only the rows that have a true crossover event.
  
  
• 00:10:00 In this section, the speaker shows how to extract true values from the EMA cross data frame by setting the EMA cross true variable, print them to the screen, and create an EMA cross trading bot. Furthermore, he hints at the next episode where he will demonstrate how to calculate a personal EMA cross strategy.

[MetaQuotes]

Build Your Own MetaTrader 5 Python Bot: BUY and SELL Signals

Get the code at GitHub: https://github.com/jimtin/algorithmic_trading_bot

Build Your Own MetaTrader 5 Python Bot: BUY and SELL Signals

This video tutorial focuses on creating buy and sell signals for a Python bot in MetaTrader 5 (MT5), using the EMA cross strategy with 50 and 200 EMAs. The tutorial explains the rules for generating signals for both buy and sell, along with stop loss, entry price, and take profit. A function is created to generate trade signals for the bot, recording the parameters for each trade along with the corresponding highest EMA. Additional columns are created to record values for trade signals, and the function also includes a check to ensure that the EMA values are not equal at the start of the function. The tutorial shows how to skip rows that are less than the minimum value of EMA and calculate stop loss, stock price, and take profit for both green and red candles. The generated signals are added back into the previously created columns, generating a list of trade signals for the bot.

• 00:00:00 In this section, the video tutorial focuses on how to turn the EMA cross strategy into buy and sell signals that can be used for auto trading bots. The EMA cross strategy generates a trade when two EMAs cross each other, and the tutorial uses the 50 and 200 EMAs. A buy signal is generated when the EMA 50 crosses above the EMA 200, indicating an upward trend, while a sell signal is generated when the EMA 50 crosses below the EMA 200. The tutorial also explains the rules for stop loss, entry price, and take profit for both buy and sell signals. The video then shows how to use the strategy function to convert the information into trade signals, setting the stage for future episodes where the signals will be fed into MetaTrader 5 to make trades.
  
  
• 00:05:00 In this section, the presenter provides an overview of the function to generate the buy and sell signals for the Python bot in MetaTrader 5 (MT5). The function records the parameters for each trade, including the corresponding highest exponential moving average (EMA), stop loss, take profit, and trade values. The presenter notes that the code includes a check to ensure that the EMA values are not equal at the start of the function, and the greater of the EMAs is used to determine which EMA column to use for the stock price. The function also creates additional columns for the data frame to record values for trade signals, enabling easier modification of the data without generating copy warnings. Finally, the presenter highlights that this function can be used to chart past trading values in a future episode.
  
  
• 00:10:00 In this section, the video discusses how to skip rows that are less than the minimum value of the Exponential Moving Average (EMA) and wait until the two EMAs are in operation. It also emphasizes waiting until the last few times the actual EMA value is calculated before using it. The tutorial then looks at calculating the stop loss, stock price, and take profit for both green and red candles. Finally, it discusses adding the generated signal back into the previously created columns.
  
  
• 00:15:00 In this section, the speaker shows how to retrieve trade event data and update the main file to print the True Values or strategy results that return true. By doing so, they generate a list of trade signals that can be used in a trading bot. The next steps will show how to use these signals to make trades on MetaTrader 5.

[MetaQuotes]

Build Your Own MetaTrader 5 Python Trading Bot: Lot Size Calculator

Get the code at GitHub: https://github.com/jimtin/algorithmic_trading_bot

Build Your Own MetaTrader 5 Python Trading Bot: Lot Size Calculator

This video discusses how to build a lot size calculator function for a trading bot on Metatrader5 using Python. The function requires knowledge of the balance being risked, risk amount, stop-loss price, entry price, and the symbol being traded, and differs for Forex trading. The speaker emphasizes the importance of rounding values to prevent Metatrader5 from rejecting the calculation and shows how to add a different currency to the function. They also discuss adding in the exchange rate, making the code more robust by adding a catch-all else statement, and providing a standard calculation for pip size and pip value. The next part of the series will focus on safely and efficiently placing orders on Metatrader5.

• 00:00:00 In this section, the presenter explains the steps involved in building your own Metatrader5 Python trading bot, starting with the creation of a lot size calculator. He advises that to calculate the lot size, one needs to know the stop loss, stock price, balance, and risk amount. The presenter recommends previous episodes on his channel for more information on understanding stop loss and stock prices, as well as on using a strategy to calculate signals. The other three episodes following the lot size calculator would help traders to place orders on Metatrader5 safely and efficiently. The presenter emphasizes the importance of creating a pseudo Library function for the lot size calculator, giving code explanations for each step.
  
  
• 00:05:00 In this section of the video, the instructor discusses the steps to build a lot size calculator function for a trading bot. He explains that the function requires knowledge of the balance being risked, the risk amount, stop-loss price, entry price, and symbol being traded. The lot size calculation differs for Forex trading and requires the calculation of pip size and pip value. The instructor provides an example of how to calculate the amount to risk and the pip value for USD/JPY currency pair. Finally, he suggests using the current exchange rate for the entry price instead of querying the mt5 for the exchange rate.
  
  
• 00:10:00 In this section, the video explains how to calculate lot size and the importance of rounding values when presenting the lot size to Metatrader5. The speaker highlights how presenting large decimal values can result in Metatrader5 rejecting the calculation and how rounding to two decimal places can help. However, using the lot size calculator with very small balances can present issues due to the rounding effect. The speaker recommends trading with a larger lot size or accepting that risk calculations may be skewed. The video also briefly shows how to add a different currency, such as the Canadian dollar, to the function.
  
  
• 00:15:00 In this section, the speaker discusses adding in the exchange rate, determining the raw lot size, and making the code more robust by adding a catch-all else statement. They caution against using the catch-all else statement too liberally and suggest only trading symbols that have been thoroughly researched. The speaker also provides a standard calculation for pip size and pip value and hints at placing orders in the next part of the series.

[MetaQuotes]

Build Your Own MetaTrader Python Trading Bot: Order Creator Part 1

Get the code at GitHub: https://github.com/jimtin/algorithmic_trading_bot

Build Your Own MetaTrader Python Trading Bot: Order Creator Pt 1

The YouTube video titled "Build Your Own MetaTrader 5 Python Trading Bot: Order Creator Pt 1" covers the process of creating orders on MetaTrader5 using Python. The video is part one of two, with this section focusing on the second step of the order creation process, which involves checking the orders before placing them. The video covers the creation of a dictionary object called 'request' that passes the necessary trade information to the order creator function. The speaker also explains how to set the request type for a sell or buy stop order, how to use the Metatrader5 order check request to prevent common errors, and the importance of formatting numbers correctly before passing them into MetaTrader 5. The next episode will cover the actual placement of orders on MetaTrader5.

• 00:00:00 In this section, the YouTuber explains how to start creating orders on MetaTrader 5 using Python. The order creation process has four distinct steps, and in this particular episode, the focus is on the second step, which is to check your orders before placing them. This is an essential step, as it helps to catch any common errors that traders often make when placing orders, saving them from making costly mistakes. The order details needed for this function include the order type, symbol, volume, stop loss, take profit, comment, stop price, and whether it's direct or not. This episode is part one of two, with the next one covering the actual placement of orders.
  
  
• 00:05:00 In this section, the speaker explains how to use the 'direct' Boolean in a recursive function, and the importance of formatting numbers with correct decimal places before passing them into MetaTrader. The speaker also emphasizes the difference between lot size and trade size and recommends watching the linked lot size calculator episode to avoid errors in risk calculation. The section concludes with the creation of a dictionary object called 'request,' which is used to pass necessary trade information like symbol, volume, stop loss, take profit, type time, and comment to order creator function.
  
  
• 00:10:00 In this section, the speaker explains how to set the request type for a sell stop order using the Metatrader5 Python API and adds a sanity check to prevent common errors like placing a stop price of zero. The same method is used for creating a buy stop order. The speaker emphasizes that the API offers many different options for working with orders and maximizing profit. The section also introduces the direct equals true or false statement that will be used in the next episode for placing orders on MetaTrader5.
  
  
• 00:15:00 In this section of the video, the presenter explains how the code will check whether a trade can be placed or not using the Metatrader5 order check request. The check is not foolproof and may miss certain errors, but it can help with the most common ones. If the result is zero, the order gets placed. If not, the code will catch some common errors and print messages. In the next episode, the order check will be turned into an actual order placement on MetaTrader5.

[MetaQuotes]

Build Your Own MetaTrader 5 Python Trading Bot: Order Creator Part 2

Get the code at GitHub: https://github.com/jimtin/algorithmic_trading_bot

Build Your Own MetaTrader 5 Python Trading Bot: Order Creator Pt 2

The video is a continuation of the tutorial on building a MetaTrader5 Python trading bot and discusses the process of code implementation for sending an order, handling different outcomes, and understanding error codes that can be returned by MetaTrader5. The presenter highlights the significance of customizing the code based on personal preferences and understanding the errors that may occur while using the bot. The presenter also provides an example function notifying the user of errors and stopping the execution if necessary.

• 00:00:00 In this section of the video, the presenter discusses the four distinct steps involved in building a MetaTrader5 Python trading bot, including calculating lot size, checking the order, placing the order, and wrapping everything together. The presenter also emphasizes the importance of understanding the different error codes that can be returned by MetaTrader5 and showcases some common examples. The video then dives into the code needed for sending an order to MetaTrader5 and explains how to handle different outcomes from the order result, using a recursive function approach.
  
  
• 00:05:00 In this section of the video, the speaker discusses some of the options and errors that may occur when using an auto trading bot in MetaTrader 5 Python. One common error is leaving auto trading on when changing accounts, which can cause issues for the rest of the code. The speaker explains their personal preference for raising breaking errors versus non-breaking errors, depending on the type of error and the potential impact on future trades. They also provide an example function that notifies the user of any errors and stops execution if necessary. Overall, the speaker emphasizes the importance of adapting the code to one's own needs and preferences.

[MetaQuotes]

Build Your Own MetaTrader 5 Python Trading Bot: Order Creator Part 3

Get the code at GitHub: https://github.com/jimtin/algorithmic_trading_bot

Build Your Own MetaTrader 5 Python Trading Bot: Order Creator pt 3

This video tutorial focuses on building a MetaTrader 5 Python trading bot and covers several steps in placing orders on the platform, including calculating the lot size, checking orders for issues, placing orders, and wrapping everything together to ensure efficiency and safety. The tutorial discusses the variables needed for the bot, such as balance, comment, risk amount, symbol, and trade values like stop loss and take profit. The video demonstrates the use of calc lot size helper function and the importance of error checking while also stressing the need for research and attention to detail. The tutorial concludes with an explanation on using data frames to extract required values and explores ways to make the bot trade continuously in the next episode.

• 00:00:00 In this section, the video tutorial shows how to combine the order creation and lot size calculations from the previous episodes, which will provide a wide range of options to explore in future episodes. The tutorial covers four distinct steps in placing orders on MetaTrader5: calculating the lot size, checking the order for issues, placing the order, and wrapping all the pieces together to ensure it is fast, efficient, and safe. The episode breaks down these steps into four separate videos to enable viewers to focus on the specific information they need. The tutorial explains how the make_trade.py file can be used to add functionality like sending trades to Discord, Slack, or Twitter by putting it into its own file.
  
  
• 00:05:00 In this section of the video on building a MetaTrader 5 Python trading bot, the presenter discusses the variables that will be needed for the bot, including balance, comment, risk amount, symbol, and trade values such as take profit, stop loss, and stock price. The pseudo-code for formatting the values and determining the lot size is also presented, and the presenter mentions future provisions that could be added to the bot, such as sending trade outcomes to Discord or managing different accounts for different currencies. The balance, take profit, stop loss, and stop price are all formatted to floats and rounded to two decimal places.
  
  
• 00:10:00 In this section, the video tutorial focuses on determining the lot size and trade type for the trading bot using the calc lot size helper function created earlier. The video demonstrates a simple way to determine buy stops and sell stops in the strategy. After getting all the required values, the trade outcome is returned to the user, and to-do's are added for future work to make the trading bot more functional. The video focuses on integrating the "make trade" function into the strategy and updating it to check the previous trade and send it to the MetaTrader 5 platform.
  
  
• 00:15:00 In this section, the video tutorial teaches how to simplify the main function by taking out some of the functions and incorporating them into the strategy function. The video also discusses the importance of error checking and the ability to recognize and correct coding errors while also stressing the necessity of research and attention to detail. The strategy function is further developed by including additional pieces of information necessary for risk management, and the video demonstrates how to add comments to differentiate strategies being used on the same MetaTrader account. The tutorial concludes with a discussion on making trades and utilizing the information needed to do so effectively.
  
  
• 00:20:00 In this section, the video tutorial shows how to use the data frame to extract the required values for take profit, stop price, and stop loss. The tutorial also explains the make trade outcome, which is initially set to false. The positional arguments, balance, and amount to risk, are hardcoded for now, but the tutorial will explore ways to make it more dynamic in future episodes. Overall, the focus is on getting the strategy together and making the bot trade continuously in the next episode.

[MetaQuotes]

Build Your Own MetaTrader Python Trading Bot: Never Miss A Candlestick

Get the code at GitHub: https://github.com/jimtin/algorithmic_trading_bot

Build Your Own MetaTrader Python Trading Bot: Never Miss A Candlestick

This video tutorial demonstrates how to build a Python trading bot in MetaTrader 5 that will never miss a Candlestick. The code initiates MetaTrader 5, captures current and previous times, and utilizes a while loop to retrieve a single candle and compare to the previous candle to identify new candlesticks. The video emphasizes the importance of correcting spacing in the code, implementing a sleep function to prevent crashing, and utilizing a separate function to simplify the main function. The instructor also provides guidance on how to handle errors in the code and use print statements for clear testing.

• 00:00:00 In this section of the video, the presenter shows how to monitor Metatrader5 to ensure that your trading strategy does not miss any new Candlesticks. The code used is straightforward, with a startup function used to initiate MetaTrader5, and variables set up to capture the current and previous times. A while loop is used to keep the trading function running as long as it is true, and the code retrieves a single candle using the timeframe for the strategy and compares the current time with the previous time. If values are not equal, a new Candlestick has occurred, and a check is implemented to see if a trade needs to occur before implementing the trade. The BTCUSD currency pair is used to get the current time, as it trades 24/7, and the time is assigned to the current time variable.
  
  
• 00:05:00 In this section, the video discusses the importance of updating the spacing in the code to ensure that all tabs are in line. The code checks if there is a new candle and if there is, it runs it through the strategy to see if a trade needs to occur. The video also mentions the use of `time.sleep(1)` to prevent high CPU usage and program crashing. The main function is then cleaned up by pulling out the symbols and time frame to create a separate function, `run strategy`, that allows for passing the strategy in at any given time while simplifying the main function. Lastly, the video discusses the process of extracting the symbols that the strategy applies to and the time frame used for trading, while keeping the time frame in main for polling of MT5 to get new candles.
  
  
• 00:10:00 In this section, the instructor explains how to handle errors in the code when building a trading bot using Python in MetaTrader 5. The video shows how to use the MetaTrader 5 library and the Strategy library to deal with error handling in the code. A "true" value is returned if the strategy was successfully run, while "false" is returned if no trade occurs, indicating that no order has been placed on MetaTrader 5. Additionally, the instructor suggests using a print statement to make the testing process clearer and easier to understand for the user.

[MetaQuotes]

Build Your Own MetaTrader 5 Python Trading Bot: Auto Manage Every Trade

Get the code at GitHub: https://github.com/jimtin/algorithmic_trading_bot

Build Your Own MetaTrader 5 Python Trading Bot: Auto Manage Every Trade

This video is part of a series on building a MetaTrader 5 Python trading bot, and focuses on managing orders. The speaker explains how to cancel an order and retrieve all open orders, while also emphasizing the importance of effective risk management in trading. The strategy of cancelling all open orders is a simple but valid way of managing the risk associated with open positions. The speaker also announces that the next episode will demonstrate how to manage multiple strategies on the same MetaTrader 5 account.

• 00:00:00 In this section, the speaker covers an overview of the three episodes in the series of building a MetaTrader 5 Python trading bot, including how to monitor MetaTrader 5 and never miss a Candlestick, managing trading orders to reduce risk, and managing multiple strategies on the same account. The focus of this episode is managing orders, including the ability to cancel an order using the mt5_lib file, creating a request object, and using the try-accept pattern to handle any errors. Furthermore, comments are added to the code for easier management purposes, and understanding error codes is crucial for adding functionality to the trading bot.
  
  
• 00:05:00 In this section, the speaker explains how to cancel an order and retrieve all open orders. When an error occurs, it is returned to the user, and the speaker chooses to simply raise an error as a breaking change. To cancel all open orders, the function will not require any parameters and will return a list of open orders. Understanding the terms "order" and "position" is essential in managing trading risks in MetaTrader 5. The two functions are then combined into the main function to manage the timing of when to cancel the orders as part of the trading strategy.
  
  
• 00:10:00 In this section, the speaker talks about the importance of effective risk management in trading and how to implement it in the trading bot. The strategy involved cancelling all open orders, which is a simple but valid way of managing the risk associated with open positions. The speaker also mentions that in the next episode of the series he will demonstrate how to manage multiple strategies on the same MetaTrader 5 account.