PySide6Plot 0.0.1__py3-none-any.whl

PySide6Plot/__init__.py

@@ -0,0 +1,187 @@
+from PySide6.QtGui import QResizeEvent
+from PySide6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout
+from PySide6.QtWidgets import QGridLayout, QSizePolicy
+from qfluentwidgets import TransparentToggleToolButton, FluentIcon
+from .widgets.q_plot_widget import QPlotWidget
+from .widgets.navigation_widget import SegmentedInterface
+from .compoents.zoom_move import (
+    StockWidgetZoomBar,
+    StockWidgetHorizontalScroller,
+    StockWidgetVerticalScroller,
+)
+from .compoents.draw_line import DrawLineComponent
+from .compoents.frame_recorder import FrameRecorderComponent
+from .compoents.average_line import AverageLineComponent
+from .libs.plot_item import get_plot_item, AdaptiveGraphObject
+from .libs.style import QStockIcon, set_background_with_theme, qconfig
+from .libs.data_handler import PricesDataFrame, VolumeDataFrame, TradeData
+
+
+class QStockPlotter(QWidget):
+    def __init__(self, show_zoom_bar=True, parent=None) -> None:
+        super().__init__(parent)
+
+        self.main_item: AdaptiveGraphObject | None = None
+
+        self.setMinimumSize(450, 200)
+        self.main_plotter = QPlotWidget(self)
+
+        self.y_scroller = StockWidgetVerticalScroller(self.main_plotter, parent=self)
+        self.x_scroller = StockWidgetHorizontalScroller(self.main_plotter, parent=self)
+        if show_zoom_bar:
+            self.zoom_bar = StockWidgetZoomBar(self.main_plotter, parent=self)
+
+        self.draw_line_component = DrawLineComponent(self.main_plotter, parent=self)
+        self.draw_line_command_bar, self.draw_line_table = self.draw_line_component.get_widget()
+        self.draw_line_table.show()
+
+        self.frame_recorder_component = FrameRecorderComponent(self.main_plotter, parent=self)
+        self.saved_frame_table = self.frame_recorder_component.get_widget()
+        self.saved_frame_table.show()
+
+        self.average_line_component = AverageLineComponent(self.main_plotter, parent=self)
+        self.average_line_command_bar = self.average_line_component.get_widget()
+
+        # self.navigation_widget = PivotInterface(parent=self)
+        self.navigation_widget = SegmentedInterface(parent=self)
+        self.navigation_widget.addSubInterface(self.draw_line_table, "saved_line_table", "Lines")
+        self.navigation_widget.addSubInterface(self.saved_frame_table, "saved_frame_table", "Frames")
+        self.navigation_widget.hide()
+        self.show_up_button = TransparentToggleToolButton(QStockIcon.CHEVRON_LEFT)
+        self.show_up_button.setFixedWidth(10)
+        self.show_up_button.clicked.connect(self.__on_show_up_button_clicked)
+
+        self.main_plotter.insert_context_menu(self.frame_recorder_component.jump_to_menu)
+        self.main_plotter.insert_context_menu(self.frame_recorder_component.record_current_frame_action)
+        self.main_plotter.insert_context_menu(self.draw_line_component.menu_action)
+
+        self.main_layout = QHBoxLayout(self)
+        self.main_layout.setContentsMargins(0, 0, 0, 0)
+        self.main_layout.setSpacing(0)
+        self.setLayout(self.main_layout)
+        self.inner_layout = QVBoxLayout()
+        self.inner_layout.setContentsMargins(0, 0, 0, 0)
+        self.inner_layout.setSpacing(0)
+        self.plotter_grid_layout = QGridLayout()
+        self.plotter_grid_layout.setContentsMargins(0, 0, 0, 0)
+        self.plotter_grid_layout.setSpacing(0)
+
+        self.main_layout.addLayout(self.inner_layout)
+        self.main_layout.addWidget(self.show_up_button)
+        self.main_layout.addWidget(self.navigation_widget)
+        self.inner_layout.addWidget(self.draw_line_command_bar)
+        self.inner_layout.addLayout(self.plotter_grid_layout)
+        self.inner_layout.addWidget(self.average_line_command_bar)
+        self.plotter_grid_layout.addWidget(self.main_plotter, 0, 0, 1, 1)
+        self.plotter_grid_layout.addWidget(self.y_scroller, 0, 1, 1, 1)
+        self.plotter_grid_layout.addWidget(self.x_scroller, 1, 0, 1, 2)
+
+        for m in [
+            "update_plot",
+            "move_y_loc",
+            "set_zoom_model",
+            "set_y_loc_model",
+            "set_full_range_enabled",
+            "set_x_range",
+            "move_to_end",
+            "move_to_start",
+            "full_range",
+        ]:
+            setattr(self, m, getattr(self.main_plotter, m))
+
+        set_background_with_theme(self)
+
+        qconfig.themeChanged.connect(lambda theme: set_background_with_theme(self, theme))
+
+    def add_main_item(self, plot_item, x_ticks=None, y_ticks=None):
+        if self.main_item is not None:
+            raise Exception("Main item already exists. There can only be one main item.")
+        self.main_item = plot_item
+        self.main_plotter.add_item(plot_item, x_ticks, y_ticks)
+        # self.average_line_component.add_default_average_lines()
+
+    def remove_main_item(self):
+        if self.main_item is None:
+            raise Exception("No main item exists.")
+        self.main_plotter.remove_item(self.main_item)
+        self.main_item = None
+
+    def __on_show_up_button_clicked(self):
+        if self.navigation_widget.isHidden():
+            self.navigation_widget.show()
+            self.show_up_button.setIcon(FluentIcon.CHEVRON_RIGHT)
+        else:
+            self.navigation_widget.hide()
+            self.show_up_button.setIcon(QStockIcon.CHEVRON_LEFT)
+
+    def resizeEvent(self, a0: QResizeEvent) -> None:
+        self.navigation_widget.setFixedWidth(min(int(self.width() * 0.3), 350))
+        return super().resizeEvent(a0)
+
+    def update_plot(self, x_loc: float | None = None, x_range: float | None = None):
+        self.main_plotter.update_plot(x_loc, x_range)
+
+
+class PriceVolumePlotter(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.main_layout = QVBoxLayout(self)
+        self.main_layout.setContentsMargins(8, 8, 8, 8)
+        self.main_layout.setSpacing(8)
+        self.setLayout(self.main_layout)
+
+        self.price_plotter = QStockPlotter(show_zoom_bar=True)
+        self.volume_plotter = QStockPlotter(show_zoom_bar=True)
+
+        self.price_plotter.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        self.volume_plotter.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        self.main_layout.addWidget(self.price_plotter, stretch=3)
+        self.main_layout.addWidget(self.volume_plotter, stretch=1)
+
+        self.price_plotter.main_plotter.sigViewChanged.connect(
+            lambda: self.__on_view_changed(self.price_plotter.main_plotter)
+        )
+        self.volume_plotter.main_plotter.sigViewChanged.connect(
+            lambda: self.__on_view_changed(self.volume_plotter.main_plotter)
+        )
+
+        set_background_with_theme(self)
+
+        qconfig.themeChanged.connect(lambda theme: set_background_with_theme(self, theme))
+
+    def __on_view_changed(self, active_plot_widget):
+        if active_plot_widget == self.price_plotter.main_plotter:
+            self.volume_plotter.update_plot(
+                x_loc=active_plot_widget.viewRect().left(),
+                x_range=active_plot_widget.viewRect().width(),
+            )
+        else:
+            self.price_plotter.update_plot(
+                x_loc=active_plot_widget.viewRect().left(),
+                x_range=active_plot_widget.viewRect().width(),
+            )
+
+    def plot_price_volume(self, price_data: PricesDataFrame, volume_data: VolumeDataFrame):
+        price_item = get_plot_item(price_data)
+        self.price_plotter.add_main_item(price_item, x_ticks=price_item.get_x_ticks())
+        volume_item = get_plot_item(volume_data)
+        self.volume_plotter.add_main_item(volume_item, x_ticks=volume_item.get_x_ticks())
+
+    def plot_trade_data(self, trade_data: TradeData):
+        self.plot_price_volume(trade_data.prices, trade_data.volume)
+
+    def update_plot(self, x_loc: float | None = None, x_range: float | None = None):
+        self.price_plotter.update_plot(x_loc, x_range)
+
+    def set_x_range(self, x_loc: float | None = None, x_range: float | None = None):
+        self.price_plotter.set_x_range(x_loc, x_range)
+        self.volume_plotter.set_x_range(x_loc, x_range)
+
+    def move_to_end(self):
+        self.price_plotter.move_to_end()
+
+    def move_to_start(self):
+        self.price_plotter.move_to_start()
+
+    def full_range(self):
+        self.price_plotter.full_range()

PySide6Plot/compoents/__init__.py

@@ -0,0 +1,3 @@
+"""
+Functional components for plotters.
+"""

PySide6Plot/compoents/average_line.py

@@ -0,0 +1,232 @@
+import numpy as np
+from PySide6.QtGui import QContextMenuEvent, QColor, QIcon
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import QWidget
+from qfluentwidgets import CommandBar, FluentIcon, Action, FluentIconBase, qconfig, RoundMenu
+from qfluentwidgets.common.overload import singledispatchmethod
+import pyqtgraph as pg
+from pyqtgraph import PlotCurveItem
+from ..widgets.q_plot_widget import QPlotWidget
+from ..widgets.colorful_toggle_button import ColorfulToggleButton
+from ..widgets.value_select_box import NewAverageLineBox
+
+
+class AverageLineItem(PlotCurveItem):
+    """
+    A class representing an average line item on a plot.
+
+    Attributes:
+        num_average_data (int): The number of data points to use for calculating the average.
+    """
+
+    def __init__(self, data, num_average_data: int, color: QColor, line_width: float):
+        """
+        Initializes an AverageLineItem object.
+
+        Args:
+            data (array-like): The data points for which the average line is calculated.
+            num_average_data (int): The number of data points to use for calculating the average.
+            color (str): The color of the average line.
+            line_width (float): The width of the average line.
+        """
+        super().__init__(
+            pen=pg.mkPen(color, width=line_width),
+            clickable=False,
+            x=np.arange(num_average_data - 1, len(data)),
+            y=np.asarray([np.mean(data[i : i + num_average_data]) for i in range(len(data) - num_average_data + 1)]),
+        )
+        self.num_average_data = num_average_data
+
+    def get_local_plot_range(self, start: float, end: float):
+        """
+        Returns the minimum and maximum values of the average line within the specified range.
+
+        Args:
+            start (float): The start value of the range.
+            end (float): The end value of the range.
+
+        Returns:
+            tuple: A tuple containing the minimum and maximum values of the average line within the range.
+                   If there are no data points within the range, returns None.
+        """
+        _, ys = self.getData()
+        ys = ys[max(0, int(start - self.num_average_data)) : max(0, int(end - self.num_average_data))]
+        if len(ys) > 0:
+            return np.min(ys), np.max(ys)
+        else:
+            return None
+
+
+class AverageLineButton(ColorfulToggleButton):
+    """
+    A button widget that represents an average line.
+
+    This button provides functionality for removing the average line and displays a context menu when right-clicked.
+
+    Signals:
+        - sigRemoveClicked: Emitted when the remove action is triggered.
+
+    Args:
+        parent (QWidget): The parent widget.
+
+    Overloaded Methods:
+        - __init__(self, parent: QWidget = None)
+        - __init__(self, color: QColor, text: str, parent: QWidget = None, icon: Union[QIcon, FluentIconBase, str] = None)
+        - __init__(self, icon: QIcon, color: QColor, text: str, parent: QWidget = None)
+        - __init__(self, icon: FluentIconBase, color: QColor, text: str, parent: QWidget = None)
+    """
+
+    sigRemoveClicked = Signal()
+
+    @singledispatchmethod
+    def __init__(self, parent: QWidget = None):
+        super().__init__(parent)
+        self.color = None
+        qconfig.themeChangedFinished.connect(self.set_color)
+        self.context_menu = RoundMenu("Context Menu")
+        self.remove_action = Action("Remove")
+        self.remove_action.setIcon(FluentIcon.DELETE)
+        self.remove_action.triggered.connect(self.sigRemoveClicked.emit)
+        self.context_menu.addAction(self.remove_action)
+
+    @__init__.register
+    def _(self, color: QColor, text: str, parent: QWidget = None, icon: QIcon | FluentIconBase | str = None):
+        self.__init__(parent)
+        self.setText(text)
+        self.setIcon(icon)
+        self.color = color
+        self.set_color()
+
+    @__init__.register
+    def _(self, icon: QIcon, color: QColor, text: str, parent: QWidget = None):
+        self.__init__(color, text, parent, icon)
+
+    @__init__.register
+    def _(self, icon: FluentIconBase, color: QColor, text: str, parent: QWidget = None):
+        self.__init__(color, text, parent, icon)
+
+    def contextMenuEvent(self, a0: QContextMenuEvent) -> None:
+        self.context_menu.exec(a0.globalPos())
+
+
+class AverageLineComponent:
+    """
+    A component that handles the addition and removal of average lines on a plot.
+    """
+
+    def __init__(self, plot_widget: QPlotWidget, parent=None) -> None:
+        """
+        Initializes the AverageLineComponent object.
+
+        Parameters:
+        - plot_widget (QPlotWidget): The plot widget where the average lines are added.
+        - parent: The parent object of the component.
+        """
+        self.parent = parent
+        self.plot_widget = plot_widget
+        self.plot_items_bar = CommandBar(parent=self.parent)
+        self.plot_items_bar.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.plot_items_bar.setFixedHeight(25)
+        self.plot_items_bar.addSeparator()
+        self.add_line_action = Action("Add average line")
+        self.add_line_action.setIcon(FluentIcon.ADD)
+        self.add_line_action.triggered.connect(self.__on_add_line_action_clicked)
+        self.plot_items_bar.addAction(self.add_line_action)
+        self.show_all_line_action = Action("Show all average lines")
+        self.show_all_line_action.setIcon(FluentIcon.VIEW)
+        self.show_all_line_action.triggered.connect(self.show_all_average_lines)
+        self.plot_items_bar.addAction(self.show_all_line_action)
+        self.hide_all_line_action = Action("Hide all average lines")
+        self.hide_all_line_action.setIcon(FluentIcon.HIDE)
+        self.hide_all_line_action.triggered.connect(self.hide_all_average_lines)
+        self.plot_items_bar.addAction(self.hide_all_line_action)
+
+        self.average_lines = {}
+
+    def __on_add_line_action_clicked(self):
+        """
+        Handles the event when the add line action is clicked.
+        Shows a dialog box for selecting the number of data points and color for the average line.
+        Adds the average line to the plot.
+        """
+        msg = NewAverageLineBox(
+            num_data=len(self.parent.main_item.get_feature_value()),
+            existed_values=self.average_lines.keys(),
+            parent=self.parent,
+        )
+        if msg.exec():
+            self.add_average_line(int(msg.value_edit.text()), msg.color_selector.current_item)
+
+    def get_widget(self):
+        """
+        Returns the plot_items_bar widget.
+
+        Returns:
+        - QWidget: The plot_items_bar widget.
+        """
+        return self.plot_items_bar
+
+    def add_average_line(self, num_average_data, color):
+        """
+        Adds an average line to the plot.
+
+        Parameters:
+        - num_average_data (int): The number of data points to calculate the average.
+        - color: The color of the average line.
+        """
+        if not hasattr(self.parent, "main_item"):
+            raise ValueError("The parent plotter has no main item")
+        if self.parent.main_item is None:
+            raise ValueError("The main item of the parent plotter is None")
+        data = self.parent.main_item.get_feature_value()
+        style = self.parent.main_item.style
+        average_line = AverageLineItem(data, num_average_data, color, style.line_width)
+        self.average_lines[num_average_data] = average_line
+        self.plot_widget.add_item(average_line)
+        toggle_button = AverageLineButton(color=color, parent=self.plot_items_bar, text=f"MA{num_average_data}")
+        toggle_button.setFixedHeight(25)
+        toggle_button.setChecked(True)
+
+        def on_toggle_button_clicked():
+            if toggle_button.isChecked():
+                self.plot_widget.add_item(average_line)
+                self.average_lines[num_average_data] = average_line
+            else:
+                self.plot_widget.remove_item(average_line)
+                self.average_lines.pop(num_average_data)
+
+        def on_remove_button_clicked():
+            self.plot_widget.remove_item(average_line)
+            self.average_lines.pop(num_average_data)
+            self.plot_items_bar.removeWidget(toggle_button)
+            toggle_button.deleteLater()
+
+        toggle_button.clicked.connect(on_toggle_button_clicked)
+        toggle_button.sigRemoveClicked.connect(on_remove_button_clicked)
+        self.plot_items_bar._insertWidgetToLayout(len(self.plot_items_bar._widgets) - 4, toggle_button)
+
+    def add_default_average_lines(self):
+        """
+        Adds the default average lines based on the style of the main item.
+        """
+        style = self.parent.main_item.style
+        for num_average_data in style.average_line_color.keys():
+            self.add_average_line(num_average_data, style.average_line_color[num_average_data])
+
+    def show_all_average_lines(self):
+        """
+        Shows all the average lines.
+        """
+        for item in self.plot_items_bar._widgets:
+            if isinstance(item, AverageLineButton):
+                if not item.isChecked():
+                    item.click()
+
+    def hide_all_average_lines(self):
+        """
+        Hides all the average lines.
+        """
+        for item in self.plot_items_bar._widgets:
+            if isinstance(item, AverageLineButton):
+                if item.isChecked():
+                    item.click()