Category: Python Auto Trading

Automated trading is a system that automatically executes trades in financial markets based on algorithms.
This eliminates the emotional judgment of investors and enables faster and more accurate trading.
In this course, we will cover how to develop an automated trading system using Python,
and introduce how to utilize PyQt and Qt Designer to build a user interface (UI).

1. Overview of Python Automated Trading System

Python is a very suitable language for developing automated trading systems.
It offers libraries that provide access to various financial data and strong algorithmic calculation capabilities.
Additionally, thanks to Python’s community and the wealth of resources available, you can find many examples and help.

1.1. Principles of Automated Trading

The basic principle of automated trading systems is to create algorithms that generate signals and
execute trades based on these signals.
Typically, signal generators are based on chart patterns, technical indicators, news analysis, and more.

1.2. Required Libraries

The following libraries are required to develop an automated trading system:

• pandas: Library for data processing
• numpy: Library for mathematical calculations
• matplotlib: Library for data visualization
• TA-Lib: Library for technical analysis
• ccxt: Library for data communication with various exchanges

2. Setting Up the Development Environment

Let’s explore how to set up the necessary environment for developing an automated trading system.

2.1. Installing Python and Libraries

First, you need to have Python installed. Download and install the latest version from the official Python website.

        
        pip install pandas numpy matplotlib ta-lib ccxt
        
    

2.2. Installing an IDE

It is recommended to use an integrated development environment (IDE) such as PyCharm, VSCode, or Jupyter Notebook for convenient coding.

3. Implementing Automated Trading Algorithms

In this section, we will implement a simple moving average crossover strategy.

3.1. Data Collection

We will look at how to collect real-time data from exchanges using the CCXT library.
For example, the code to fetch the Bitcoin price from Binance is as follows.

        
        import ccxt
        import pandas as pd

        # Creating a Binance instance
        binance = ccxt.binance()

        # Fetching Bitcoin data
        ohlcv = binance.fetch_ohlcv('BTC/USDT', timeframe='1d')
        df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
        print(df.head())
        
    

3.2. Calculating Moving Averages

Here’s how to calculate moving averages based on the collected data.

        
        # Calculating 50-day and 200-day moving averages
        df['MA50'] = df['close'].rolling(window=50).mean()
        df['MA200'] = df['close'].rolling(window=200).mean()

        # Generating signals
        df['signal'] = 0
        df.loc[df['MA50'] > df['MA200'], 'signal'] = 1
        df.loc[df['MA50'] < df['MA200'], 'signal'] = -1
        
    

3.3. Executing Trades

The code to execute trades based on signals is as follows.
Since real trades will take place, it should be used cautiously after thorough testing.

        
        # Trade execution function
        def execute_trade(signal):
            if signal == 1:
                print("Executing buy")
                # binance.create_market_buy_order('BTC/USDT', amount)
            elif signal == -1:
                print("Executing sell")
                # binance.create_market_sell_order('BTC/USDT', amount)

        # Executing trades based on the last signal
        last_signal = df.iloc[-1]['signal']
        execute_trade(last_signal)
        
    

4. Introduction to PyQt and Qt Designer

PyQt is a library that allows you to use the Qt framework in Python.
Qt Designer is a tool that helps you easily create GUI (Graphical User Interface).
It allows for the easy design of a visual interface, including fields for user input.

4.1. Installing PyQt

To install PyQt, enter the following command.

        
        pip install PyQt5
        
    

4.2. Installing Qt Designer

Qt Designer is part of PyQt and is installed along with it.
It can be used within the IDE and offers an intuitive visual tool for GUI design.

4.3. Creating a Basic GUI Structure

You can generate a UI file via Qt Designer and then convert it into Python code for use.
The following example shows how to create a basic window.

        
        from PyQt5.QtWidgets import QApplication, QMainWindow
        import sys

        class MyWindow(QMainWindow):
            def __init__(self):
                super(MyWindow, self).__init__()
                self.setWindowTitle("Automated Trading System")

        app = QApplication(sys.argv)
        window = MyWindow()
        window.show()
        sys.exit(app.exec_())
        
    

5. Integrating the Automated Trading System with the UI

Now let’s integrate the automated trading algorithm we created earlier with the GUI.
We will add functionality to execute trades when a button is clicked in the UI.

        
        from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QLabel
        import sys

        class MyWindow(QMainWindow):
            def __init__(self):
                super(MyWindow, self).__init__()
                self.setWindowTitle("Automated Trading System")

                self.label = QLabel("Status: Waiting", self)
                self.label.setGeometry(50, 50, 200, 50)

                self.btn_execute = QPushButton("Execute Trade", self)
                self.btn_execute.setGeometry(50, 100, 200, 50)
                self.btn_execute.clicked.connect(self.execute_trade)

            def execute_trade(self):
                # Execute the trading algorithm here.
                self.label.setText("Status: Executing Trade")

        app = QApplication(sys.argv)
        window = MyWindow()
        window.show()
        sys.exit(app.exec_())
        
    

6. Conclusion

Today we learned about developing an automated trading system using Python and designing a UI with PyQt and Qt Designer.
Leveraging an automated trading system allows for efficient trading, and PyQt makes it easy to design a user-friendly interface.
I encourage you to further explore various strategies and advanced features.

6.1. Additional Resources

• CCXT Documentation
• Pandas Documentation
• Matplotlib Documentation
• Qt for Python Documentation

6.2. Questions and Feedback

If you have any questions or feedback, please feel free to leave a comment. Thank you!

This course will explain how to develop an automated trading system using Python and how to easily create a GUI (Graphical User Interface) with PyQt and Qt Designer. Trading stocks involves complex and diverse algorithms, but the goal of this course is to build a basic automated trading system.

1. Overview of Automated Trading Systems

An automated trading system is a program that executes orders in the market automatically based on algorithms set by the user. Such systems can be applied to various financial products such as stocks, forex, and futures, maximizing trading efficiency by automating the generation of trading signals and order execution.

1.1 Advantages of Automated Trading

• Emotion Exclusion: Automated trading allows for objective trading decisions without being swayed by emotions.
• Time-Saving: Automating the decision-making and execution of trades saves time and effort.
• Consistency: The set algorithm can be continuously applied, maintaining consistency in trading strategies.
• High-Frequency Trading: Helps not to miss crucial opportunities in a rapidly changing market.

1.2 Disadvantages of Automated Trading

• System Failures: Trading issues may arise due to program errors or connection problems.
• Difficulties in Reflecting Market Changes: The algorithm may not respond appropriately to sudden market changes.
• Dependence on Historical Data: There is no guarantee that strategies based on past data will remain valid in the future.

2. Setting Up the Development Environment

Building an environment to develop an automated trading system is very important. Install the necessary tools according to the following steps.

2.1 Installing Python

First, install Python. You can download it from the official Python website.

2.2 Installing Required Libraries

Let’s install the libraries needed to develop the automated trading system. The main libraries are as follows:

pip install numpy pandas matplotlib requests PyQt5

3. Installing PyQt and Qt Designer

PyQt provides a way to use the Qt library with Python. Qt is a tool for developing powerful GUI applications.

3.1 Installing Qt Designer

Qt Designer is a graphical tool that allows you to design GUIs. It can be downloaded for free from the official Qt website. After installation, you can use Qt Designer to create UI files in XML format.

3.2 Installing PyQt5

PyQt5 can be installed as follows:

pip install PyQt5

4. Setting Up Project Structure

Now let’s set up the project structure. The recommended project structure is as follows:

    auto_trader/
    ├── main.py               # Main execution file
    ├── trader.py             # Automated trading logic
    ├── ui/                   # UI-related files
    │   └── main_window.ui     # UI file generated by Qt Designer
    └── requirements.txt      # List of required libraries
    

5. UI Design

Use Qt Designer to design a basic UI. Below are example UI components:

• Stock selection dropdown
• Buy button
• Sell button
• Current price display label
• Trade history display table

Design the UI in Qt Designer in the following form and save it as main_window.ui.

6. Implementing Automated Trading Logic

To implement the automated trading logic, write the trader.py file. Below is an example code for basic trading logic.

    import requests

    class Trader:
        def __init__(self):
            self.api_url = "https://api.example.com/trade"
            self.symbol = "AAPL"  # Stock to trade
            self.balance = 10000  # Initial balance

        def buy(self, amount):
            # Buy logic
            response = requests.post(self.api_url, data={'symbol': self.symbol, 'action': 'buy', 'amount': amount})
            return response.json()

        def sell(self, amount):
            # Sell logic
            response = requests.post(self.api_url, data={'symbol': self.symbol, 'action': 'sell', 'amount': amount})
            return response.json()
    

7. Writing the Main Execution File

Now let’s write the main execution file, main.py. This file will call the GUI and handle user interactions.

    import sys
    from PyQt5.QtWidgets import QApplication, QMainWindow
    from ui.main_window import Ui_MainWindow
    from trader import Trader

    class MainApp(QMainWindow, Ui_MainWindow):
        def __init__(self):
            super().__init__()
            self.setupUi(self)
            self.trader = Trader()

            self.buy_button.clicked.connect(self.buy_stock)
            self.sell_button.clicked.connect(self.sell_stock)

        def buy_stock(self):
            amount = int(self.amount_input.text())
            response = self.trader.buy(amount)
            self.update_ui(response)

        def sell_stock(self):
            amount = int(self.amount_input.text())
            response = self.trader.sell(amount)
            self.update_ui(response)

        def update_ui(self, response):
            # UI update logic
            print(response)

    if __name__ == '__main__':
        app = QApplication(sys.argv)
        window = MainApp()
        window.show()
        sys.exit(app.exec_())
    

8. Execution and Testing

Once all the code is ready, type python main.py in the terminal to run the program. When the GUI opens, you can select stocks and click the buy or sell button to execute orders.

9. Conclusion

In this course, we explained the process of developing an automated trading system using Python and how to create a GUI using PyQt. In the real market, various variables and conditions exist, so applying more complex algorithms and data analysis techniques can help create a more sophisticated system.

9.1 Additional Learning Resources

• Official Python Documentation
• PyQt5 Download Page
• Official Qt Documentation
• Practice data analysis on Kaggle

We hope your automated trading system operates successfully!

Python is gaining great popularity in data science and financial analysis. In particular, Python’s powerful libraries are becoming useful tools for many traders in developing automated trading systems. In this course, we will learn how to build a GUI using PyQt and visualize trading data using Matplotlib.

1. Overview of Automated Trading Systems

An automated trading system is a system that automatically executes trades according to predefined algorithms. These systems generate trading signals, make buy and sell decisions at appropriate times, and manage portfolios.

The main components of an automated trading system are as follows:

• Market data collection
• Signal generation
• Order execution
• Portfolio management

2. Installing PyQt and Matplotlib

To use PyQt and Matplotlib, you first need to install them. You can install the required packages using the command below:

            pip install PyQt5 matplotlib
        

3. Creating a GUI with PyQt

PyQt is a framework for creating GUI applications in Python. We will create a basic GUI for the automated trading system using PyQt5.

3.1 Basic GUI Structure

We will create a basic application window and add a text field and a button to receive input from the user.

Example Code:

        import sys
        from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout, QLabel, QLineEdit

        class AutoTraderApp(QWidget):
            def __init__(self):
                super().__init__()
                self.initUI()

            def initUI(self):
                self.setWindowTitle('Automated Trading System')
                layout = QVBoxLayout()

                self.label = QLabel('Enter Stock Code:')
                layout.addWidget(self.label)

                self.stock_input = QLineEdit(self)
                layout.addWidget(self.stock_input)

                self.submit_btn = QPushButton('Submit', self)
                self.submit_btn.clicked.connect(self.onSubmit)
                layout.addWidget(self.submit_btn)

                self.setLayout(layout)

            def onSubmit(self):
                stock_code = self.stock_input.text()
                print(f'Entered Stock Code: {stock_code}')

        if __name__ == '__main__':
            app = QApplication(sys.argv)
            ex = AutoTraderApp()
            ex.show()
            sys.exit(app.exec_())
    

4. Data Visualization with Matplotlib

Matplotlib is a widely used library for visualizing data in Python. It can be used to show the volatility of stock prices in graphs or visually represent the performance of automated trading algorithms.

4.1 Basics of Plotting

Let’s create a simple line graph using Matplotlib. We will generate stock data and display it in a graph.

Example Code:

        import matplotlib.pyplot as plt
        import numpy as np

        # Generate time (dates)
        days = np.arange(1, 31)  # From 1 to 30

        # Generate random stock prices
        prices = np.random.rand(30) * 100  # Prices between 0 and 100

        # Plotting the graph
        plt.plot(days, prices, marker='o')
        plt.title('Stock Price Changes')
        plt.xlabel('Date')
        plt.ylabel('Stock Price')
        plt.grid()
        plt.show()
    

5. Integrating PyQt and Matplotlib

Now let’s integrate Matplotlib graphs into the PyQt GUI. We will add functionality to display a graph for the stock code entered by the user.

Example Code:

        import sys
        from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout, QLabel, QLineEdit
        from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
        from matplotlib.figure import Figure
        import numpy as np

        class PlotCanvas(FigureCanvas):
            def __init__(self, parent=None):
                fig = Figure()
                self.axes = fig.add_subplot(111)
                super().__init__(fig)

            def plot(self, stock_code):
                days = np.arange(1, 31)
                prices = np.random.rand(30) * 100  # Random price data
                self.axes.clear()
                self.axes.plot(days, prices, marker='o', label=stock_code)
                self.axes.set_title(f'{stock_code} Stock Price Changes')
                self.axes.set_xlabel('Date')
                self.axes.set_ylabel('Stock Price')
                self.axes.grid()
                self.axes.legend()
                self.draw()

        class AutoTraderApp(QWidget):
            def __init__(self):
                super().__init__()
                self.initUI()

            def initUI(self):
                self.setWindowTitle('Automated Trading System')
                layout = QVBoxLayout()

                self.label = QLabel('Enter Stock Code:')
                layout.addWidget(self.label)

                self.stock_input = QLineEdit(self)
                layout.addWidget(self.stock_input)

                self.submit_btn = QPushButton('Submit', self)
                self.submit_btn.clicked.connect(self.onSubmit)
                layout.addWidget(self.submit_btn)

                self.plot_canvas = PlotCanvas(self)
                layout.addWidget(self.plot_canvas)

                self.setLayout(layout)

            def onSubmit(self):
                stock_code = self.stock_input.text()
                self.plot_canvas.plot(stock_code)

        if __name__ == '__main__':
            app = QApplication(sys.argv)
            ex = AutoTraderApp()
            ex.show()
            sys.exit(app.exec_())
    

6. Conclusion

In this course, we learned how to build a GUI for an automated trading system using PyQt and visualize stock price change graphs using Matplotlib. By combining GUI and data visualization, we can improve user experience and intuitively understand the performance of automated trading algorithms. Utilizing these techniques will allow us to develop a more efficient automated trading system.

Thank you!

Automated trading is an increasingly popular field among financial investors. With the advancement of artificial intelligence and machine learning, there are more opportunities to automate trading systems to enhance efficiency and profitability. In this course, you will learn how to develop a basic automated trading system using Python, design a user interface (UI) with PyQt, and implement data visualization using Matplotlib.

Table of Contents

• 1. Understanding Automated Trading
• 2. Setting Up the Development Environment
• 3. Building UI with PyQt
• 4. Visualizing Data with Matplotlib
• 5. Implementing Automated Trading Algorithms
• 6. Comprehensive Example
• 7. Conclusion

1. Understanding Automated Trading

An automated trading system is a program that automatically executes trades based on pre-defined trading strategies. These systems make trading decisions based on various market data such as price fluctuations, trading volume, and technical indicators. The biggest advantage of automated trading is that it allows for objective trading, free from emotions. However, it is crucial to establish the correct strategies, as poor algorithms or data analysis can lead to significant losses.

2. Setting Up the Development Environment

To develop an automated trading system, you need to install the following libraries:

pip install PyQt5 matplotlib pandas numpy

You can install PyQt5, Matplotlib, Pandas, and NumPy with the command above. PyQt5 is a powerful library for creating GUI applications, Matplotlib is useful for visualizing data, and NumPy and Pandas are essential libraries for data processing.

3. Building UI with PyQt

Let’s learn how to build the user interface using PyQt. Below is an example code for a simple UI setup:

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton, QLabel

class MyApp(QWidget):
    def __init__(self):
        super().__init__()
        
        self.initUI()

    def initUI(self):
        self.setWindowTitle('Automated Trading System')
        
        layout = QVBoxLayout()
        
        self.label = QLabel('Welcome to Automated Trading System', self)
        layout.addWidget(self.label)

        self.startButton = QPushButton('Start Trading', self)
        self.startButton.clicked.connect(self.startTrading)
        layout.addWidget(self.startButton)

        self.setLayout(layout)
        self.show()

    def startTrading(self):
        self.label.setText('Trading Started!')

if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = MyApp()
    sys.exit(app.exec_())

The above code creates a simple window using PyQt5. When the user clicks the “Start Trading” button, the text of the label changes.

4. Visualizing Data with Matplotlib

You can visualize trading data using Matplotlib. Below is a simple data visualization example:

import matplotlib.pyplot as plt
import numpy as np

# Generate dummy data
x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.title('Sine Wave')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.grid(True)
plt.show()

The above code generates a simple graph by plotting the sin(x) function. This generated graph can be integrated into the UI.

5. Implementing Automated Trading Algorithms

Now we will define a basic automated trading algorithm that we will implement. Here, we will use a moving average crossover strategy to identify trading signals. The simple strategy is as follows:

• Generate a buy signal when the short-term moving average crosses above the long-term moving average.
• Generate a sell signal when the short-term moving average crosses below the long-term moving average.

import pandas as pd

def moving_average_crossover(data, short_window=40, long_window=100):
    """Function to generate buy and sell signals"""
    signals = pd.DataFrame(index=data.index)
    signals['signal'] = 0.0

    # Short-term and long-term moving averages
    signals['short_mavg'] = data['Close'].rolling(window=short_window, min_periods=1).mean()
    signals['long_mavg'] = data['Close'].rolling(window=long_window, min_periods=1).mean()

    # Buy signal
    signals['signal'][short_window:] = np.where(signals['short_mavg'][short_window:] 
                                                > signals['long_mavg'][short_window:], 1.0, 0.0)   

    # Sell signal
    signals['positions'] = signals['signal'].diff()

    return signals

The code above calculates moving averages from stock price data and generates buy and sell signals. This allows testing of the strategy and its application to real trades.

6. Comprehensive Example

Let’s look at a comprehensive example that integrates all elements of the automated trading system.

from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton, QLabel
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

class TradingSystem(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()
        self.data = None  # Variable to store trading data

    def initUI(self):
        self.setWindowTitle('Automated Trading System')
        
        layout = QVBoxLayout()
        
        self.label = QLabel('Welcome to Automated Trading System', self)
        layout.addWidget(self.label)

        self.startButton = QPushButton('Start Trading', self)
        self.startButton.clicked.connect(self.startTrading)
        layout.addWidget(self.startButton)

        self.setLayout(layout)
        self.show()

    def startTrading(self):
        self.label.setText('Fetching market data...')
        self.fetchMarketData()
        self.label.setText('Data fetched. Analyzing...')
        signals = self.analyzeData(self.data)  # Analyze data

        self.label.setText('Trading Strategy executed.')
        self.visualizeData(signals)  # Data visualization

    def fetchMarketData(self):
        # Generate dummy trading data
        dates = pd.date_range(start='2023-01-01', periods=200)
        prices = np.random.normal(loc=100, scale=10, size=(200,)).cumsum()
        self.data = pd.DataFrame(data={'Close': prices}, index=dates)

    def analyzeData(self, data):
        return moving_average_crossover(data)

    def visualizeData(self, signals):
        plt.figure(figsize=(10, 6))
        plt.plot(self.data.index, self.data['Close'], label='Close Price')
        plt.plot(signals['short_mavg'], label='Short Moving Average', alpha=0.7)
        plt.plot(signals['long_mavg'], label='Long Moving Average', alpha=0.7)
        
        plt.title('Stock Price and Moving Averages')
        plt.xlabel('Date')
        plt.ylabel('Price')
        plt.legend()
        plt.show()

def moving_average_crossover(data, short_window=40, long_window=100):
    signals = pd.DataFrame(index=data.index)
    signals['signal'] = 0.0

    signals['short_mavg'] = data['Close'].rolling(window=short_window, min_periods=1).mean()
    signals['long_mavg'] = data['Close'].rolling(window=long_window, min_periods=1).mean()
    signals['signal'][short_window:] = np.where(signals['short_mavg'][short_window:] 
                                                > signals['long_mavg'][short_window:], 1.0, 0.0)   
    signals['positions'] = signals['signal'].diff()

    return signals

if __name__ == '__main__':
    app = QApplication(sys.argv)
    trading_system = TradingSystem()
    sys.exit(app.exec_())

The above code creates a complete automated trading system that includes functions for fetching data, analysis, and visualization within the PyQt interface. When the “Start Trading” button is clicked, it fetches and analyzes market data and visualizes the results.

7. Conclusion

This course introduced the process of developing a simple automated trading system using PyQt and Matplotlib. By controlling the trading system through the user interface and implementing data visualization using Matplotlib, we created a basic automated trading system with essential features. Based on this code and principles, we encourage you to add more complex trading algorithms and functionalities to develop your own automated trading system.

Now, to further enhance your automated trading system, try applying data analysis, machine learning, and various strategies for practical use. The world of automated trading offers broad and diverse possibilities. The key to success lies in continuous learning and practice with passion.

Please leave any questions in the comments!

Automated trading means a system that performs trades automatically in financial markets. Python is widely used for developing automated trading systems due to its powerful libraries and simple syntax. This course will explain in detail how to build a GUI (Graphical User Interface) using the PyQt library, starting from the basics of automated trading development with Python, to enable users to handle the interface more easily.

        import pandas as pd
        import numpy as np

        class MovingAverageCrossStrategy:
            def __init__(self, short_window=40, long_window=100):
                self.short_window = short_window
                self.long_window = long_window

            def generate_signals(self, data):
                signals = pd.DataFrame(index=data.index)
                signals['price'] = data['Close']
                signals['short_mavg'] = data['Close'].rolling(window=self.short_window, min_periods=1).mean()
                signals['long_mavg'] = data['Close'].rolling(window=self.long_window, min_periods=1).mean()
                signals['signal'] = 0.0
                signals['signal'][self.short_window:] = np.where(signals['short_mavg'][self.short_window:] 
                                                   > signals['long_mavg'][self.short_window:], 1.0, 0.0)   
                signals['positions'] = signals['signal'].diff()

                return signals
        

        import sys
        from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QLabel, QVBoxLayout, QWidget

        class TradingApp(QMainWindow):
            def __init__(self):
                super().__init__()
                self.setWindowTitle('Automated Trading System')
                self.setGeometry(100, 100, 600, 400)

                # Setting up the basic layout
                self.layout = QVBoxLayout()
                self.label = QLabel('Welcome to the Automated Trading System!')
                self.start_button = QPushButton('Start Trading')

                # Connecting event on button click
                self.start_button.clicked.connect(self.start_trading)

                self.layout.addWidget(self.label)
                self.layout.addWidget(self.start_button)

                container = QWidget()
                container.setLayout(self.layout)
                self.setCentralWidget(container)

            def start_trading(self):
                print('Trading started')

        if __name__ == '__main__':
            app = QApplication(sys.argv)
            window = TradingApp()
            window.show()
            sys.exit(app.exec_())
        

        import yfinance as yf

        def get_data(stock_symbol, start_date, end_date):
            data = yf.download(stock_symbol, start=start_date, end=end_date)
            return data
        

        import matplotlib.pyplot as plt

        def plot_data(signals):
            plt.figure(figsize=(12,8))
            plt.plot(signals['price'], label='Price')
            plt.plot(signals['short_mavg'], label='Short Moving Average', linestyle='--', color='orange')
            plt.plot(signals['long_mavg'], label='Long Moving Average', linestyle='--', color='red')
            plt.title('Price and Moving Averages')
            plt.legend()
            plt.show()
        

        class TradingApp(QMainWindow):
            # ... previous code omitted ...

            def start_trading(self):
                stock_symbol = 'AAPL'
                data = get_data(stock_symbol, '2020-01-01', '2022-01-01')
                strategy = MovingAverageCrossStrategy()
                signals = strategy.generate_signals(data)
                plot_data(signals)