squap 0.0.1__tar.gz

squap-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rik Mulder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

squap-0.0.1/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: squap
+Version: 0.0.1
+Summary: Package for animated plots, focussed on simplicity and speed.
+Author-email: Rik Mulder <rikmulder7@proton.me>
+License-Expression: MIT
+Project-URL: documentation, https://squap.readthedocs.io/en/latest/
+Project-URL: source, https://github.com/squaplib/squap
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+Dynamic: requires-python
+
+# squap
+A python package for animated plots, focussed on simplicity and speed. Its name stands for Simple QUick Animated Plots. It is based on pyqtgraph using PySide6. It is much simpler and user-friendly than pyqtgraph, sacrificing as little performance as possible.

squap-0.0.1/README.md

@@ -0,0 +1,2 @@
+# squap
+A python package for animated plots, focussed on simplicity and speed. Its name stands for Simple QUick Animated Plots. It is based on pyqtgraph using PySide6. It is much simpler and user-friendly than pyqtgraph, sacrificing as little performance as possible.

squap-0.0.1/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "squap"
+version = "0.0.1"
+authors = [
+  { name="Rik Mulder", email="rikmulder7@proton.me" },
+]
+description = "Package for animated plots, focussed on simplicity and speed."
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+documentation = "https://squap.readthedocs.io/en/latest/"
+source = "https://github.com/squaplib/squap"

squap-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

squap-0.0.1/setup.py

@@ -0,0 +1,9 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="squap",
+    version="0.0.1",
+    packages=find_packages(),
+    python_requires=">=3.9",
+    install_requires=[],
+)

squap-0.0.1/squap/__init__.py

@@ -0,0 +1,480 @@
+# starts off by creating an instance of main_window, containing a plot widget.
+from typing import Callable, Iterable       # Iterable is necessary for docs compiler
+
+from . import widgets
+from .widgets import (MainWindow, PlotManager, TableManager, PlotWidget, InputTable, Box, PlotCurve, ErrorbarCurve,
+                      TextCurve, InfLine, ImageCurve, GridCurve)
+from .variables import Variables
+from .customisation import get_font, get_gradient, get_cmap, cmap_to_colors
+from .helper_funcs import ColorType, ColorsType
+
+import functools        # for copy_docstring decorator
+import inspect
+
+from pyqtgraph import setConfigOption
+from PySide6.QtCore import QTimer
+
+__all__ = [
+    "widgets", "ColorType", "ColorsType",       # things not in __init__.pyi
+    "var", "plot", "scatter", "errorbar", "set_xlim", "set_ylim", "xlim", "ylim", "legend", "set_title", "lock_zoom", "subplots",
+    "remove_item", "get_gradient", "get_cmap", "inf_dline", "inf_hline", "inf_vline", "grid", "plot_text", "merge_plots", "set_interval",
+    "on_refresh", "on_mouse_click", "on_mouse_move", "get_mouse_pos", "on_key_press", "add_slider", "add_checkbox", "add_inputbox", "add_button",
+    "add_dropdown", "add_rate_slider", "link_boxes", "add_input_table", "set_active_tab", "rename_tab", "get_all_boxes", "display_fps", "resize", "benchmark", "set_input_width",
+    "set_input_partition", "is_alive", "refresh", "show_window", "show", "clear", "export", "export_video", "start_recording", "get_font",
+    "cmap_to_colors"
+]
+
+_window = None
+_input_table = None
+_table_manager = None
+var = Variables()
+
+
+def _copy_docstring(method):
+    def decorator(func):
+        original_module = func.__module__
+        sig = inspect.signature(method)
+        params = list(sig.parameters.values())
+        if params and params[0].name == 'self':
+            params = params[1:]
+        new_sig = sig.replace(parameters=params)
+        functools.update_wrapper(func, method)
+        if hasattr(func, '__wrapped__'):
+            del func.__wrapped__
+        func.__module__ = original_module
+        func.__signature__ = new_sig
+        return func
+    return decorator
+
+
+def get_window() -> MainWindow:
+    global _window
+    if _window is None:
+        _window = widgets.MainWindow(var)
+    return _window
+
+
+def get_input_table() -> InputTable:
+    global _input_table
+    if _input_table is None:
+        if get_window().table_manager.main_input_widget:     # it is possible to init table widget without this function
+            _input_table = get_window().table_manager.main_input_widget
+        else:
+            _input_table = get_window().init_first_tab()
+    return _input_table
+
+
+def get_table_manager():
+    """Makes sure that when a function from table_manager is called, the input table is initialised."""
+    global _table_manager
+    if _table_manager is None:
+        get_input_table()
+        _table_manager = get_window().table_manager
+    return _table_manager
+
+
+# <editor-fold desc="wrapped functions">
+@_copy_docstring(widgets.PlotWidget.plot)
+def plot(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.plot(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.scatter)
+def scatter(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.scatter(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.errorbar)
+def errorbar(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.errorbar(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.inf_dline)
+def inf_dline(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.inf_dline(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.inf_hline)
+def inf_hline(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.inf_hline(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.inf_vline)
+def inf_vline(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.inf_vline(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.grid)
+def grid(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.grid(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.plot_text)
+def plot_text(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.plot_text(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.imshow)
+def imshow(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.imshow(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.set_xlim)
+def set_xlim(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.set_xlim(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.set_ylim)
+def set_ylim(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.set_ylim(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.xlim)
+def xlim(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.xlim(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.ylim)
+def ylim(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.ylim(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.enable_autoscale)
+def enable_autoscale(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.enable_autoscale(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.disable_autoscale)
+def disable_autoscale(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.disable_autoscale(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.legend)
+def legend(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.legend(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.set_title)
+def set_title(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.set_title(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotWidget.lock_zoom)
+def lock_zoom(*args, **kwargs):
+    return get_window().plot_manager.plot_widget.lock_zoom(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotManager.create_subplots)
+def subplots(*args, **kwargs):
+    return get_window().plot_manager.create_subplots(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotManager.remove_item)
+def remove_item(*args, **kwargs):
+    return get_window().plot_manager.remove_item(*args, **kwargs)
+
+
+@_copy_docstring(widgets.PlotManager.merge_plots)
+def merge_plots(*args, **kwargs):
+    return get_window().plot_manager.merge_plots(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.set_interval)
+def set_interval(*args, **kwargs):
+    return get_window().set_interval(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.is_alive)
+def is_alive():
+    return get_window().is_alive()
+
+
+@_copy_docstring(widgets.InputTable.add_slider)
+def add_slider(*args, **kwargs):
+    return get_input_table().add_slider(*args, **kwargs)
+
+
+@_copy_docstring(widgets.InputTable.add_checkbox)
+def add_checkbox(*args, **kwargs):
+    return get_input_table().add_checkbox(*args, **kwargs)
+
+
+@_copy_docstring(widgets.InputTable.add_inputbox)
+def add_inputbox(*args, **kwargs):
+    return get_input_table().add_inputbox(*args, **kwargs)
+
+
+@_copy_docstring(widgets.input_widget.InputTable.add_button)
+def add_button(*args, **kwargs):
+    return get_input_table().add_button(*args, **kwargs)
+
+
+@_copy_docstring(widgets.InputTable.add_dropdown)
+def add_dropdown(*args, **kwargs):
+    return get_input_table().add_dropdown(*args, **kwargs)
+
+
+@_copy_docstring(widgets.InputTable.add_rate_slider)
+def add_rate_slider(*args, **kwargs):
+    return get_input_table().add_rate_slider(*args, **kwargs)
+
+
+@_copy_docstring(widgets.InputTable.add_color_picker)
+def add_color_picker(*args, **kwargs):
+    return get_input_table().add_color_picker(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.on_mouse_click)
+def on_mouse_click(*args, **kwargs):
+    return get_window().on_mouse_click(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.on_mouse_move)
+def on_mouse_move(*args, **kwargs):
+    return get_window().on_mouse_move(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.get_mouse_pos)
+def get_mouse_pos(*args, **kwargs):
+    return get_window().get_mouse_pos(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.on_key_press)
+def on_key_press(*args, **kwargs):
+    return get_window().on_key_press(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.add_table)
+def add_input_table(*args, **kwargs):
+    return get_window().add_table(*args, **kwargs)
+
+
+@_copy_docstring(widgets.TableManager.rename_tab)
+def rename_tab(*args, **kwargs):
+    return get_table_manager().rename_tab(*args, **kwargs)
+
+
+@_copy_docstring(widgets.TableManager.set_active_tab)
+def set_active_tab(*args, **kwargs):
+    return get_table_manager().set_active_tab(*args, **kwargs)
+
+
+@_copy_docstring(widgets.TableManager.get_all_tabs)
+def get_all_tabs():
+    return get_table_manager().get_all_tabs()
+
+
+@_copy_docstring(widgets.TableManager.get_all_boxes)
+def get_all_boxes():
+    return get_table_manager().get_all_boxes()
+
+
+@_copy_docstring(widgets.TableManager.get_current_row)
+def get_current_row():
+    return get_table_manager().get_current_row()
+
+
+@_copy_docstring(widgets.TableManager.link_boxes)
+def link_boxes(*args, **kwargs):
+    return get_table_manager().link_boxes(*args, **kwargs)
+
+
+@_copy_docstring(widgets.TableManager.set_input_partition)
+def set_input_partition(*args, **kwargs):
+    return get_table_manager().set_input_partition(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.resize_window)
+def resize(*args, **kwargs):
+    return get_window().resize_window(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.window_size)
+def size():
+    return get_window().window_size()
+
+
+@_copy_docstring(widgets.MainWindow.set_input_width_ratio)
+def set_input_width(*args, **kwargs):
+    return get_window().set_input_width_ratio(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.display_fps)
+def display_fps(*args, **kwargs):
+    return get_window().display_fps(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.benchmark)
+def benchmark(*args, **kwargs):
+    return get_window().benchmark(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.refresh)
+def refresh(*args, **kwargs):
+    return get_window().refresh(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.show_window)
+def show_window():
+    return get_window().show_window()
+
+
+@_copy_docstring(widgets.MainWindow.on_refresh)
+def on_refresh(*args, **kwargs):
+    return get_window().on_refresh(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.start)
+def show():
+    return get_window().start()
+
+
+def close_window():
+    """Closes the window."""
+    return get_window().close()
+
+
+@_copy_docstring(widgets.MainWindow.clear)
+def clear():
+    return get_window().clear()
+
+
+@_copy_docstring(widgets.MainWindow.export)
+def export(*args, **kwargs):
+    return get_window().export(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.export_video)
+def export_video(*args, **kwargs):
+    return get_window().export_video(*args, **kwargs)
+
+
+@_copy_docstring(widgets.MainWindow.start_recording)
+def start_recording(*args, **kwargs):
+    return get_window().start_recording(*args, **kwargs)
+# </editor-fold>
+
+
+def enable_numba(enable: bool = True):
+    """Enable numba. Can be a little faster, but takes longer to initialize. """
+    setConfigOption('useNumba', enable)
+
+
+def on_next_refresh(func: Callable):          # todo: only works in eventloop, not in show_window style.
+    """Calls a function upon next refresh only. """
+    QTimer.singleShot(0, func)
+
+
+# def init_3D():
+#     window.init_3D()
+#
+#
+# def add_grid(diagonal):
+#     """
+#     :param diagonal: A tuple of two points that span the diagonal of a rectangle that lies on or parallel to the
+#         xy, yz, or zx plane.
+#     :return:
+#     """
+#     if window.plot_style_3D:
+#         window.plot_widget.add_grid(diagonal)
+#     else:
+#         raise RuntimeError("This function only works in 3D. 3D mode needs to be initialised first. (1003)")
+#
+#
+# def add_grids(size=(0.0, 5.0)):
+#     """
+#     Adds square grids on the xy, yz and zx planes, spanning from size[0] to size[1].
+#
+#     :param size: the size of each grid.
+#     """
+#     if window.plot_style_3D:
+#         window.plot_widget.add_grids(size)
+#     else:
+#         raise RuntimeError("This function only works in 3D. 3D mode needs to be initialised first. (1003)")
+#
+#
+# def align_camera():
+#     window.plot_widget.animated = True
+#     current_params = window.plot_widget.cameraParams()
+#     add_rate_slider("distance", current_params["distance"], changerate=2)
+#     row_js_1 = get_current_row()
+#     slider_1 = add_slider("azimuth", current_params["azimuth"], 0, 360, n_ticks=72)
+#     slider_2 = add_slider("elevation", current_params["elevation"], -90, 90, n_ticks=180)
+#     slider_3 = add_slider("fov", current_params["fov"], 0, 180, n_ticks=180)
+#     add_rate_slider("x", 0, absolute=True, changerate=5)       # todo: change init_value to current_params.center.x
+#     row_js_x = get_current_row()
+#     add_rate_slider("y", 0, absolute=True, changerate=5)
+#     row_js_y = get_current_row()
+#     add_rate_slider("z", 0, absolute=True, changerate=5)
+#     row_js_z = get_current_row()
+#
+#     def update_cam_params():
+#         window.plot_widget.setCameraParams(
+#             distance=var.distance,
+#             azimuth=var.azimuth,
+#             elevation=var.elevation,
+#             fov=var.fov
+#         )
+#
+#     def rate_slider_update(row):
+#         if row == row_js_1:
+#             update_cam_params()
+#
+#     def update_cam_pos():
+#         vector = QtGui.QVector3D(
+#             var.x,
+#             var.y,
+#             var.z
+#         )
+#         window.plot_widget.setCameraPosition(
+#             vector
+#         )
+#
+#     def rate_slider_pos_update(row):
+#         if row == row_js_x or row == row_js_y or row == row_js_z:
+#             update_cam_pos()
+#
+#     slider_1.valueChanged.connect(update_cam_params)
+#     slider_2.valueChanged.connect(update_cam_params)
+#     slider_3.valueChanged.connect(update_cam_params)
+#     window.input_widget.cellChanged.connect(rate_slider_update)
+#     window.input_widget.cellChanged.connect(rate_slider_pos_update)
+#     update_cam_params()
+#
+#     def get_params():
+#         print(
+#             f"The following function would get you this camera postition: \n"
+#             f"squap.set_camera(\n"
+#             f"    x={var.x}, y={var.y}, z={var.z}, \n"
+#             f"    distance={var.distance}, azimuth={var.azimuth}, "
+#             f"elevation={var.elevation}, fov={var.fov}\n)"
+#         )
+#
+#     add_button("print camera parameters", get_params)
+#
+#
+# def set_camera(x=None, y=None, z=None, distance=None, azimuth=None, elevation=None, fov=None):
+#     """
+#     Sets the camera position, rotation and fov using the given arguments.
+#
+#     :param x:
+#     :type x: float
+#     :param fov: field of view of the camera
+#
+#     """
+#     cam_params_kwargs = {}
+#
+#     if distance is not None:
+#         cam_params_kwargs["distance"] = distance
+#     if azimuth is not None:
+#         cam_params_kwargs["azimuth"] = azimuth
+#     if elevation is not None:
+#         cam_params_kwargs["elevation"] = elevation
+#     if fov is not None:
+#         cam_params_kwargs["fov"] = fov
+#
+#     window.plot_widget.setCameraParams(**cam_params_kwargs)
+#     if x is not None or y is not None or z is not None:     # todo: fix this. When only z is given there is an error.
+#         window.plot_widget.setCameraPosition(
+#             QtGui.QVector3D(x, y, z)
+#         )

squap-0.0.1/squap/__init__.pyi

@@ -0,0 +1,71 @@
+from . import widgets
+from .helper_funcs import ColorType, ColorsType
+from .customisation import Font
+from typing import Callable, Iterable, Union, Optional, Any, ForwardRef
+import typing
+import numpy
+
+import PySide6
+import pyqtgraph
+from pyqtgraph import mkColor
+import matplotlib.colors
+
+from .variables import Variables
+from .helper_funcs import ColorType, ColorsType
+
+
+var: Variables
+
+
+def plot(*args, color: Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float, Iterable[ForwardRef('ColorsType')]] = 'y', width: int = 1, dashed: bool = False, dash_pattern: Optional[Iterable[int]] = None, connect: str | numpy.ndarray = 'auto', gradient: Optional[PySide6.QtGui.QGradient] = None, line_style: Optional[str] = None, antialias: bool = False, auto_downsample: bool = False, downsample: int = 1, downsample_method: str = 'mean', skip_finite_check: bool = False, **kwargs) -> 'PlotCurve': ...
+def scatter(*args, color: Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float, Iterable[ForwardRef('ColorsType')]] = 'y', size: int = 7, edge_width: int = -1, edge_color: Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float] = 'white', pixel_mode: bool = True, downsample: int = 1, downsample_method: str = 'mean', auto_downsample: bool = False, antialias: bool = False, **kwargs) -> 'PlotCurve': ...
+def errorbar(*args, x_err=None, y_err=None, color: Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float] = 'y', width: int = 1, errorbar_width: int = 1, beam_size: float = 0, dashed: bool = False, dash_pattern: Iterable[int] = None, connect: str = 'auto', gradient: Optional[PySide6.QtGui.QGradient] = None, line_style: Optional[str] = None, antialias: bool = False, auto_downsample: bool = False, downsample: int = 1, downsample_method: str = 'mean', skip_finite_check: bool = False, **kwargs) -> 'PlotCurve': ...
+def set_xlim(x_min: float, x_max: float): ...
+def set_ylim(y_min: float, y_max: float): ...
+def xlim() -> tuple[float]: ...
+def ylim() -> tuple[float]: ...
+def legend(): ...
+def set_title(text: str | typing.Any): ...
+def lock_zoom(curves: 'Iterable[PlotCurve]'): ...
+def subplots(nrows: int = 1, ncols: int = 1, heightratios: Optional[list[int]] = None, widthratios: Optional[list[int]] = None) -> list: ...
+def remove_item(item: pyqtgraph.graphicsItems.GraphicsObject.GraphicsObject): ...
+def get_gradient(cmap: Union[str, matplotlib.colors.Colormap, Iterable, dict], style: str = 'horizontal', position: Optional[Iterable] = None, extend: str = 'pad', resolution: int = 256) -> PySide6.QtGui.QGradient: ...
+def get_cmap(data: Union[str, dict[float, Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float]], Iterable[Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float]]], source: str = 'matplotlib'): ...
+def inf_dline(pos: float | tuple[float], angle: float = 45, color: Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float] = 'y', width: int = 1, dashed: bool = False, dash_pattern: Optional[Iterable[int]] = None, line_style: Optional[str] = None, movable: bool = False, bounds: Optional[Iterable[int]] = None, span: tuple = (0, 1), line_movable: Optional[bool] = None, label: bool = False, label_text: str = '{value}', label_movable: Optional[Iterable[int]] = None, label_position: float = 0.5, label_anchors: Optional[list[tuple]] = None, hover_color: Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float] = 'red', hover_width: int = 1, name: Optional[str] = None, **kwargs): ...
+def inf_hline(pos: float | tuple[float], color: Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float] = 'y', width: int = 1, dashed: bool = False, dash_pattern: Optional[Iterable[int]] = None, line_style: Optional[str] = None, movable: bool = False, bounds: Optional[Iterable[int]] = None, span: tuple = (0, 1), line_movable: Optional[bool] = None, label: bool = False, label_text: str = '{value}', label_movable: Optional[Iterable[int]] = None, label_position: float = 0.5, label_anchors: Optional[list[tuple]] = None, hover_color: Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float] = 'red', hover_width: int = 1, name: Optional[str] = None, **kwargs): ...
+def inf_vline(pos: float | tuple[float], color: Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float] = 'y', width: int = 1, dashed: bool = False, dash_pattern: Optional[Iterable[int]] = None, line_style: Optional[str] = None, movable: bool = False, bounds: Optional[Iterable[int]] = None, span: tuple = (0, 1), line_movable: Optional[bool] = None, label: bool = False, label_text: str = '{value}', label_movable: Optional[Iterable[int]] = None, label_position: float = 0.5, label_anchors: Optional[list[tuple]] = None, hover_color: Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float] = 'red', hover_width: int = 1, name: Optional[str] = None, **kwargs): ...
+def grid(tick_spacing: Union[tuple, float, None] = None, color: Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float, None] = None, width: int = 1, **kwargs): ...
+def plot_text(text: str, pos: Iterable[float], color: Union[PySide6.QtGui.QColor, mkColor, str, Iterable[float], float] = (0.8, 0.8, 0.8), angle: float = 0, font: Union[str, squap.customisation.Font, None] = None, font_size: Optional[int] = None, html: Optional[str] = None, text_width: Optional[int] = None, **kwargs): ...
+def merge_plots(plots: Iterable[widgets.plot_widget.PlotWidget]) -> widgets.plot_widget.PlotWidget: ...
+def set_interval(interval: float): ...
+def on_refresh(func: Callable, disconnect: bool = False): ...
+def on_mouse_click(func: Callable, pixel_mode: bool = False, ax: Optional[widgets.plot_widget.PlotWidget] = None): ...
+def on_mouse_move(func: Callable, pixel_mode: bool = False, ax: Optional[widgets.plot_widget.PlotWidget] = None): ...
+def get_mouse_pos(pixel_mode=False, ax: Optional[widgets.plot_widget.PlotWidget] = None) -> tuple: ...
+def on_key_press(func: Callable, accept_modifier: bool = False, modifier_arg: bool = False, event_arg: bool = False) -> Callable: ...
+def add_slider(name: str, init_value: float = 1.0, min_value: float = 0.0, max_value: float = 10.0, n_ticks: int = 51, tick_interval: Optional[float] = None, only_ints: bool = False, logscale: bool = False, custom_arr: Optional[Iterable] = None, var_name: Optional[str] = None, print_value: bool = False, row: Optional[int] = None) -> 'InputTable.Slider': ...
+def add_checkbox(name: str, init_value: bool = False, var_name: Optional[str] = None, print_value: bool = False, row: Optional[int] = None) -> 'InputTable.CheckBox': ...
+def add_inputbox(name: str, init_value: Any = 1.0, type_func: Optional[Callable] = None, var_name: Optional[str] = None, print_value: bool = False, row: Optional[int] = None) -> 'InputTable.InputBox': ...
+def add_button(name: str, func: Optional[Callable] = None, row: Optional[int] = None) -> 'InputTable.Button': ...
+def add_dropdown(name: str, options: list, init_index: int = 0, option_names: Optional[Iterable[str]] = None, var_name: Optional[str] = None, print_value: bool = False, row: Optional[int] = None) -> 'InputTable.Dropdown': ...
+def add_rate_slider(name: str, init_value: float = 1.0, change_rate: float = 10.0, absolute: bool = False, time_var: Optional[str] = None, custom_func: Optional[Callable] = None, var_name: Optional[str] = None, print_value: bool = False, row: Optional[int] = None) -> 'InputTable.RateSlider': ...
+def link_boxes(boxes: Iterable[widgets.input_widget.Box | int], only_update_boxes: list | None = None): ...
+def add_table(name: Optional[str] = None) -> widgets.input_widget.InputTable: ...
+def set_active_tab(*args: int | widgets.input_widget.InputTable | str, index: int | None = None, tab: widgets.input_widget.InputTable | None = None, name: str | None = None) -> widgets.input_widget.InputTable: ...
+def rename_tab(name: str, index: Optional[int] = 0, old_name: Optional[str] = None) -> widgets.input_widget.InputTable: ...
+def get_all_boxes() -> list[widgets.input_widget.Box]: ...
+def display_fps(update_speed: float = 0.2, get_fps: bool = False, optimized: bool = False, ax: Optional[widgets.plot_widget.PlotWidget] = None): ...
+def resize_window(width: int, height: int): ...
+def benchmark(n_frames: Optional[int] = None, duration: Optional[float] = None): ...
+def set_input_width_ratio(fraction: float = 0.5): ...
+def set_input_partition(fraction: float = 0.3333333333333333): ...
+def is_alive() -> bool: ...
+def refresh(wait_interval: bool = True, call_update_funcs: bool = True): ...
+def show_window(): ...
+def start(): ...
+def clear(): ...
+def export(filename: str, widget: str = 'window'): ...
+def export_video(filename: str, fps: float = 30.0, n_frames: Optional[int] = None, duration: Optional[float] = None, stop_func: Optional[Callable] = None, skip_frames: int = 0, display_window: bool = False, widget: str = 'window', save_on_close: bool = False): ...
+def start_recording(filename: str, fps: float = 30.0, skip_frames: int = 0, widget: str = 'window') -> Callable: ...
+def get_font(font_name: str = 'Segoe UI', font_size: Optional[int] = None, bold: bool = False, italic: bool = False, underline: bool = False, strikethrough: bool = False, overline: bool = False, kerning: bool = False, stretch: int = 100, letter_spacing: float = 0.0, word_spacing: float = 0.0, **kwargs) -> squap.customisation.Font: ...
+def cmap_to_colors(cmap: Callable, N_points: int) -> numpy.ndarray: ...