Category: Python Auto Trading

The automated trading system is a program that mechanically executes trades in financial markets, allowing for quick trading according to algorithms while excluding emotions. In this article, we will explore in detail the development process of automated trading using Python, focusing on UI (User Interface) configuration utilizing PyQt and Qt Designer. This article will cover the entire process from the basic concepts of automated trading systems, to PyQt installation, UI design, data visualization, and the construction of the automated trading system.

1. Understanding the Automated Trading System

An automated trading system is software that automatically executes buy or sell orders when certain conditions are met. It analyzes market data using algorithmic trading algorithms and executes buy or sell orders when signals occur. Here are the main components of automated trading:

• Data Collection: A system that collects and analyzes real-time market data.
• Trading Algorithm: Rules and models that make trading decisions based on market data.
• State Management: Tracks current positions and manages exit conditions.
• User Interface: Visual elements that allow users to interact with the trading system.

2. Introduction to PyQt and Qt Designer

PyQt is a binding that allows the use of the Qt framework in Python. Qt is a powerful GUI framework written in C++ that enables the development of applications that can run on various platforms. Using PyQt, you can easily create GUIs with Python code, and by utilizing Qt Designer, you can graphically design the GUI layout.

2.1 Installing PyQt

PyQt5 can be installed via pip. Use the following command to install PyQt5:

pip install PyQt5

2.2 Installing Qt Designer

Qt Designer is provided as part of Qt and is automatically included when you install Qt Creator. Here’s how to install Qt Creator:

• Visit the official Qt website and download the Qt Installer.
• Follow the installation process and select the necessary components.

Once the installation is complete, you can run Qt Designer to design the UI.

3. UI Design

UI design is the process of creating visual elements through which users interact with the program. You can build an intuitive UI using Qt Designer. Here, we will explain how to create a basic UI for the automated trading system.

3.1 Creating a New Form in Qt Designer

After launching Qt Designer, create a new form and select ‘Main Window’. Add various elements to this form to configure the UI.

3.2 Key UI Components

The following are the basic UI components needed in the automated trading program:

• Start/Stop Button: Controls the execution of the trading system.
• Log Area: Displays trading records and system logs.
• Price Chart: Visually represents real-time price changes.
• Strategy Settings Area: Allows users to input trading strategies.

4. UI Component Example

The example code below shows how to implement the UI generated by Qt Designer using PyQt5. This code demonstrates how to set up a basic UI for the trading system.

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QTextEdit, QVBoxLayout, QWidget, QLabel
import matplotlib.pyplot as plt
import numpy as np

class AutoTradingApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Automated Trading System")
        self.setGeometry(100, 100, 800, 600)

        self.initUI()

    def initUI(self):
        layout = QVBoxLayout()

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

        self.stopButton = QPushButton('Stop', self)
        self.stopButton.clicked.connect(self.stopTrading)
        layout.addWidget(self.stopButton)

        self.logArea = QTextEdit(self)
        layout.addWidget(self.logArea)

        self.priceChart = QLabel("Price Chart", self)
        layout.addWidget(self.priceChart)

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

    def startTrading(self):
        self.logArea.append("Trading system started")

    def stopTrading(self):
        self.logArea.append("Trading system stopped")

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

5. Data Visualization

Visualizing price change data in the automated trading system is very important. This allows users to easily understand how the system operates in the market. You can create real-time price charts using the matplotlib library.

5.1 Installing matplotlib

matplotlib can be installed using the following command:

pip install matplotlib

5.2 Updating the Price Chart

Here’s how to update the price chart in real-time within the automated trading system:

def updateChart(self, prices):
    plt.clf()  # Clear existing graph
    plt.plot(prices)
    plt.title("Real-time Price Chart")
    plt.xlabel("Time")
    plt.ylabel("Price")
    plt.pause(0.01)  # Wait for graph update

6. Implementing the Automated Trading Logic

The core of the automated trading system is the algorithm that generates trading signals. The trading algorithm analyzes market data to generate buy or sell signals.

6.1 Basic Structure of the Trading Algorithm

The basic structure of the trading algorithm is as follows:

def tradingAlgorithm(self, market_data):
    if market_data['signal'] == 'buy':
        self.logArea.append("Executing buy order.")
    elif market_data['signal'] == 'sell':
        self.logArea.append("Executing sell order.")

7. Conclusion

In this article, we covered how to configure a simple UI for an automated trading system using PyQt and Qt Designer. We explained the basic UI components, data visualization, and how to implement the trading algorithm. Through this process, you will be able to build a more advanced automated trading system. Based on this example, feel free to add your own trading strategies and incorporate advanced data analysis techniques to implement the optimal trading system!

Additionally, we encourage you to expand the program by adding your own trading algorithms, user settings save functionality, and more diverse visualization options. Best wishes for building a successful automated trading system!

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)