mirror of
https://github.com/bec-project/bec_widgets.git
synced 2025-12-31 19:11:18 +01:00
1244 lines
37 KiB
Python
1244 lines
37 KiB
Python
# This file was automatically generated by generate_cli.py
|
|
|
|
from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECFigureClientMixin
|
|
from typing import Literal, Optional, overload
|
|
|
|
|
|
class BECPlotBase(RPCBase):
|
|
@property
|
|
@rpc_call
|
|
def config_dict(self) -> "dict":
|
|
"""
|
|
Get the configuration of the widget.
|
|
Returns:
|
|
dict: The configuration of the widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set(self, **kwargs) -> "None":
|
|
"""
|
|
Set the properties of the plot widget.
|
|
Args:
|
|
**kwargs: Keyword arguments for the properties to be set.
|
|
Possible properties:
|
|
- title: str
|
|
- x_label: str
|
|
- y_label: str
|
|
- x_scale: Literal["linear", "log"]
|
|
- y_scale: Literal["linear", "log"]
|
|
- x_lim: tuple
|
|
- y_lim: tuple
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_title(self, title: "str"):
|
|
"""
|
|
Set the title of the plot widget.
|
|
Args:
|
|
title(str): Title of the plot widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_x_label(self, label: "str"):
|
|
"""
|
|
Set the label of the x-axis.
|
|
Args:
|
|
label(str): Label of the x-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_y_label(self, label: "str"):
|
|
"""
|
|
Set the label of the y-axis.
|
|
Args:
|
|
label(str): Label of the y-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_x_scale(self, scale: "Literal['linear', 'log']" = "linear"):
|
|
"""
|
|
Set the scale of the x-axis.
|
|
Args:
|
|
scale(Literal["linear", "log"]): Scale of the x-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_y_scale(self, scale: "Literal['linear', 'log']" = "linear"):
|
|
"""
|
|
Set the scale of the y-axis.
|
|
Args:
|
|
scale(Literal["linear", "log"]): Scale of the y-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_x_lim(self, *args) -> "None":
|
|
"""
|
|
Set the limits of the x-axis. This method can accept either two separate arguments
|
|
for the minimum and maximum x-axis values, or a single tuple containing both limits.
|
|
|
|
Usage:
|
|
set_x_lim(x_min, x_max)
|
|
set_x_lim((x_min, x_max))
|
|
|
|
Args:
|
|
*args: A variable number of arguments. Can be two integers (x_min and x_max)
|
|
or a single tuple with two integers.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_y_lim(self, *args) -> "None":
|
|
"""
|
|
Set the limits of the y-axis. This method can accept either two separate arguments
|
|
for the minimum and maximum y-axis values, or a single tuple containing both limits.
|
|
|
|
Usage:
|
|
set_y_lim(y_min, y_max)
|
|
set_y_lim((y_min, y_max))
|
|
|
|
Args:
|
|
*args: A variable number of arguments. Can be two integers (y_min and y_max)
|
|
or a single tuple with two integers.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_grid(self, x: "bool" = False, y: "bool" = False):
|
|
"""
|
|
Set the grid of the plot widget.
|
|
Args:
|
|
x(bool): Show grid on the x-axis.
|
|
y(bool): Show grid on the y-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def lock_aspect_ratio(self, lock):
|
|
"""
|
|
Lock aspect ratio.
|
|
Args:
|
|
lock(bool): True to lock, False to unlock.
|
|
"""
|
|
|
|
@rpc_call
|
|
def plot(self, data_x: "list | np.ndarray", data_y: "list | np.ndarray", **kwargs):
|
|
"""
|
|
Plot custom data on the plot widget. These data are not saved in config.
|
|
Args:
|
|
data_x(list|np.ndarray): x-axis data
|
|
data_y(list|np.ndarray): y-axis data
|
|
**kwargs: Keyword arguments for the plot.
|
|
"""
|
|
|
|
@rpc_call
|
|
def remove(self):
|
|
"""
|
|
Remove the plot widget from the figure.
|
|
"""
|
|
|
|
|
|
class BECWaveform(RPCBase):
|
|
@property
|
|
@rpc_call
|
|
def config_dict(self) -> "dict":
|
|
"""
|
|
Get the configuration of the widget.
|
|
Returns:
|
|
dict: The configuration of the widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def add_curve_scan(
|
|
self,
|
|
x_name: "str",
|
|
y_name: "str",
|
|
z_name: "Optional[str]" = None,
|
|
x_entry: "Optional[str]" = None,
|
|
y_entry: "Optional[str]" = None,
|
|
z_entry: "Optional[str]" = None,
|
|
color: "Optional[str]" = None,
|
|
color_map_z: "Optional[str]" = "plasma",
|
|
label: "Optional[str]" = None,
|
|
validate_bec: "bool" = True,
|
|
**kwargs
|
|
) -> "BECCurve":
|
|
"""
|
|
Add a curve to the plot widget from the scan segment.
|
|
Args:
|
|
x_name(str): Name of the x signal.
|
|
x_entry(str): Entry of the x signal.
|
|
y_name(str): Name of the y signal.
|
|
y_entry(str): Entry of the y signal.
|
|
z_name(str): Name of the z signal.
|
|
z_entry(str): Entry of the z signal.
|
|
color(str, optional): Color of the curve. Defaults to None.
|
|
color_map_z(str): The color map to use for the z-axis.
|
|
label(str, optional): Label of the curve. Defaults to None.
|
|
**kwargs: Additional keyword arguments for the curve configuration.
|
|
|
|
Returns:
|
|
BECCurve: The curve object.
|
|
"""
|
|
|
|
@rpc_call
|
|
def add_curve_custom(
|
|
self,
|
|
x: "list | np.ndarray",
|
|
y: "list | np.ndarray",
|
|
label: "str" = None,
|
|
color: "str" = None,
|
|
**kwargs
|
|
) -> "BECCurve":
|
|
"""
|
|
Add a custom data curve to the plot widget.
|
|
Args:
|
|
x(list|np.ndarray): X data of the curve.
|
|
y(list|np.ndarray): Y data of the curve.
|
|
label(str, optional): Label of the curve. Defaults to None.
|
|
color(str, optional): Color of the curve. Defaults to None.
|
|
**kwargs: Additional keyword arguments for the curve configuration.
|
|
|
|
Returns:
|
|
BECCurve: The curve object.
|
|
"""
|
|
|
|
@rpc_call
|
|
def remove_curve(self, *identifiers):
|
|
"""
|
|
Remove a curve from the plot widget.
|
|
Args:
|
|
*identifiers: Identifier of the curve to be removed. Can be either an integer (index) or a string (curve_id).
|
|
"""
|
|
|
|
@rpc_call
|
|
def scan_history(self, scan_index: "int" = None, scan_id: "str" = None):
|
|
"""
|
|
Update the scan curves with the data from the scan storage.
|
|
Provide only one of scan_id or scan_index.
|
|
Args:
|
|
scan_id(str, optional): ScanID of the scan to be updated. Defaults to None.
|
|
scan_index(int, optional): Index of the scan to be updated. Defaults to None.
|
|
"""
|
|
|
|
@property
|
|
@rpc_call
|
|
def curves(self) -> "list[BECCurve]":
|
|
"""
|
|
Get the curves of the plot widget as a list
|
|
Returns:
|
|
list: List of curves.
|
|
"""
|
|
|
|
@rpc_call
|
|
def get_curve(self, identifier) -> "BECCurve":
|
|
"""
|
|
Get the curve by its index or ID.
|
|
Args:
|
|
identifier(int|str): Identifier of the curve. Can be either an integer (index) or a string (curve_id).
|
|
Returns:
|
|
BECCurve: The curve object.
|
|
"""
|
|
|
|
@rpc_call
|
|
def get_curve_config(self, curve_id: "str", dict_output: "bool" = True) -> "CurveConfig | dict":
|
|
"""
|
|
Get the configuration of a curve by its ID.
|
|
Args:
|
|
curve_id(str): ID of the curve.
|
|
Returns:
|
|
CurveConfig|dict: Configuration of the curve.
|
|
"""
|
|
|
|
@rpc_call
|
|
def apply_config(self, config: "dict | WidgetConfig", replot_last_scan: "bool" = False):
|
|
"""
|
|
Apply the configuration to the 1D waveform widget.
|
|
Args:
|
|
config(dict|WidgetConfig): Configuration settings.
|
|
replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
|
|
"""
|
|
|
|
@rpc_call
|
|
def get_all_data(self, output: "Literal['dict', 'pandas']" = "dict") -> "dict | pd.DataFrame":
|
|
"""
|
|
Extract all curve data into a dictionary or a pandas DataFrame.
|
|
Args:
|
|
output (Literal["dict", "pandas"]): Format of the output data.
|
|
Returns:
|
|
dict | pd.DataFrame: Data of all curves in the specified format.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set(self, **kwargs) -> "None":
|
|
"""
|
|
Set the properties of the plot widget.
|
|
Args:
|
|
**kwargs: Keyword arguments for the properties to be set.
|
|
Possible properties:
|
|
- title: str
|
|
- x_label: str
|
|
- y_label: str
|
|
- x_scale: Literal["linear", "log"]
|
|
- y_scale: Literal["linear", "log"]
|
|
- x_lim: tuple
|
|
- y_lim: tuple
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_title(self, title: "str"):
|
|
"""
|
|
Set the title of the plot widget.
|
|
Args:
|
|
title(str): Title of the plot widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_x_label(self, label: "str"):
|
|
"""
|
|
Set the label of the x-axis.
|
|
Args:
|
|
label(str): Label of the x-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_y_label(self, label: "str"):
|
|
"""
|
|
Set the label of the y-axis.
|
|
Args:
|
|
label(str): Label of the y-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_x_scale(self, scale: "Literal['linear', 'log']" = "linear"):
|
|
"""
|
|
Set the scale of the x-axis.
|
|
Args:
|
|
scale(Literal["linear", "log"]): Scale of the x-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_y_scale(self, scale: "Literal['linear', 'log']" = "linear"):
|
|
"""
|
|
Set the scale of the y-axis.
|
|
Args:
|
|
scale(Literal["linear", "log"]): Scale of the y-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_x_lim(self, *args) -> "None":
|
|
"""
|
|
Set the limits of the x-axis. This method can accept either two separate arguments
|
|
for the minimum and maximum x-axis values, or a single tuple containing both limits.
|
|
|
|
Usage:
|
|
set_x_lim(x_min, x_max)
|
|
set_x_lim((x_min, x_max))
|
|
|
|
Args:
|
|
*args: A variable number of arguments. Can be two integers (x_min and x_max)
|
|
or a single tuple with two integers.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_y_lim(self, *args) -> "None":
|
|
"""
|
|
Set the limits of the y-axis. This method can accept either two separate arguments
|
|
for the minimum and maximum y-axis values, or a single tuple containing both limits.
|
|
|
|
Usage:
|
|
set_y_lim(y_min, y_max)
|
|
set_y_lim((y_min, y_max))
|
|
|
|
Args:
|
|
*args: A variable number of arguments. Can be two integers (y_min and y_max)
|
|
or a single tuple with two integers.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_grid(self, x: "bool" = False, y: "bool" = False):
|
|
"""
|
|
Set the grid of the plot widget.
|
|
Args:
|
|
x(bool): Show grid on the x-axis.
|
|
y(bool): Show grid on the y-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def lock_aspect_ratio(self, lock):
|
|
"""
|
|
Lock aspect ratio.
|
|
Args:
|
|
lock(bool): True to lock, False to unlock.
|
|
"""
|
|
|
|
@rpc_call
|
|
def plot(self, data_x: "list | np.ndarray", data_y: "list | np.ndarray", **kwargs):
|
|
"""
|
|
Plot custom data on the plot widget. These data are not saved in config.
|
|
Args:
|
|
data_x(list|np.ndarray): x-axis data
|
|
data_y(list|np.ndarray): y-axis data
|
|
**kwargs: Keyword arguments for the plot.
|
|
"""
|
|
|
|
@rpc_call
|
|
def remove(self):
|
|
"""
|
|
Remove the plot widget from the figure.
|
|
"""
|
|
|
|
|
|
class BECFigure(RPCBase, BECFigureClientMixin):
|
|
@property
|
|
@rpc_call
|
|
def config_dict(self) -> "dict":
|
|
"""
|
|
Get the configuration of the widget.
|
|
Returns:
|
|
dict: The configuration of the widget.
|
|
"""
|
|
|
|
@property
|
|
@rpc_call
|
|
def axes(self) -> "list[BECPlotBase]":
|
|
"""
|
|
Access all widget in BECFigure as a list
|
|
Returns:
|
|
list[BECPlotBase]: List of all widgets in the figure.
|
|
"""
|
|
|
|
@property
|
|
@rpc_call
|
|
def widgets(self) -> "dict":
|
|
"""
|
|
None
|
|
"""
|
|
|
|
@rpc_call
|
|
def add_plot(
|
|
self,
|
|
x_name: "str" = None,
|
|
y_name: "str" = None,
|
|
z_name: "str" = None,
|
|
x_entry: "str" = None,
|
|
y_entry: "str" = None,
|
|
z_entry: "str" = None,
|
|
x: "list | np.ndarray" = None,
|
|
y: "list | np.ndarray" = None,
|
|
color: "Optional[str]" = None,
|
|
color_map_z: "Optional[str]" = "plasma",
|
|
label: "Optional[str]" = None,
|
|
validate: "bool" = True,
|
|
row: "int" = None,
|
|
col: "int" = None,
|
|
config=None,
|
|
**axis_kwargs
|
|
) -> "BECWaveform":
|
|
"""
|
|
Add a Waveform1D plot to the figure at the specified position.
|
|
Args:
|
|
widget_id(str): The unique identifier of the widget. If not provided, a unique ID will be generated.
|
|
row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
|
|
col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
|
|
config(dict): Additional configuration for the widget.
|
|
**axis_kwargs(dict): Additional axis properties to set on the widget after creation.
|
|
"""
|
|
|
|
@rpc_call
|
|
def add_image(
|
|
self,
|
|
monitor: "str" = None,
|
|
color_bar: "Literal['simple', 'full']" = "full",
|
|
color_map: "str" = "magma",
|
|
data: "np.ndarray" = None,
|
|
vrange: "tuple[float, float]" = None,
|
|
row: "int" = None,
|
|
col: "int" = None,
|
|
config=None,
|
|
**axis_kwargs
|
|
) -> "BECImageShow":
|
|
"""
|
|
Add an image to the figure at the specified position.
|
|
Args:
|
|
monitor(str): The name of the monitor to display.
|
|
color_bar(Literal["simple","full"]): The type of color bar to display.
|
|
color_map(str): The color map to use for the image.
|
|
data(np.ndarray): Custom data to display.
|
|
vrange(tuple[float, float]): The range of values to display.
|
|
row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
|
|
col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
|
|
config(dict): Additional configuration for the widget.
|
|
**axis_kwargs: Additional axis properties to set on the widget after creation.
|
|
|
|
Returns:
|
|
BECImageShow: The image widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def add_motor_map(
|
|
self,
|
|
motor_x: "str" = None,
|
|
motor_y: "str" = None,
|
|
row: "int" = None,
|
|
col: "int" = None,
|
|
config=None,
|
|
**axis_kwargs
|
|
) -> "BECMotorMap":
|
|
"""
|
|
Args:
|
|
motor_x(str): The name of the motor for the X axis.
|
|
motor_y(str): The name of the motor for the Y axis.
|
|
row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
|
|
col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
|
|
config(dict): Additional configuration for the widget.
|
|
**axis_kwargs:
|
|
|
|
Returns:
|
|
BECMotorMap: The motor map widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def plot(
|
|
self,
|
|
x_name: "str" = None,
|
|
y_name: "str" = None,
|
|
z_name: "str" = None,
|
|
x_entry: "str" = None,
|
|
y_entry: "str" = None,
|
|
z_entry: "str" = None,
|
|
x: "list | np.ndarray" = None,
|
|
y: "list | np.ndarray" = None,
|
|
color: "Optional[str]" = None,
|
|
color_map_z: "Optional[str]" = "plasma",
|
|
label: "Optional[str]" = None,
|
|
validate: "bool" = True,
|
|
**axis_kwargs
|
|
) -> "BECWaveform":
|
|
"""
|
|
Add a 1D waveform plot to the figure. Always access the first waveform widget in the figure.
|
|
Args:
|
|
x_name(str): The name of the device for the x-axis.
|
|
y_name(str): The name of the device for the y-axis.
|
|
z_name(str): The name of the device for the z-axis.
|
|
x_entry(str): The name of the entry for the x-axis.
|
|
y_entry(str): The name of the entry for the y-axis.
|
|
z_entry(str): The name of the entry for the z-axis.
|
|
x(list | np.ndarray): Custom x data to plot.
|
|
y(list | np.ndarray): Custom y data to plot.
|
|
color(str): The color of the curve.
|
|
color_map_z(str): The color map to use for the z-axis.
|
|
label(str): The label of the curve.
|
|
validate(bool): If True, validate the device names and entries.
|
|
**axis_kwargs: Additional axis properties to set on the widget after creation.
|
|
|
|
Returns:
|
|
BECWaveform: The waveform plot widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def image(
|
|
self,
|
|
monitor: "str" = None,
|
|
color_bar: "Literal['simple', 'full']" = "full",
|
|
color_map: "str" = "magma",
|
|
data: "np.ndarray" = None,
|
|
vrange: "tuple[float, float]" = None,
|
|
**axis_kwargs
|
|
) -> "BECImageShow":
|
|
"""
|
|
Add an image to the figure. Always access the first image widget in the figure.
|
|
Args:
|
|
monitor(str): The name of the monitor to display.
|
|
color_bar(Literal["simple","full"]): The type of color bar to display.
|
|
color_map(str): The color map to use for the image.
|
|
data(np.ndarray): Custom data to display.
|
|
vrange(tuple[float, float]): The range of values to display.
|
|
**axis_kwargs: Additional axis properties to set on the widget after creation.
|
|
|
|
Returns:
|
|
BECImageShow: The image widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def motor_map(
|
|
self, motor_x: "str" = None, motor_y: "str" = None, **axis_kwargs
|
|
) -> "BECMotorMap":
|
|
"""
|
|
Add a motor map to the figure. Always access the first motor map widget in the figure.
|
|
Args:
|
|
motor_x(str): The name of the motor for the X axis.
|
|
motor_y(str): The name of the motor for the Y axis.
|
|
**axis_kwargs: Additional axis properties to set on the widget after creation.
|
|
|
|
Returns:
|
|
BECMotorMap: The motor map widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def remove(
|
|
self,
|
|
row: "int" = None,
|
|
col: "int" = None,
|
|
widget_id: "str" = None,
|
|
coordinates: "tuple[int, int]" = None,
|
|
) -> "None":
|
|
"""
|
|
Remove a widget from the figure. Can be removed by its unique identifier or by its coordinates.
|
|
Args:
|
|
row(int): The row coordinate of the widget to remove.
|
|
col(int): The column coordinate of the widget to remove.
|
|
widget_id(str): The unique identifier of the widget to remove.
|
|
coordinates(tuple[int, int], optional): The coordinates of the widget to remove.
|
|
"""
|
|
|
|
@rpc_call
|
|
def change_layout(self, max_columns=None, max_rows=None):
|
|
"""
|
|
Reshuffle the layout of the figure to adjust to a new number of max_columns or max_rows.
|
|
If both max_columns and max_rows are provided, max_rows is ignored.
|
|
|
|
Args:
|
|
max_columns (Optional[int]): The new maximum number of columns in the figure.
|
|
max_rows (Optional[int]): The new maximum number of rows in the figure.
|
|
"""
|
|
|
|
@rpc_call
|
|
def change_theme(self, theme: "Literal['dark', 'light']") -> "None":
|
|
"""
|
|
Change the theme of the figure widget.
|
|
Args:
|
|
theme(Literal["dark","light"]): The theme to set for the figure widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def clear_all(self):
|
|
"""
|
|
Clear all widgets from the figure and reset to default state
|
|
"""
|
|
|
|
|
|
class BECCurve(RPCBase):
|
|
@property
|
|
@rpc_call
|
|
def config_dict(self) -> "dict":
|
|
"""
|
|
Get the configuration of the widget.
|
|
Returns:
|
|
dict: The configuration of the widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set(self, **kwargs):
|
|
"""
|
|
Set the properties of the curve.
|
|
Args:
|
|
**kwargs: Keyword arguments for the properties to be set.
|
|
Possible properties:
|
|
- color: str
|
|
- symbol: str
|
|
- symbol_color: str
|
|
- symbol_size: int
|
|
- pen_width: int
|
|
- pen_style: Literal["solid", "dash", "dot", "dashdot"]
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_data(self, x, y):
|
|
"""
|
|
None
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_color(self, color: "str", symbol_color: "Optional[str]" = None):
|
|
"""
|
|
Change the color of the curve.
|
|
Args:
|
|
color(str): Color of the curve.
|
|
symbol_color(str, optional): Color of the symbol. Defaults to None.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_colormap(self, colormap: "str"):
|
|
"""
|
|
Set the colormap for the scatter plot z gradient.
|
|
Args:
|
|
colormap(str): Colormap for the scatter plot.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_symbol(self, symbol: "str"):
|
|
"""
|
|
Change the symbol of the curve.
|
|
Args:
|
|
symbol(str): Symbol of the curve.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_symbol_color(self, symbol_color: "str"):
|
|
"""
|
|
Change the symbol color of the curve.
|
|
Args:
|
|
symbol_color(str): Color of the symbol.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_symbol_size(self, symbol_size: "int"):
|
|
"""
|
|
Change the symbol size of the curve.
|
|
Args:
|
|
symbol_size(int): Size of the symbol.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_pen_width(self, pen_width: "int"):
|
|
"""
|
|
Change the pen width of the curve.
|
|
Args:
|
|
pen_width(int): Width of the pen.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_pen_style(self, pen_style: "Literal['solid', 'dash', 'dot', 'dashdot']"):
|
|
"""
|
|
Change the pen style of the curve.
|
|
Args:
|
|
pen_style(Literal["solid", "dash", "dot", "dashdot"]): Style of the pen.
|
|
"""
|
|
|
|
@rpc_call
|
|
def get_data(self) -> "tuple[np.ndarray, np.ndarray]":
|
|
"""
|
|
Get the data of the curve.
|
|
Returns:
|
|
tuple[np.ndarray,np.ndarray]: X and Y data of the curve.
|
|
"""
|
|
|
|
|
|
class BECImageShow(RPCBase):
|
|
@property
|
|
@rpc_call
|
|
def config_dict(self) -> "dict":
|
|
"""
|
|
Get the configuration of the widget.
|
|
Returns:
|
|
dict: The configuration of the widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def add_image_by_config(self, config: "ImageItemConfig | dict") -> "BECImageItem":
|
|
"""
|
|
Add an image to the widget by configuration.
|
|
Args:
|
|
config(ImageItemConfig|dict): The configuration of the image.
|
|
|
|
Returns:
|
|
BECImageItem: The image object.
|
|
"""
|
|
|
|
@rpc_call
|
|
def get_image_config(self, image_id, dict_output: "bool" = True) -> "ImageItemConfig | dict":
|
|
"""
|
|
Get the configuration of the image.
|
|
Args:
|
|
image_id(str): The ID of the image.
|
|
dict_output(bool): Whether to return the configuration as a dictionary. Defaults to True.
|
|
|
|
Returns:
|
|
ImageItemConfig|dict: The configuration of the image.
|
|
"""
|
|
|
|
@rpc_call
|
|
def get_image_dict(self) -> "dict[str, dict[str, BECImageItem]]":
|
|
"""
|
|
Get all images.
|
|
Returns:
|
|
dict[str, dict[str, BECImageItem]]: The dictionary of images.
|
|
"""
|
|
|
|
@rpc_call
|
|
def add_monitor_image(
|
|
self,
|
|
monitor: "str",
|
|
color_map: "Optional[str]" = "magma",
|
|
color_bar: "Optional[Literal['simple', 'full']]" = "simple",
|
|
downsample: "Optional[bool]" = True,
|
|
opacity: "Optional[float]" = 1.0,
|
|
vrange: "Optional[tuple[int, int]]" = None,
|
|
**kwargs
|
|
) -> "BECImageItem":
|
|
"""
|
|
None
|
|
"""
|
|
|
|
@rpc_call
|
|
def add_custom_image(
|
|
self,
|
|
name: "str",
|
|
data: "Optional[np.ndarray]" = None,
|
|
color_map: "Optional[str]" = "magma",
|
|
color_bar: "Optional[Literal['simple', 'full']]" = "simple",
|
|
downsample: "Optional[bool]" = True,
|
|
opacity: "Optional[float]" = 1.0,
|
|
vrange: "Optional[tuple[int, int]]" = None,
|
|
**kwargs
|
|
):
|
|
"""
|
|
None
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_vrange(self, vmin: "float", vmax: "float", name: "str" = None):
|
|
"""
|
|
Set the range of the color bar.
|
|
If name is not specified, then set vrange for all images.
|
|
Args:
|
|
vmin(float): Minimum value of the color bar.
|
|
vmax(float): Maximum value of the color bar.
|
|
name(str): The name of the image. If None, apply to all images.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_color_map(self, cmap: "str", name: "str" = None):
|
|
"""
|
|
Set the color map of the image.
|
|
If name is not specified, then set color map for all images.
|
|
Args:
|
|
cmap(str): The color map of the image.
|
|
name(str): The name of the image. If None, apply to all images.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_autorange(self, enable: "bool" = False, name: "str" = None):
|
|
"""
|
|
Set the autoscale of the image.
|
|
Args:
|
|
enable(bool): Whether to autoscale the color bar.
|
|
name(str): The name of the image. If None, apply to all images.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_monitor(self, monitor: "str", name: "str" = None):
|
|
"""
|
|
Set the monitor of the image.
|
|
If name is not specified, then set monitor for all images.
|
|
Args:
|
|
monitor(str): The name of the monitor.
|
|
name(str): The name of the image. If None, apply to all images.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_processing(self, name: "str" = None, **kwargs):
|
|
"""
|
|
Set the post processing of the image.
|
|
If name is not specified, then set post processing for all images.
|
|
Args:
|
|
name(str): The name of the image. If None, apply to all images.
|
|
**kwargs: Keyword arguments for the properties to be set.
|
|
Possible properties:
|
|
- fft: bool
|
|
- log: bool
|
|
- rot: int
|
|
- transpose: bool
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_image_properties(self, name: "str" = None, **kwargs):
|
|
"""
|
|
Set the properties of the image.
|
|
Args:
|
|
name(str): The name of the image. If None, apply to all images.
|
|
**kwargs: Keyword arguments for the properties to be set.
|
|
Possible properties:
|
|
- downsample: bool
|
|
- color_map: str
|
|
- monitor: str
|
|
- opacity: float
|
|
- vrange: tuple[int,int]
|
|
- fft: bool
|
|
- log: bool
|
|
- rot: int
|
|
- transpose: bool
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_fft(self, enable: "bool" = False, name: "str" = None):
|
|
"""
|
|
Set the FFT of the image.
|
|
If name is not specified, then set FFT for all images.
|
|
Args:
|
|
enable(bool): Whether to perform FFT on the monitor data.
|
|
name(str): The name of the image. If None, apply to all images.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_log(self, enable: "bool" = False, name: "str" = None):
|
|
"""
|
|
Set the log of the image.
|
|
If name is not specified, then set log for all images.
|
|
Args:
|
|
enable(bool): Whether to perform log on the monitor data.
|
|
name(str): The name of the image. If None, apply to all images.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_rotation(self, deg_90: "int" = 0, name: "str" = None):
|
|
"""
|
|
Set the rotation of the image.
|
|
If name is not specified, then set rotation for all images.
|
|
Args:
|
|
deg_90(int): The rotation angle of the monitor data before displaying.
|
|
name(str): The name of the image. If None, apply to all images.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_transpose(self, enable: "bool" = False, name: "str" = None):
|
|
"""
|
|
Set the transpose of the image.
|
|
If name is not specified, then set transpose for all images.
|
|
Args:
|
|
enable(bool): Whether to transpose the monitor data before displaying.
|
|
name(str): The name of the image. If None, apply to all images.
|
|
"""
|
|
|
|
@rpc_call
|
|
def toggle_threading(self, use_threading: "bool"):
|
|
"""
|
|
Toggle threading for the widgets postprocessing and updating.
|
|
Args:
|
|
use_threading(bool): Whether to use threading.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set(self, **kwargs) -> "None":
|
|
"""
|
|
Set the properties of the plot widget.
|
|
Args:
|
|
**kwargs: Keyword arguments for the properties to be set.
|
|
Possible properties:
|
|
- title: str
|
|
- x_label: str
|
|
- y_label: str
|
|
- x_scale: Literal["linear", "log"]
|
|
- y_scale: Literal["linear", "log"]
|
|
- x_lim: tuple
|
|
- y_lim: tuple
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_title(self, title: "str"):
|
|
"""
|
|
Set the title of the plot widget.
|
|
Args:
|
|
title(str): Title of the plot widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_x_label(self, label: "str"):
|
|
"""
|
|
Set the label of the x-axis.
|
|
Args:
|
|
label(str): Label of the x-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_y_label(self, label: "str"):
|
|
"""
|
|
Set the label of the y-axis.
|
|
Args:
|
|
label(str): Label of the y-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_x_scale(self, scale: "Literal['linear', 'log']" = "linear"):
|
|
"""
|
|
Set the scale of the x-axis.
|
|
Args:
|
|
scale(Literal["linear", "log"]): Scale of the x-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_y_scale(self, scale: "Literal['linear', 'log']" = "linear"):
|
|
"""
|
|
Set the scale of the y-axis.
|
|
Args:
|
|
scale(Literal["linear", "log"]): Scale of the y-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_x_lim(self, *args) -> "None":
|
|
"""
|
|
Set the limits of the x-axis. This method can accept either two separate arguments
|
|
for the minimum and maximum x-axis values, or a single tuple containing both limits.
|
|
|
|
Usage:
|
|
set_x_lim(x_min, x_max)
|
|
set_x_lim((x_min, x_max))
|
|
|
|
Args:
|
|
*args: A variable number of arguments. Can be two integers (x_min and x_max)
|
|
or a single tuple with two integers.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_y_lim(self, *args) -> "None":
|
|
"""
|
|
Set the limits of the y-axis. This method can accept either two separate arguments
|
|
for the minimum and maximum y-axis values, or a single tuple containing both limits.
|
|
|
|
Usage:
|
|
set_y_lim(y_min, y_max)
|
|
set_y_lim((y_min, y_max))
|
|
|
|
Args:
|
|
*args: A variable number of arguments. Can be two integers (y_min and y_max)
|
|
or a single tuple with two integers.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_grid(self, x: "bool" = False, y: "bool" = False):
|
|
"""
|
|
Set the grid of the plot widget.
|
|
Args:
|
|
x(bool): Show grid on the x-axis.
|
|
y(bool): Show grid on the y-axis.
|
|
"""
|
|
|
|
@rpc_call
|
|
def lock_aspect_ratio(self, lock):
|
|
"""
|
|
Lock aspect ratio.
|
|
Args:
|
|
lock(bool): True to lock, False to unlock.
|
|
"""
|
|
|
|
@rpc_call
|
|
def plot(self, data_x: "list | np.ndarray", data_y: "list | np.ndarray", **kwargs):
|
|
"""
|
|
Plot custom data on the plot widget. These data are not saved in config.
|
|
Args:
|
|
data_x(list|np.ndarray): x-axis data
|
|
data_y(list|np.ndarray): y-axis data
|
|
**kwargs: Keyword arguments for the plot.
|
|
"""
|
|
|
|
@rpc_call
|
|
def remove(self):
|
|
"""
|
|
Remove the plot widget from the figure.
|
|
"""
|
|
|
|
@property
|
|
@rpc_call
|
|
def images(self) -> "list[BECImageItem]":
|
|
"""
|
|
Get the list of images.
|
|
Returns:
|
|
list[BECImageItem]: The list of images.
|
|
"""
|
|
|
|
|
|
class BECConnector(RPCBase):
|
|
@property
|
|
@rpc_call
|
|
def config_dict(self) -> "dict":
|
|
"""
|
|
Get the configuration of the widget.
|
|
Returns:
|
|
dict: The configuration of the widget.
|
|
"""
|
|
|
|
|
|
class BECImageItem(RPCBase):
|
|
@property
|
|
@rpc_call
|
|
def config_dict(self) -> "dict":
|
|
"""
|
|
Get the configuration of the widget.
|
|
Returns:
|
|
dict: The configuration of the widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set(self, **kwargs):
|
|
"""
|
|
Set the properties of the image.
|
|
Args:
|
|
**kwargs: Keyword arguments for the properties to be set.
|
|
Possible properties:
|
|
- downsample
|
|
- color_map
|
|
- monitor
|
|
- opacity
|
|
- vrange
|
|
- fft
|
|
- log
|
|
- rot
|
|
- transpose
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_fft(self, enable: "bool" = False):
|
|
"""
|
|
Set the FFT of the image.
|
|
Args:
|
|
enable(bool): Whether to perform FFT on the monitor data.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_log(self, enable: "bool" = False):
|
|
"""
|
|
Set the log of the image.
|
|
Args:
|
|
enable(bool): Whether to perform log on the monitor data.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_rotation(self, deg_90: "int" = 0):
|
|
"""
|
|
Set the rotation of the image.
|
|
Args:
|
|
deg_90(int): The rotation angle of the monitor data before displaying.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_transpose(self, enable: "bool" = False):
|
|
"""
|
|
Set the transpose of the image.
|
|
Args:
|
|
enable(bool): Whether to transpose the image.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_opacity(self, opacity: "float" = 1.0):
|
|
"""
|
|
Set the opacity of the image.
|
|
Args:
|
|
opacity(float): The opacity of the image.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_autorange(self, autorange: "bool" = False):
|
|
"""
|
|
Set the autorange of the color bar.
|
|
Args:
|
|
autorange(bool): Whether to autorange the color bar.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_color_map(self, cmap: "str" = "magma"):
|
|
"""
|
|
Set the color map of the image.
|
|
Args:
|
|
cmap(str): The color map of the image.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_auto_downsample(self, auto: "bool" = True):
|
|
"""
|
|
Set the auto downsample of the image.
|
|
Args:
|
|
auto(bool): Whether to downsample the image.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_monitor(self, monitor: "str"):
|
|
"""
|
|
Set the monitor of the image.
|
|
Args:
|
|
monitor(str): The name of the monitor.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_vrange(
|
|
self, vmin: "float" = None, vmax: "float" = None, vrange: "tuple[int, int]" = None
|
|
):
|
|
"""
|
|
Set the range of the color bar.
|
|
Args:
|
|
vmin(float): Minimum value of the color bar.
|
|
vmax(float): Maximum value of the color bar.
|
|
"""
|
|
|
|
@rpc_call
|
|
def get_data(self) -> "np.ndarray":
|
|
"""
|
|
Get the data of the image.
|
|
Returns:
|
|
np.ndarray: The data of the image.
|
|
"""
|
|
|
|
|
|
class BECMotorMap(RPCBase):
|
|
@property
|
|
@rpc_call
|
|
def config_dict(self) -> "dict":
|
|
"""
|
|
Get the configuration of the widget.
|
|
Returns:
|
|
dict: The configuration of the widget.
|
|
"""
|
|
|
|
@rpc_call
|
|
def change_motors(
|
|
self,
|
|
motor_x: "str",
|
|
motor_y: "str",
|
|
motor_x_entry: "str" = None,
|
|
motor_y_entry: "str" = None,
|
|
validate_bec: "bool" = True,
|
|
) -> "None":
|
|
"""
|
|
Change the active motors for the plot.
|
|
Args:
|
|
motor_x(str): Motor name for the X axis.
|
|
motor_y(str): Motor name for the Y axis.
|
|
motor_x_entry(str): Motor entry for the X axis.
|
|
motor_y_entry(str): Motor entry for the Y axis.
|
|
validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_max_points(self, max_points: "int") -> "None":
|
|
"""
|
|
Set the maximum number of points to display.
|
|
Args:
|
|
max_points(int): Maximum number of points to display.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_precision(self, precision: "int") -> "None":
|
|
"""
|
|
Set the decimal precision of the motor position.
|
|
Args:
|
|
precision(int): Decimal precision of the motor position.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_num_dim_points(self, num_dim_points: "int") -> "None":
|
|
"""
|
|
Set the number of dim points for the motor map.
|
|
Args:
|
|
num_dim_points(int): Number of dim points.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_background_value(self, background_value: "int") -> "None":
|
|
"""
|
|
Set the background value of the motor map.
|
|
Args:
|
|
background_value(int): Background value of the motor map.
|
|
"""
|
|
|
|
@rpc_call
|
|
def set_scatter_size(self, scatter_size: "int") -> "None":
|
|
"""
|
|
Set the scatter size of the motor map plot.
|
|
Args:
|
|
scatter_size(int): Size of the scatter points.
|
|
"""
|
|
|
|
@rpc_call
|
|
def get_data(self) -> "dict":
|
|
"""
|
|
Get the data of the motor map.
|
|
Returns:
|
|
dict: Data of the motor map.
|
|
"""
|