PySide6Plot 0.0.1__tar.gz

pyside6plot-0.0.1/.gitignore

@@ -0,0 +1,164 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+/pic_edit
+/build
+/dist
+/qstockplotter.egg-info

pyside6plot-0.0.1/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: PySide6Plot
+Version: 0.0.1
+Summary: Scientific/Financial plot utilities with PySide6+pyqtgraph.
+Author-email: YQ Cui <qianyun210603@hotmail.com>
+License-Expression: MIT
+Keywords: visualization,plotting,pyside6,pyqtgraph,financial,scientific
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: pyaml>=23.10.0
+Requires-Dist: PySide6!=6.9.1,>=6.9.0; python_version >= "3.12"
+Requires-Dist: PySide6>=6.9.0; python_version <= "3.12"
+Requires-Dist: pyqtgraph>=0.13.3
+Requires-Dist: PySide6-Fluent-Widgets[full]>=1.5.1
+Provides-Extra: dev
+Requires-Dist: ruff>=0.0.263; extra == "dev"
+Requires-Dist: setuptools_scm>=8; extra == "dev"
+Requires-Dist: setuptools>=64; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+
+<h1 align="center">
+  <br>PySide6Plot<br>
+</h1>
+
+-----
+
+A PySide6-based data visualization tool.

pyside6plot-0.0.1/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-0.0.1/PySide6Plot/compoents/__init__.py

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

pyside6plot-0.0.1/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()