Automatic Trading Development with Python, Converting UI Files Utilizing PyQt to Python Code

Python is one of the programming languages widely used in the financial sector. It is particularly utilized in the development of automated trading systems. Today, I will explain in detail how to convert a user interface (UI) file developed using PyQt into Python code. Through this process, you will be able to acquire the basic skills necessary for creating GUI applications.

1. What is PyQt?

PyQt is a binding for developing Qt applications in Python. Qt is a cross-platform GUI toolkit that allows you to create applications that can run on various operating systems. PyQt provides a robust framework for desktop application development, making it easier for developers to create graphical user interfaces.

1.1 Features of PyQt

  • Cross-platform: Supports Windows, macOS, and Linux.
  • Diverse Widgets: Offers a variety of UI widgets for easily constructing complex UIs.
  • Rapid Development: Enhances development speed through tools that allow you to design UIs and convert them to code.

2. Creating UI Files Using PyQt

First, let’s create a simple UI with PyQt. By using a tool called Qt Designer, we can visually construct the UI and then convert the generated UI file into Python code.

2.1 Installing Qt Designer

Qt Designer is a UI design tool included in the Qt framework and can be used once installed. After installation is complete, open Qt Designer to create a new UI file.

2.2 Designing a Simple UI

Let’s design a simple UI in Qt Designer with the following components.

  • QLineEdit: A text box for user input
  • QPushButton: A button to execute automated trading
  • QTextEdit: A text area for log output

After designing this UI, save it with the name example.ui.

2.3 Converting UI Files to Python Code

To convert the saved UI file into Python code, use the command pyuic5. This command is a tool provided by PyQt that converts .ui files to .py files. Execute the following command in the terminal:

pyuic5 -x example.ui -o example.py

When you run this command, a Python file named example.py will be created. This file contains code based on the UI designed in Qt Designer.

3. Utilizing the Generated Python Code

Now we will use the converted Python file to create a real GUI application. Below is a simple example code for the example.py file:

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow
from example import Ui_MainWindow  # Importing the automatically generated UI code

class MainWindow(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super().__init__()
        self.setupUi(self)  # UI initialization

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

    def start_trading(self):
        input_text = self.lineEdit.text()
        self.textEdit.append(f'Automated trading started: {input_text}')  # Adding to log

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

3.1 Code Explanation

This code has a very simple structure. It inherits from QMainWindow to set up the UI and calls the start_trading method upon button click. Here, it reads the value entered by the user in the QLineEdit and outputs the corresponding content in QTextEdit.

4. Integrating Automated Trading Logic

Now that the basic UI is ready, let’s integrate the actual automated trading logic. The example below adds a simple stock trading logic which generates random virtual trading results.

import random

class MainWindow(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        self.pushButton.clicked.connect(self.start_trading)

    def start_trading(self):
        input_text = self.lineEdit.text()
        self.textEdit.append(f'Automated trading started: {input_text}')
        result = self.simulate_trading(input_text)
        self.textEdit.append(result)

    def simulate_trading(self, stock):
        # Randomly generating virtual trading results
        if random.choice([True, False]):
            return f'{stock} Purchase successful!'
        else:
            return f'{stock} Sale successful!'

The above code randomly outputs a purchase or sale successful message for the stock entered by the user. To actually trade stocks through an API, you can utilize the trading platform’s API.

5. API Integration and Practical Application

To build a real automated trading system, it is necessary to integrate a stock trading API. For instance, leading online brokerages in Korea provide OpenAPI to allow users to automate stock trading.

5.1 Using APIs

Many exchanges provide APIs that allow for real-time data collection and trade orders. Later, you can create a more complex journey by integrating this UI with APIs.

Example: Trading API Integration

import requests

def execute_trade(stock, action):
    url = 'https://api.broker.com/trade'  # Example URL
    data = {
        'stock': stock,
        'action': action
    }
    response = requests.post(url, json=data)
    return response.json()

The above execute_trade function is an example of sending a POST request for stock trading. The actual API may require authentication information and additional parameters.

Conclusion

In this lecture, we explored how to design a GUI using PyQt and convert it into Python code, and we briefly implemented automated trading logic. I hope this process has provided you with foundational experience in creating GUI applications. Finally, I also introduced how to implement actual trading using APIs. Building on this, I hope you can further develop your automated trading system.

References