PySide6Plot 0.0.1__py3-none-any.whl

PySide6Plot/compoents/frame_recorder.py

@@ -0,0 +1,213 @@
+from qfluentwidgets import FluentIcon, Action, RoundMenu, MessageBox
+import pyqtgraph as pg
+from ..widgets.q_plot_widget import QPlotWidget
+from ..widgets.value_select_box import select_str, select_limited_str
+from ..widgets.removable_table import RemovableTable
+
+
+class SavedFrameTable(RemovableTable):
+    """
+    Table widget for displaying saved frames.
+    """
+
+    def __init__(self, parent=None):
+        super().__init__(
+            parent=parent,
+            show_row_index=False,
+            resize_columns_to_contents=False,
+            show_move_up_down_buttons=False,
+            show_delete_button=True,
+            show_rename_button=True,
+            accept_name="Jump to",
+            accept_icon=FluentIcon.CHEVRON_RIGHT,
+            link_default_slot=True,
+        )
+        self.set_header_labels(["Name", "Location", "Range"])
+        self.setColumnWidth(0, 100)
+        self.setColumnWidth(1, 150)
+        self.setColumnWidth(2, 150)
+
+
+class FrameRecorderComponent:
+    """
+    A Component for recording and managing frames in a plot widget.
+    """
+
+    def __init__(self, plot_widget: QPlotWidget, parent=None) -> None:
+        """
+        Initialize the FrameRecorderComponent.
+
+        Args:
+            plot_widget (QPlotWidget): The plot widget to record frames from.
+            parent (QWidget, optional): The parent widget. Defaults to None.
+        """
+        self.parent = parent
+        self.plot_widget = plot_widget
+        view_rect = self.plot_widget.viewRect()
+        self.current_x_loc = view_rect.left()
+        self.current_x_range = view_rect.width()
+        self.record_current_frame_change = True
+        self.previous_frame = []
+        self.saved_frame = []
+        self.num_previous_frame = 30
+        self.full_range_action = Action(FluentIcon.FULL_SCREEN, "Full range")
+        self.latest_frame_action = Action(FluentIcon.RIGHT_ARROW, "Latest")
+        self.previous_frame_action = Action(FluentIcon.CANCEL, "Previous frame")
+        self.given_frame_action = Action(FluentIcon.LABEL, "Input coordinate")
+        self.record_current_frame_action = Action(FluentIcon.ADD_TO, "Record current frame")
+        self.jump_to_menu = RoundMenu("Jump to", self.parent)
+        self.jump_to_menu.setIcon(FluentIcon.CHEVRON_RIGHT)
+        self.jump_to_menu.addAction(self.previous_frame_action)
+        self.jump_to_menu.addAction(self.full_range_action)
+        self.jump_to_menu.addAction(self.latest_frame_action)
+        self.jump_to_menu.addAction(self.given_frame_action)
+        self.saved_frame_table = SavedFrameTable(self.parent)
+        self.saved_frame_table.sigAcceptClicked.connect(self.__on_table_jump_to_clicked)
+        self.saved_frame_table.sigRowClicked.connect(self.__on_table_jump_to_clicked)
+        self.saved_frame_table.sigNameEdited.connect(self.__on_table_name_changed)
+        self.saved_frame_table.sigDeleteClicked.connect(self.__on_table_row_deleted)
+        self.saved_frame_table.hide()
+
+        self.__init_connections()
+
+    def __init_connections(self):
+        """
+        Initialize the signal connections.
+        """
+        self.full_range_action.triggered.connect(
+            lambda: self.plot_widget.update_plot(x_loc=self.plot_widget.x_start, x_range=self.plot_widget.x_range_max)
+        )
+        self.latest_frame_action.triggered.connect(
+            lambda: self.plot_widget.update_plot(
+                x_loc=self.plot_widget.x_end - self.plot_widget.viewRect().width(),
+                x_range=self.plot_widget.viewRect().width(),
+            )
+        )
+        self.previous_frame_action.triggered.connect(self.__on_previous_frame_clicked)
+        self.given_frame_action.triggered.connect(self.__on_given_frame_clicked)
+        self.record_current_frame_action.triggered.connect(self.__on_record_current_frame_clicked)
+        self.pg_plotter_view_changed_slot = pg.SignalProxy(
+            self.plot_widget.sigRangeChanged, rateLimit=100, slot=self.__on_pg_plotter_view_changed
+        )
+
+    def __on_pg_plotter_view_changed(self, event):
+        """
+        Handle the event when the plot view changes.
+
+        Args:
+            event: The event object.
+
+        Returns:
+            None
+        """
+        if self.record_current_frame_change:  # move plot will also trigger this event
+            view_rect = self.plot_widget.viewRect()
+            if view_rect.left() != self.current_x_loc or view_rect.width() != self.current_x_range:
+                self.current_x_loc = view_rect.left()
+                self.current_x_range = view_rect.width()
+                if len(self.previous_frame) == self.num_previous_frame:
+                    self.previous_frame.pop(0)
+                    self.previous_frame.append((self.current_x_loc, self.current_x_range))
+                else:
+                    self.previous_frame.append((self.current_x_loc, self.current_x_range))
+                if len(self.previous_frame) > 1:
+                    self.previous_frame_action.setVisible(True)
+        self.record_current_frame_change = True
+
+    def __on_previous_frame_clicked(self):
+        """
+        Move the plot to the previous frame and update the previous_frame list.
+        If there is only one frame left in the previous_frame list, hide the 'previous_frame' option in the context menu.
+        """
+        if len(self.previous_frame) > 1:
+            self.record_current_frame_change = False
+            self.plot_widget.update_plot(x_loc=self.previous_frame[-2][0], x_range=self.previous_frame[-2][1])
+            self.previous_frame.pop(-1)
+            if len(self.previous_frame) == 1:
+                self.previous_frame_action.setVisible(False)
+
+    def __on_record_current_frame_clicked(self):
+        """
+        Records the current frame by prompting the user to input a frame name and saves it to the `saved_frame` list.
+        Updates the saved frame menu afterwards.
+        """
+        frame_name = select_str(self.parent.window(), "Input frame name", f"saved_frame_{len(self.saved_frame) + 1}")
+        if frame_name is not None:
+            view_rect = self.plot_widget.viewRect()
+            self.saved_frame.append([frame_name, view_rect.left(), view_rect.width()])
+            self.saved_frame_table.add_row_data(
+                [frame_name, self.plot_widget.getAxis("bottom").tick_str(view_rect.left()), str(view_rect.width())]
+            )
+
+    def __on_given_frame_clicked(self):
+        """
+        Handle the event when a frame is clicked.
+
+        This method prompts the user to input a coordinate and moves the plot accordingly.
+
+        Returns:
+            None
+        """
+        if self.plot_widget.getAxis("bottom").plot_strs is None:
+            MessageBox(
+                "Error", content="There is no support coordinate system in the plot!", parent=self.parent.window()
+            ).exec()
+        else:
+            items = list(self.plot_widget.getAxis("bottom").plot_strs.values())
+            select_x = select_limited_str(self.parent.window(), "Input coordinate", items)
+            if select_x is not None:
+                self.plot_widget.update_plot(
+                    x_loc=items.index(select_x) - self.plot_widget.x_range_min / 2, x_range=self.plot_widget.x_range_min
+                )
+
+    def __on_table_jump_to_clicked(self, row: int):
+        """
+        Handle the event when a frame is clicked.
+
+        This method moves the plot to the selected frame.
+
+        Args:
+            row (int): The row index of the selected frame.
+
+        Returns:
+            None
+        """
+        self.plot_widget.update_plot(x_loc=self.saved_frame[row][1], x_range=self.saved_frame[row][2])
+
+    def __on_table_name_changed(self, row: int, new_name: str):
+        """
+        Handle the event when the name of a frame is changed.
+
+        Args:
+            row (int): The row index of the frame.
+            new_name (str): The new name for the frame.
+
+        Returns:
+            None
+        """
+        if new_name != "":
+            self.saved_frame[row][0] = new_name
+            self.saved_frame_table.set_row_data_item(row, 0, new_name)
+        else:
+            self.saved_frame_table.set_row_data_item(row, 0, self.saved_frame[row][0])
+
+    def __on_table_row_deleted(self, row: int):
+        """
+        Handle the event when a frame is deleted.
+
+        Args:
+            row (int): The row index of the frame to be deleted.
+
+        Returns:
+            None
+        """
+        self.saved_frame.pop(row)
+
+    def get_widget(self):
+        """
+        Get the widget associated with the FrameRecorderComponent.
+
+        Returns:
+            QWidget: The widget associated with the FrameRecorderComponent.
+        """
+        return self.saved_frame_table

PySide6Plot/compoents/zoom_move.py

@@ -0,0 +1,160 @@
+from pyqtgraph import SignalProxy
+from ..widgets.q_plot_widget import QPlotWidget
+from ..widgets.zoom_bar import ZoomBar
+from ..widgets.fluent_scroller import HorizontalFluentScroller, VerticalFluentScroller
+from ..libs.constant import ZOOM_MODEL, YLOC_MODEL
+
+
+class StockWidgetZoomBar(ZoomBar):
+    """
+    A custom zoom bar widget for the stock plot widget.
+
+    Args:
+        plot_widget (QPlotWidget): The parent plot widget.
+        parent (QWidget): The parent widget.
+
+    Attributes:
+        plot_widget (QPlotWidget): The parent plot widget.
+        current_value (float): The current value of the plot widget's view rectangle width.
+    """
+
+    def __init__(self, plot_widget: QPlotWidget, parent=None) -> None:
+        super().__init__(parent=parent, use_opacity_effect=True)
+        self.plot_widget = plot_widget
+        self.current_value = plot_widget.viewRect().width()
+
+        def update_position():
+            self.setGeometry(
+                self.plot_widget.geometry().width() - 300 - 20, self.plot_widget.geometry().y() + 10, 300, 40
+            )
+
+        update_position()
+        self.plot_widget.sigSizeChanged.connect(update_position)
+
+        def update_boundings():
+            self.current_value = self.plot_widget.viewRect().width()
+            self.update_min_max_value(min_v=self.plot_widget.x_range_min, max_v=self.plot_widget.x_range_max)
+
+        update_boundings()
+        self.plot_widget.sigBoundingUpdated.connect(update_boundings)
+
+        def update_widget():
+            self.update_widget(value=self.plot_widget.viewRect().width())
+
+        update_widget()
+        self.plotter_view_changed_slot = SignalProxy(self.plot_widget.sigRangeChanged, rateLimit=50, slot=update_widget)
+
+    def apply_value_func(self, value):
+        """
+        Apply the given value to the plot widget's x range.
+
+        Args:
+            value (float): The value to be applied.
+
+        Returns:
+            None
+
+        """
+        # x_loc = (self.plot_widget.viewRect().right()+self.plot_widget.viewRect().left())/2-value/2
+        self.plot_widget.update_plot(x_range=value)
+
+
+class StockWidgetHorizontalScroller(HorizontalFluentScroller):
+    """
+    A custom horizontal scroller widget for controlling the movement of a plot widget.
+
+    Args:
+        plot_widget (QPlotWidget): The plot widget to be controlled.
+        parent: The parent widget.
+    """
+
+    def __init__(self, plot_widget: QPlotWidget, parent: None) -> None:
+        super().__init__(parent)
+        self.plot_widget = plot_widget
+        self.move_unit_ratio = 0.02
+        self.move_unit_min = 1
+        self.move_from_update = False
+        self.update_location()
+        self.plot_widget.sigBoundingUpdated.connect(self.update_location)
+        self.plotter_view_changed_slot = SignalProxy(
+            self.plot_widget.sigRangeChanged, rateLimit=50, slot=self.update_location
+        )
+        self.valueChanged.connect(self.on_value_changed)
+
+    def update_location(self):
+        """
+        Update the location and range of the scroller based on the plot widget's view.
+        """
+        self.move_unit = max(self.plot_widget.viewRect().width() * self.move_unit_ratio, self.move_unit_min)
+        self.setRange(
+            0,
+            int(
+                (self.plot_widget.x_end - self.plot_widget.x_start - self.plot_widget.viewRect().width())
+                / self.move_unit
+            ),
+        )
+        self.move_from_update = True
+        self.setValue(int((self.plot_widget.viewRect().left() - self.plot_widget.x_start) / self.move_unit))
+        self.move_from_update = False
+
+    def on_value_changed(self):
+        """
+        Handle the value changed signal of the scroller and update the plot widget's plot accordingly.
+        """
+        if not self.move_from_update:
+            self.plot_widget.update_plot(x_loc=self.value() * self.move_unit + self.plot_widget.x_start)
+
+
+class StockWidgetVerticalScroller(VerticalFluentScroller):
+    """
+    A custom vertical scroller widget for controlling the y-axis movement of a plot widget.
+
+    Args:
+        plot_widget (QPlotWidget): The plot widget to control.
+        parent (None): The parent widget.
+    """
+
+    def __init__(self, plot_widget: QPlotWidget, parent: None) -> None:
+        super().__init__(parent)
+        self.plot_widget = plot_widget
+        self.move_unit_ratio = 0.02
+        self.move_unit_min = 1
+        self.move_from_update = False
+        self.update_location()
+        self.on_zoom_loc_model_changed()
+        self.plot_widget.sigZoomModelChanged.connect(self.on_zoom_loc_model_changed)
+        self.plot_widget.sigYLocModelChanged.connect(self.on_zoom_loc_model_changed)
+        self.plot_widget.sigBoundingUpdated.connect(self.update_location)
+        self.plotter_view_changed_slot = SignalProxy(
+            self.plot_widget.sigRangeChanged, rateLimit=50, slot=self.update_location
+        )
+        self.valueChanged.connect(self.on_value_changed)
+
+    def update_location(self):
+        """
+        Update the location and range of the scroller based on the plot widget's current state.
+        """
+        self.move_unit = max(self.plot_widget.viewRect().height() * self.move_unit_ratio, self.move_unit_min)
+        maximum_y = int(
+            (self.plot_widget.y_end - self.plot_widget.y_start - self.plot_widget.viewRect().height()) / self.move_unit
+        )
+        self.setRange(0, maximum_y)
+        self.move_from_update = True
+        self.setValue(maximum_y - int((self.plot_widget.viewRect().top() - self.plot_widget.y_start) / self.move_unit))
+        self.move_from_update = False
+
+    def on_value_changed(self):
+        """
+        Handle the value changed signal of the scroller and update the plot widget's y-axis location accordingly.
+        """
+        if not self.move_from_update:
+            self.plot_widget.move_y_loc((self.maximum() - self.value()) * self.move_unit + self.plot_widget.y_start)
+
+    def on_zoom_loc_model_changed(self):
+        """
+        Handle the zoom and y-axis location model changed signals of the plot widget and enable/disable the scroller accordingly.
+        """
+        if self.plot_widget.zoom_model != ZOOM_MODEL.AUTO_RANGE and self.plot_widget.y_loc_model == YLOC_MODEL.FREE:
+            self.setEnabled(True)
+        else:
+            self.setEnabled(False)

PySide6Plot/libs/__init__.py

@@ -0,0 +1,3 @@
+"""
+Utils and helper functions for qstock_plotter
+"""

PySide6Plot/libs/constant.py

@@ -0,0 +1,19 @@
+from .helpers import GeneralDataClass
+
+ZOOM_MODEL = GeneralDataClass(
+    AUTO_RANGE=0,
+    FIXED_RATIO=1,
+    FIXED_YRANGE=2,
+)
+
+YLOC_MODEL = GeneralDataClass(
+    FREE=0,  # allow free move, y_loc is changed as while y_center is not changed
+    DATA_CENTERED=1,  # doesn't allow free move, y_loc is always the center of the data
+    FIXED=2,  # dosen't allow free move, y_loc is not changed
+)
+
+SCALE_LOC_MODEL = GeneralDataClass(
+    CENTRAL=0,
+    LEFT=1,
+    RIGHT=2,
+)

PySide6Plot/libs/data_handler.py

@@ -0,0 +1,230 @@
+import pandas as pd
+from dataclasses import dataclass
+from copy import deepcopy
+
+
+class ChildDataFrame:
+    """
+    A class representing a child DataFrame.
+
+    Attributes:
+        data_frame (pd.DataFrame): The parent DataFrame.
+        data_keys (list): The key(s) of the data column(s) in the parent DataFrame.
+        max_y_key (str): The key of the maximum y-value column.
+        min_y_key (str): The key of the minimum y-value column.
+        x_ticks (dict): A dictionary mapping index values to x-labels.
+        __index_start (int): The starting index of the child DataFrame.
+
+    Methods:
+        get_min_x(): Returns the minimum x-value in the parent DataFrame.
+        get_max_x(): Returns the maximum x-value in the parent DataFrame.
+        get_local_range(x_start, x_end): Returns the local range of y-values between x_start and x_end.
+        get_x_ticks(): Returns the x-ticks dictionary.
+        __len__(): Returns the length of the child DataFrame.
+        __getitem__(idx): Returns a tuple of data values at the given index.
+
+    """
+
+    def __init__(
+        self, data_frame: pd.DataFrame, data_keys: str | list, max_y_key=None, min_y_key=None, x_label_key=None
+    ) -> None:
+        """
+        Initialize the DataHandler object.
+
+        Args:
+            data_frame (pd.DataFrame): The parent DataFrame containing the data.
+            data_keys (Union[str, list]): The key(s) to access the data in the parent DataFrame.
+            max_y_key (str, optional): The key to access the maximum y-value data. Defaults to None.
+            min_y_key (str, optional): The key to access the minimum y-value data. Defaults to None.
+            x_label_key (str, optional): The key to access the x-label data. Defaults to None.
+        """
+        data_keys = data_keys if isinstance(data_keys, list) else [data_keys]
+        self.data_keys = deepcopy(data_keys)
+        if max_y_key is not None:
+            if max_y_key not in data_keys:
+                data_keys.append(max_y_key)
+        else:
+            max_y_key = data_keys[0]
+        self.max_y_key = max_y_key
+        if min_y_key is not None:
+            if min_y_key not in data_keys:
+                data_keys.append(min_y_key)
+        else:
+            min_y_key = data_keys[0]
+        self.min_y_key = min_y_key
+        x_label_key = x_label_key if x_label_key is not None else "date"
+        if x_label_key not in data_keys:
+            data_keys.append(x_label_key)
+        self.data_frame = data_frame[data_keys]
+        self.x_ticks: dict = {i: str(self.data_frame[x_label_key][i]) for i in self.data_frame.index}
+        self.__index_start = self.get_min_x()
+
+    def get_min_x(self):
+        """
+        Returns the minimum x-value in the parent DataFrame.
+
+        Returns:
+            int: The minimum x-value.
+
+        """
+        return self.data_frame.index[0]
+
+    def get_max_x(self):
+        """
+        Returns the maximum x-value in the parent DataFrame.
+
+        Returns:
+            int: The maximum x-value.
+
+        """
+        return self.data_frame.index[-1]
+
+    def get_local_range(self, x_start, x_end):
+        """
+        Returns the local range of y-values between x_start and x_end.
+
+        Args:
+            x_start (int): The starting x-value.
+            x_end (int): The ending x-value.
+
+        Returns:
+            tuple: A tuple containing the minimum and maximum y-values.
+
+        """
+        x_start = int(x_start)
+        x_end = int(x_end)
+        return pd.to_numeric(self.data_frame.loc[x_start:x_end, self.min_y_key]).min(), pd.to_numeric(
+            self.data_frame.loc[x_start:x_end, self.max_y_key]
+        ).max()
+
+    def get_x_ticks(self):
+        """
+        Returns the x-ticks dictionary.
+
+        Returns:
+            dict: A dictionary mapping index values to x-labels.
+
+        """
+        return self.x_ticks
+
+    def __len__(self):
+        """
+        Returns the length of the child DataFrame.
+
+        Returns:
+            int: The length of the child DataFrame.
+
+        """
+        return len(self.data_frame)
+
+    def __getitem__(self, idx):
+        """
+        Returns a tuple of data values at the given index.
+
+        Args:
+            idx (int): The index.
+
+        Returns:
+            tuple: A tuple containing the index value and data values.
+
+        """
+
+        return tuple([self.data_frame.index[idx]]) + tuple(
+            pd.to_numeric(self.data_frame[key][self.__index_start + idx], errors="coerce") for key in self.data_keys
+        )
+
+
+class PricesDataFrame(ChildDataFrame):
+    """
+    A class representing a DataFrame containing prices data.
+
+    Parameters:
+    data_frame (pd.DataFrame): The parent DataFrame containing the prices data.
+    """
+
+    def __init__(self, data_frame: pd.DataFrame):
+        super().__init__(
+            data_frame,
+            data_keys=["open", "close", "high", "low"],
+            max_y_key="high",
+            min_y_key="low",
+            x_label_key="date",
+        )
+
+
+class VolumeDataFrame(ChildDataFrame):
+    """
+    A class representing a volume data frame.
+
+    This class inherits from the ChildDataFrame class and provides additional functionality
+    for handling volume data.
+
+    Args:
+        data_frame (pd.DataFrame): The parent data frame from which the volume data frame is derived.
+
+    Attributes:
+        data_keys (list): A list of data keys for the volume data.
+        x_label_key (str): The key for the x-axis label in the volume data frame.
+
+    """
+
+    def __init__(self, data_frame: pd.DataFrame):
+        super().__init__(data_frame, data_keys=["volume"], x_label_key="date")
+
+
+@dataclass
+class TradeData:
+    prices: PricesDataFrame
+    volume: VolumeDataFrame
+
+
+class DataHandler:
+    def __init__(self):
+        self.day_data: TradeData = None
+        self.week_data: TradeData = None
+        self.month_data: TradeData = None
+
+    def save(self, hdf5_path):
+        for key, data in zip(
+            ["day_data", "week_data", "month_data"], [self.day_data, self.week_data, self.month_data], strict=False
+        ):
+            price = data.prices.data_frame
+            volume = data.volume.data_frame
+            volume = volume.drop(columns=["date"])
+            df = price.join(volume)
+            df.to_hdf(hdf5_path, key=key)
+
+    def load(self, hdf5_path):
+        # self.__df_day = pd.read_hdf(hdf5_path, key="day_data")
+        # self.__df_week = pd.read_hdf(hdf5_path, key="week_data")
+        # self.__df_month = pd.read_hdf(hdf5_path, key="month_data")
+        self.day_data = self._load_data(hdf5_path, "day_data")
+        self.week_data = self._load_data(hdf5_path, "week_data")
+        self.month_data = self._load_data(hdf5_path, "month_data")
+
+    def _load_data(self, path, key):
+        try:
+            df = pd.read_hdf(path, key=key)
+        except Exception as e:
+            print(f"Error loading data from {path} with key {key}: {e}")
+            return None
+        return TradeData(PricesDataFrame(df), VolumeDataFrame(df))
+
+
+class HDF5Handler(DataHandler):
+    """
+    A class that handles candlestick data from an HDF5 file.
+
+    Attributes:
+        day_data (TradeData): Candlestick data for daily intervals.
+        week_data (TradeData): Candlestick data for weekly intervals.
+        month_data (TradeData): Candlestick data for monthly intervals.
+
+    Methods:
+        __init__(hdf5_path): Initializes the HDF5Handler object.
+
+    """
+
+    def __init__(self, hdf5_path: str) -> None:
+        super().__init__()
+        self.load(hdf5_path)