### Install Package

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Install the package in editable mode to make the custom Taurus GUI extensions available.

```bash
pip install -e .
```

--------------------------------

### Start TangoTest with Pixi

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Starts the TangoTest device server using a Pixi run command. This should be executed in a separate terminal from the Pixi database task.

```bash
pixi run start_tangotest
```

--------------------------------

### Create a Simple TaurusMainWindow Application

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/programmatic_gui.md

This snippet demonstrates how to create a basic Taurus application with a TaurusMainWindow and a TaurusForm as its central widget. It shows the initial setup and execution of the GUI.

```python
import sys
from taurus.qt.qtgui.panel import TaurusForm
from taurus.qt.qtgui.application import TaurusApplication
from taurus.qt.qtgui.container import TaurusMainWindow

app = TaurusApplication(sys.argv, app_name="Taurus Main Window Training")
mainwindow = TaurusMainWindow()

form = TaurusForm()
form.model = ["sys/tg_test/1/ampli", "sys/tg_test/1/double_scalar"]
mainwindow.setCentralWidget(form)

mainwindow.show()
sys.exit(app.exec_())
```

--------------------------------

### Taurus Installation and Logging

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_and_models.md

Check Taurus installation version, use custom logger with different log levels, and validate device/attribute names.

```python
import taurus

print(taurus.__version__)

taurus.info("Info 1")
taurus.debug("Debug 1")
taurus.setLogLevel(taurus.Debug)
taurus.info("Info 2")
taurus.debug("Debug 2")

print("-"*20)
taurus.info(f"sys/tg_test/1/ampli is valid? {taurus.isValidName('sys/tg_test/1/ampli')}")
taurus.info(f"sys/tg_test/1/ampli/1 is valid? {taurus.isValidName('sys/tg_test/1/ampli/1')}")
taurus.info(f"sys/tg_test/1/nonexistent is valid? {taurus.isValidName('sys/tg_test/1/nonexistent')} "
"-> The name is valid even if the attribute or device doesn't exist.")
```

--------------------------------

### Install Pixi Package Manager

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Downloads and installs the Pixi package manager using a curl script. Pixi is used for managing reproducible development environments.

```bash
curl -fsSL https://pixi.sh/install.sh | bash
```

--------------------------------

### Install taurus_pyqtgraph in Editable Mode

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Clones the taurus_pyqtgraph repository and installs it in editable mode using pip. This is for developing plotting widgets.

```bash
git clone https://gitlab.com/taurus-org/taurus_pyqtgraph.git
cd taurus_pyqtgraph
pip install -e .
```

--------------------------------

### Import and Get Tango Device with Taurus

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Import the Taurus library and obtain a generic TangoDevice instance. This is the default behavior before applying any extensions.

```python
import taurus

dev = taurus.Device("sys/tg_test/1")
```

--------------------------------

### Launch Taurus Form with Redis Scheme

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/custom_schemes.md

Command-line examples for launching a Taurus form directly with a Redis URI. Supports full URIs or shortened versions if configured.

```bash
taurus form redis://localhost:6379/0/my:test:key
```

```bash
taurus form redis:my:test:key
```

--------------------------------

### Start Pixi Local Tango Database

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Starts the Pixi database task, which typically launches PyDatabaseds 2 with an SQLite database. Use this if you do not have an existing Tango database on port 10000.

```bash
pixi run pydb
```

--------------------------------

### Install Taurus in Editable Mode

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Clones the Taurus repository from GitLab and installs it in editable mode using pip. This is for developing Taurus itself.

```bash
git clone https://gitlab.com/taurus-org/taurus.git
cd taurus
pip install -e .
```

--------------------------------

### Install Optional Tango Tools with Conda

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Installs optional tools like Jive, Tango-Astor, and SvgSynoptic2 into the current conda environment using conda-forge.

```bash
conda install -c conda-forge jive tango-astor svgsynoptic2
```

--------------------------------

### Runtime Formatter Configuration

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/custom_widgets_and_formatters.md

Configure formatters at runtime for a specific widget class or instance. This example shows setting a formatter for TaurusLabel instances.

```python
import sys
import taurus
from taurus.qt.qtgui.application import TaurusApplication
from taurus.qt.qtgui.display import TaurusLabel

TaurusLabel.FORMAT = taurus.core.tango.util.formatter.tangoFormatter

app = TaurusApplication(sys.argv)

w1 = TaurusLabel()
w2 = TaurusLabel()

w1.setModel("sys/tg_test/1/float_scalar")
w1.setFormat("{:2.3f}")
w2.setModel("sys/tg_test/1/float_scalar")

w1.show()
w2.show()
sys.exit(app.exec_())
```

--------------------------------

### Eval with Unit Awareness

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/eval_scheme.md

Demonstrates that eval expressions are unit-aware. This example performs a division of two quantities with units and converts the result to base units.

```bash
taurus form "eval:({eval:Q('3N')}/{eval:Q('2kg')}).to_base_units()"
```

--------------------------------

### Display Taurus Version

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Prints the installed Taurus version to the console. This is a basic smoke test to check if the Taurus CLI is accessible.

```bash
taurus
```

--------------------------------

### Create Write Widget (Relative Move)

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Implement a custom write widget for TaurusValue that allows relative movements. This example provides buttons for moving a device by a specified step value.

```python
class MyMotorWriteWidget(TaurusWidget):

    def __init__(self, parent=None):
        super().__init__(parent)

        layout = Qt.QHBoxLayout(self)
        layout.setSpacing(2)

        self.minus = Qt.QPushButton("◀")
        self.plus = Qt.QPushButton("▶")

        self.step = Qt.QDoubleSpinBox()
        self.step.setValue(1.0)

        layout.addWidget(self.minus)
        layout.addWidget(self.step)
        layout.addWidget(self.plus)

        self.minus.clicked.connect(lambda: self._move(-1))
        self.plus.clicked.connect(lambda: self._move(+1))

    def _move(self, sign):
        model = self.getModelObj()
        dev = model.getParentObj()

        pos = model.read().rvalue
        step = self.step.value()

        dev.move(pos + sign * step)
```

--------------------------------

### Combine Widgets into TaurusValue

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Integrate custom write and extra widgets into a TaurusValue. This example shows how to set the custom widget classes for a new TaurusValue implementation.

```python
from taurus.qt.qtgui.panel import TaurusValue


class MyMotorTaurusValue(TaurusValue):

    def __init__(self, parent=None):
        super().__init__(parent)

        self.setWriteWidgetClass(MyMotorWriteWidget)
        self.setExtraWidgetClass(MyMotorExtraWidget)
```

--------------------------------

### Configure Pixi Environment for Remote TANGO_HOST

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Example TOML configuration for Pixi, setting the TANGO_HOST environment variable to connect to a remote Tango database. Edit the 'pixi.toml' file to use this setting.

```toml
[activation.env]
TANGO_HOST = "remote-host:10000"
```

--------------------------------

### Use Redis Scheme in Taurus Label

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/custom_schemes.md

Example of using the Redis scheme within a TaurusLabel widget. This requires a running Taurus application and a Redis server.

```python
import sys
from taurus.external.qt import Qt
from taurus.qt.qtgui.application import TaurusApplication
from taurus.qt.qtgui.display import TaurusLabel
import taurus
app = TaurusApplication(sys.argv, cmd_line_parser=None,)
panel = Qt.QWidget()
layout = Qt.QHBoxLayout()
panel.setLayout(layout)
taurus.setLogLevel(0)

w1, w2, w3, w4 = TaurusLabel(panel), TaurusLabel(panel), TaurusLabel(panel)
layout.addWidget(w1)
layout.addWidget(w2)
layout.addWidget(w3)
w1.model = 'redis://localhost:6379/0/my:test:key'
w2.model = 'sys/tg_test/1/double_scalar'
w3.model = 'redis://localhost:6379/0/my:test:key#label'

panel.show()
sys.exit(app.exec_())
```

--------------------------------

### Writable Eval Attributes from Class Properties

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/eval_scheme.md

Demonstrates creating writable Taurus attributes by exposing Python class properties via the eval scheme. The example uses a simple class with a `foo` property that can be read and written.

```bash
taurus form 'eval:@c=mymod.MyClass()/c.foo'
```

--------------------------------

### Basic Eval Attribute Creation

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/eval_scheme.md

Demonstrates creating a Taurus attribute using a Python expression with the default evaluator. The `rand()` function is used as an example.

```python
import taurus

a = taurus.Attribute('eval:Q(rand(),"V")')
print(a.read().rvalue)
```

```python
print(a.getFullName())
```

--------------------------------

### Clone Pixi Workshop Repository

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Clones the Pixi workshop repository from GitLab. This repository contains setup scripts and configurations for a reproducible workshop environment, including a local Tango database.

```bash
git clone https://gitlab.com/alba-synchrotron/controls-section/icalepcs2025-workshop.git
cd icalepcs2025-workshop
```

--------------------------------

### Eval with Other Attributes

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/eval_scheme.md

Shows how to use values from other Taurus attributes within an eval expression. The example multiplies the value of a tango attribute by 10.

```bash
taurus form "tango:sys/tg_test/1/short_scalar" "eval:{tango:sys/tg_test/1/short_scalar}*10"
```

--------------------------------

### Create Conda Environment with Taurus Packages

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Use mamba or micromamba to create a new conda environment named 'taurus' with specified Python and Taurus-related packages. This command installs Python 3.12, Taurus, PyTango, PyQt, taurus-pyqtgraph, and tango-test.

```bash
mamba create -n taurus -c conda-forge python=3.12 taurus pytango pyqt taurus_pyqtgraph tango-test
```

```bash
micromamba create -n taurus -c conda-forge python=3.12 taurus pytango pyqt taurus_pyqtgraph tango-test
```

--------------------------------

### Create Extra Widget (Button)

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Define a custom widget that adds extra functionality, such as a button, to a TaurusValue. This example creates a button to move a motor to zero.

```python
from taurus.qt.qtgui.container import TaurusWidget
from taurus.external.qt import Qt


class MyMotorExtraWidget(TaurusWidget):

    def __init__(self, parent=None):
        super().__init__(parent)

        layout = Qt.QHBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)

        self.btn = Qt.QPushButton("Move zero")
        layout.addWidget(self.btn)

        self.btn.clicked.connect(self._move_zero)

    def _move_zero(self):
        dev = self.getModelObj().getParentObj()
        dev.move_to_zero()
```

--------------------------------

### Accessing Module Symbols with Eval

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/eval_scheme.md

Demonstrates using the `@module.*` syntax to access functions and variables from Python modules directly within eval expressions. Examples include `os.path.exists` and `datetime.date.today`.

```bash
taurus form 'eval:@os.*/path.exists("/home")'
```

```bash
taurus form 'eval:@os.path.*/exists("/home")'
```

```bash
taurus form  'eval:@datetime.*/date.today().isoformat()' \
            'eval:@os.*/environ["USER"]' \
            'eval:@os.path.*/getsize("/var/log/messages")<50'
```

--------------------------------

### Eval with OpenCV for Image Processing

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/eval_scheme.md

A practical example using eval to access members of a class instance from the OpenCV module (`cv2`). It captures video frames and processes the third channel of the image data.

```bash
taurus image --taurus-polling-period=100 'eval:@c=cv2.VideoCapture(0)/c.read()[1][...,2]'
```

--------------------------------

### Adding Noise to Image with eval

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/forms_and_widgets.md

Adds random noise to an image attribute using the 'eval' command. This example requires an image attribute and uses Python's random number generation.

```bash
taurus form eval:'img={tango:sys/tg_test/1/short_image_ro}; img + 10 * rand(*img.shape)'
```

--------------------------------

### Navigate to Project Directory

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/taurus_gui.md

After generating the GUI, change into the project directory to explore its structure and files.

```bash
cd DIRECTORY
```

--------------------------------

### Run Tango Device Server

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Execute the device server script to make the registered device available.

```bash
python MyMotorDS.py test
```

--------------------------------

### Run Final Test

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Execute a test script to verify the integration of the custom GUI widget by providing a device path as an argument.

```bash
python test_form.py my/motor/1/Position
```

--------------------------------

### Instantiating Class Instances with Eval

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/eval_scheme.md

Shows how to instantiate Python classes as evaluation devices using the `@name=module.Class(args)` syntax. This allows accessing instance members and methods.

```bash
taurus form 'eval:@b=foo.Bar(3)/b.even' 'eval:@b=foo.Bar(3)/b.odd' 'eval:@c=foo.Bar(8)/c.even'
```

--------------------------------

### Create Simple Programmatic TaurusGui

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/programmatic_gui.md

Creates a basic Taurus GUI application programmatically. Instantiate TaurusApplication, TaurusGui, and a widget, then add the widget as a panel to the GUI.

```python
import sys
from taurus.qt.qtgui.panel import TaurusForm
from taurus.qt.qtgui.application import TaurusApplication
from taurus.qt.qtgui.taurusgui import TaurusGui

app = TaurusApplication(sys.argv, app_name="Taurus Main Window Training")
taurusgui = TaurusGui()

form = TaurusForm()
form.model = ["sys/tg_test/1/ampli", "sys/tg_test/1/double_scalar"]
taurusgui.createPanel(form, 'Panel', floating=False, permanent=True)

taurusgui.show()
sys.exit(app.exec_())
```

--------------------------------

### Initialize Redis Scheme Plugin Module

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/custom_schemes.md

Ensure the plugin is importable by including necessary components in the plugin's __init__.py file.

```python
from .redisattribute import *
from .redisauthority import *
from .redisdevice import *
from .redisfactory import *
from .redisvalidator import *
```

--------------------------------

### Create Minimal Conda Environment and Activate

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Creates a minimal conda environment named 'taurus' with Python 3.12, Taurus, PyTango, and taurus_pyqtgraph, then activates it. This environment is sufficient for most exercises.

```bash
conda create -n taurus -c conda-forge \
  python=3.12 taurus pytango taurus_pyqtgraph

conda activate taurus
```

--------------------------------

### Register Redis Scheme Entry Point

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/custom_schemes.md

Configure the Redis scheme plugin by adding an entry point in your pyproject.toml file. The entry point name must match the module name.

```toml
[project.entry-points."taurus.core.schemes"]
taurus_redis_scheme = "taurus_redis_scheme"
```

--------------------------------

### Register GUI Item Factory Entry Point

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Configure the project's entry points in a TOML file to register a custom item factory for Taurus GUI. This makes the factory discoverable by Taurus.

```toml
[project.entry-points."taurus.form.item_factories"]
my_motor = "mypackage:my_motor_item_factory"
```

--------------------------------

### Generate a New Taurus GUI

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/taurus_gui.md

Use the `taurus newgui` command to launch a wizard for creating a new Taurus GUI project. Follow the prompts to configure project details, panels, and external applications.

```bash
taurus newgui
```

--------------------------------

### Test Custom Core Extension

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Register the custom extension and instantiate a Taurus device to verify its functionality.

```python
import taurus
from MyMotorDevice import registerExtensions, MyMotorDevice

registerExtensions()

dev = taurus.Device("my/motor/1")

print(type(dev))  # should be MyMotorDevice
print(dev.get_position())

dev.move(5)
```

--------------------------------

### Run the Taurus GUI Application

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/taurus_gui.md

Execute this command in the terminal to launch the generated Taurus GUI application.

```bash
mytaurusgui
```

--------------------------------

### Create TaurusGui Declarative PanelDescription

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/programmatic_gui.md

Defines panels for a Taurus GUI using PanelDescription objects. Import PanelDescription and create instances with classname and model attributes.

```python
from taurus.qt.qtgui.taurusgui.utils import PanelDescription

taurus_form = PanelDescription('TaurusForm1',
                                classname='taurus.qt.qtgui.panel:TaurusForm',
                                model='tango://localhost:10000/sys/tg_test/1/ampli')

taurus_trend = PanelDescription('TaurusTrend1',
                                 classname='taurus_pyqtgraph:TaurusTrend',
                                 model=['tango://localhost:10000/sys/tg_test/1/double_scalar', 'tango://localhost:10000/sys/tg_test/1/short_scalar'])
```

--------------------------------

### TaurusDevice: Device Abstraction and Interaction

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_and_models.md

Interact with a device using `TaurusDevice`, including reading attributes, executing commands, and handling commands with parameters. Demonstrates reading attributes via specific methods or as object attributes, and reading multiple attributes.

```python
import taurus
#taurus.setLogLevel(taurus.Debug)

device = taurus.Device("sys/tg_test/1")
device.info(device.state)

device.info("-"*20)

device.debug(device.read_attribute("State"))
device.info(device.read_attribute("State").value)
# Running command as function
device.SwitchStates()
device.info(device.read_attribute("State").value)
# Running command using command_inout
device.command_inout("SwitchStates")
device.info(device.read_attribute("State").value)

device.info("-"*20)

# Running commands with parameters
device.info(device.DevUShort(1))
device.info(device.command_inout("DevUShort", 2))

device.info("-"*20)

device.debug(device.read_attribute("short_scalar"))
# Read attribute using read_attribute
device.info(device.read_attribute("short_scalar").value)
# Read attribute as object attribute
device.info(device.short_scalar)
# Read multiple attributes with read_attributes
values = device.read_attributes(["short_scalar", "double_scalar", "boolean_scalar"])
device.debug(values)
device.info("Values read together:")
for value in values:
    device.info(f"     {value.name}: {value.value}")
```

--------------------------------

### Python Application for Synoptic Display

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/svg_synoptic.md

This Python code sets up a custom Taurus synoptic widget and loads an HTML file to display it. It requires a QApplication instance and configures the widget's model using a local HTML file.

```python
class ExampleSynopticWidget(TaurusSynopticWidget):

    """
    A custom subclass of the synoptic widget.
    """
    

def main():
    qapp = Qt.QApplication([])

    path = os.path.dirname(__file__)
    widget = ExampleSynopticWidget()
    widget.setModel(os.path.join(path, "index.html"))
    widget.resize(1000, 700)
    widget.show()
    qapp.exec_()
```

--------------------------------

### Explore Taurus Configuration

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/taurus_gui.md

Use this command to explore the configuration file where permanent panels are stored. The file is typically located in ~/.config/TAURUS/MyTaurusGUI.ini.

```bash
taurus config ~/.config/TAURUS/MyTaurusGUI.ini
```

--------------------------------

### Override Click Event Handler in Python

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/svg_synoptic.md

Override the `on_click` method to handle specific element clicks in the synoptic. This example detects clicks on an element named 'box' and prints a message, otherwise it calls the superclass method.

```python
    def on_click(self, kind, name):
        # Overriding the left click event handler
        if kind == "model" and name == "box":
            print("*** Box was clicked! ***")
        else:
            super().on_click(kind, name)
```

--------------------------------

### Basic Arithmetic with eval

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/forms_and_widgets.md

Demonstrates a simple arithmetic operation using the 'eval' command in Taurus. The result is displayed directly in the Taurus form.

```bash
taurus form eval:'2 + 2'
```

--------------------------------

### Create and Show a Simple TaurusForm Widget

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/programmatic_gui.md

Use this snippet to create a basic TaurusForm with specified models. It requires importing necessary Taurus and system modules.

```python
import sys
from taurus.qt.qtgui.application import TaurusApplication
from taurus.qt.qtgui.panel import TaurusForm

app = TaurusApplication(sys.argv)
form = TaurusForm()
form.model = ['sys/tg_test/1/ampli', 'sys/tg_test/1/double_scalar']

form.show()
sys.exit(app.exec_())
```

--------------------------------

### Get Full Device Name and Authority

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/custom_schemes.md

Retrieve the device name validator for a given scheme and use getNames to obtain the full name of a device. The authority can then be extracted from the full name using getUriGroups, even if it was not explicitly provided in the initial name.

```python
scheme = taurus.getSchemeFromName(name)
v = taurus.Factory(scheme).getDeviceNameValidator()
full_name, _, _ = v.getNames(name)   
# # and now, we can, e.g., find the authority from it 
# **even if it was not explicit in `name`**
auth = v.getUriGroups(full_name)['authority']
```

--------------------------------

### Execute Command on Device Click

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/svg_synoptic.md

This Python code snippet shows how to override the get_device_panel method to execute a specific command ('SwitchStates') on a 'TangoTest' device when it's clicked. It prevents the default device panel from opening.

```python
    def get_device_panel(self, device):
        dev = Device(device)
        proxy = dev.getDeviceProxy()
        info = proxy.info()
        if info.dev_class == "TangoTest":
            proxy.command_inout("SwitchStates")
        else:
            return super().get_device_panel(device)
```

--------------------------------

### Python Timer for Live Updates

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/svg_synoptic.md

Schedules a function to run periodically to update the synoptic display. Use this to implement dynamic visual feedback based on application state.

```python
def __init__(self, *args, **kwargs):
 super().__init__(*args, **kwargs)
 QtCore.QTimer.singleShot(1000, self._update)
 self.counter = 0

def _update(self):
 # Red every second time
 red = self.counter % 2
 classes = {"red": bool(red)}
 self.js.evaluate(f"synoptic.setClasses('model', 'star', {json.dumps(classes)})")
 self.counter += 1
 QtCore.QTimer.singleShot(1000, self._update)
```

--------------------------------

### Register Device with Tango Database

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Use the Tango Database API to register a new device with its class and server information.

```python
from tango import Database, DbDevInfo

db = Database()

dev = DbDevInfo()
dev.name = "my/motor/1"
dev._class = "MyMotor"
dev.server = "MyMotor/test"

db.add_device(dev)
```

--------------------------------

### Check TANGO_HOST Environment Variable

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Prints the current value of the TANGO_HOST environment variable to the console. This is used to verify the Tango database connection settings.

```bash
echo "$TANGO_HOST"
```

--------------------------------

### Ergonomic Device Interaction with Custom Methods

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Illustrates the desired outcome of using custom Taurus extensions, where device interactions are mapped to more intuitive Python methods.

```python
dev.move(10)
dev.get_position()
```

--------------------------------

### Create Custom TangoDevice Extension

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Define a custom device class inheriting from Taurus's TangoDevice to add specific methods and logic.

```python
from taurus import Factory
from taurus.core.tango import TangoDevice


class MyMotorDevice(TangoDevice):

    def move(self, pos):
        self.command_inout("Move", float(pos))

    def move_to_zero(self):
        self.move(0.0)

    def get_position(self):
        return self.read_attribute("Position").value


def registerExtensions():
    factory = Factory("tango")
    factory.registerDeviceClass("MyMotor", MyMotorDevice)
```

--------------------------------

### Create Basic TaurusForm

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Use TaurusForm to create a simple GUI panel that displays and allows interaction with a device attribute.

```python
from taurus.qt.qtgui.application import TaurusApplication
from taurus.qt.qtgui.panel import TaurusForm
import sys

app = TaurusApplication(sys.argv)

form = TaurusForm()
form.setModel(["my/motor/1/Position"])
form.show()

app.exec_()
```

--------------------------------

### Create Taurus Device and Attribute Objects

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_and_models.md

Use helper functions to create Taurus Device and Attribute objects. These are the most common way to interact with Taurus models.

```python
import taurus

dev = taurus.Device("sys/tg_test/1")
attr = taurus.Attribute("sys/tg_test/1/double_scalar")
```

--------------------------------

### Command-line Default Formatter

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/custom_widgets_and_formatters.md

Change the default formatter for widgets in a launched application using the command line.

```bash
taurus form sys/tg_test/1/float_scalar --default-formatter="{:2.3f}"
```

--------------------------------

### Standalone Synoptic Widget Application

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/svg_synoptic.md

Defines a custom SynopticWidget and launches a PyQt5 application to display it. Ensure the HTML file path is absolute.

```python
"""
A simple example that shows how to use the SVG synoptic widget
in a stand alone application.
"""

import sys
import os

from PyQt5.QtWidgets import QApplication

from svgsynoptic2.synopticwidget import SynopticWidget


class ExampleSynopticWidget(SynopticWidget):

    """
    A custom subclass of the synoptic widget.
    """

    # Needed for now, just ignore it...
    _modelNames = None


def main():
    qapp = QApplication(sys.argv)

    # We need to give the absolute path to the HTML file
    # because our webview is setup to load assets from the
    # svgsynoptic library's path, not from the module's path.
    path = os.path.dirname(__file__)
    widget = ExampleSynopticWidget(os.path.join(path, "index.html"))
    widget.resize(800, 600)

    widget.show()
    qapp.exec_()


if __name__ == "__main__":
    main()

```

--------------------------------

### Use Redis Scheme in Taurus Form

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/custom_schemes.md

Demonstrates how to use the Redis scheme within a TaurusForm widget. This allows for a GUI-based editing of Redis keys.

```python
import sys
from taurus.qt.qtgui.application import TaurusApplication
from taurus.qt.qtgui.panel import TaurusForm

app = TaurusApplication(sys.argv, cmd_line_parser=None,)
panel = TaurusForm()
model = ['redis://localhost:6379/0/my:test:key']
panel.setModel(model)
print(panel[0].readWidgetClass)
print(panel[0].writeWidgetClass)
panel.show()
sys.exit(app.exec_())
```

--------------------------------

### Run Pixi Jive and Taurus Form Checks

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Executes Jive (a Tango device browser) and opens a Taurus form for a Tango attribute using Pixi run commands. These are optional checks after setting up the Pixi environment.

```bash
pixi run jive
```

```bash
pixi run taurus form sys/tg_test/1/state
```

--------------------------------

### Create Conda Environment with Pinned Versions

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Creates a conda environment named 'taurus' with specific versions pinned for Python, PyTango, PySide6, Taurus, and taurus_pyqtgraph. Use this for environments requiring exact dependency versions.

```bash
conda create -n taurus -c conda-forge \
  python=3.12 pytango=10.0.4 pyside6=6.11 taurus=5.4 taurus_pyqtgraph
```

--------------------------------

### Write and Read Redis Key with Taurus

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/custom_schemes.md

A simple Python script to demonstrate writing a value to and reading it back from a Redis key using the Taurus Redis scheme. Ensure Redis is running and accessible.

```python
import taurus

uri = "redis://localhost:6379/0/my:test:key"

# Get the attribute object via Taurus
attr = taurus.Attribute(uri)

# Write a test value
test_value = "Hello, Redis + Taurus!"
print(f"Writing to {uri}: '{test_value}'")
attr.write(test_value)

# Read it back
read_val = attr.read().rvalue
print(f"Read from {uri}: '{read_val}'")

# Check correctness
assert read_val == test_value, "Mismatch between written and read value"

print("✅ Redis scheme test passed.")
```

--------------------------------

### Verify Basic Taurus Form with Tango Devices

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Opens a basic Taurus form displaying the 'state' and 'status' attributes of the TangoTest device server. This verifies Taurus can connect to and display Tango device data.

```bash
taurus form sys/tg_test/1/state sys/tg_test/1/status
```

--------------------------------

### Factory Object Identity Comparison

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_and_models.md

Compare attribute objects obtained through direct instantiation and factory retrieval. Demonstrates that factories can return the same object for identical model names.

```python
import taurus

a1 = taurus.Attribute("sys/tg_test/1/double_scalar")
a2 = taurus.Factory("tango").getAttribute(
    "tango://localhost:10000/sys/tg_test/1/double_scalar"
)

print(a1 is a2)
```

--------------------------------

### Test Tango Device Interaction

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Interact with the registered Tango device to read attributes and execute commands.

```python
import tango

dev = tango.DeviceProxy("my/motor/1")
print(dev.Position)
dev.Move(0)
```

--------------------------------

### Define a Dummy Tango Motor Device

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_gui_extensions.md

Create a Python class for a dummy Tango motor device, including initialization, attributes, and commands. This serves as the basis for creating custom Taurus extensions.

```python
import time

from tango import DevState
from tango.server import Device, attribute, command


class MyMotor(Device):

    def init_device(self):
        super().init_device()
        self._position = 10.0
        self.set_state(DevState.ON)

    @attribute(dtype=float)
    def Position(self):
        return self._position

    @command(dtype_in=float)
    def Move(self, position):
        self.set_state(DevState.MOVING)
        time.sleep(0.2)
        self._position = position
        self.set_state(DevState.ON)
```

--------------------------------

### HTML Structure for SVG Synoptic

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/svg_synoptic.md

Sets up the HTML page structure and includes a script to load the SVG synoptic. The loadSVG function requires the absolute path to the SVG file.

```html
...

<body oncontextmenu="return false;">
  
  <div id="view">                            
    <!-- this is where our synoptic will go -->
    <div class="overlay">SVG Synoptic!</div>
  </div>

  ...

  <!-- kick everything off when the page has loaded -->
  <script type="text/javascript">
                          
    window.addEventListener("load", function () {
        var container = document.getElementById("view");
        var config = {};
        
        // loadSVG is a convenience method for loading a file.  Note
        // that we need to give the absolute path to the file. ${path}
        // will be replaced with the path to this HTML file.
        loadSVG("${path}/synoptic1.svg", container, config);
    });
  </script>
  
</body>

```

--------------------------------

### Open TaurusForm with Attributes

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/forms_and_widgets.md

Execute this command in the terminal to open a TaurusForm displaying multiple attributes. This is useful for monitoring and interacting with control system data.

```bash
taurus form sys/tg_test/1/state sys/tg_test/1/status sys/tg_test/1/boolean_scalar sys/tg_test/1/double_scalar sys/tg_test/1/double_scalar_w sys/tg_test/1/ampli
```

--------------------------------

### TaurusForm with Device Data

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/forms_and_widgets.md

Passing a Tango device to TaurusForm creates a shortcut to a TaurusDevicePanel, showing all device attributes and commands.

```bash
taurus device DEVICE_NAME
```

--------------------------------

### Custom Eval Device with Programmatic Symbols

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/eval_scheme.md

Shows how to use a custom evaluation device (`@mydev`) and add symbols to it programmatically. This allows extending the available functions within eval expressions.

```python
import taurus
d = taurus.Device('eval:@mydev')
d.addSafe({'message':'hello world'})
a = taurus.Attribute('eval:@mydev/message.upper()')
print(a.read().rvalue)
```

```python
# ...
print(sorted(d.getSafe().keys()))
```

--------------------------------

### Interact with Taurus Attributes

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/core_and_models.md

Demonstrates reading, writing, and subscribing to Taurus attributes. Ensure the attribute is writable before attempting to write. Subscription requires system event support.

```python
import taurus
# taurus.setLogLevel(taurus.Debug)

attribute = taurus.Attribute("sys/tg_test/1/short_scalar")

attribute.info("Reading the attribute using read()")
reading = attribute.read()
attribute.info(f"Reading object: {reading}")
attribute.info(f"Current value (reading.value): {reading.value}")

attribute.info("-" * 20)

attribute.info("Reading the value directly via the property 'attribute.value'")
attribute.info(f"Attribute value: {attribute.value}")

attribute.info("-" * 20)

attribute.info("Attempting to write a new value (if the attribute is writable)")
try:
    attribute.write(42)  # Change this to a suitable value for your attribute's type
    attribute.info(f"New value after write: {attribute.value}")
except Exception as e:
    attribute.error(f"Failed to write value: {e}")

attribute.info("-" * 20)

attribute.info("Subscribing to changes (if the system supports events)")

def my_attr_listener(evt_src, evt_type, evt_value):
    attribute.info(f"Event received: {evt_type}, value: {evt_value.rvalue}")

attribute.addListener(my_attr_listener)

attribute.info("-" * 20)

attribute.info("Retrieving attribute configuration (metadata)")
config = attribute.getConfig()
attribute.info(f"Label: {config.label}, Data Type: {config.type}, Description: {config.description}")
```

--------------------------------

### Explore TaurusTrend with Eval and Tango Attribute

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/plotting.md

Execute `taurus trend` with a random evaluation and a Tango attribute to observe real-time data plotting.

```bash
taurus trend "eval:rand()" sys/tg_test/1/double_scalar_rww
```

--------------------------------

### Execute Taurus Form

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/forms_and_widgets.md

Opens a Taurus form for specified attributes. Use this command to interact with and modify attribute values.

```bash
taurus form sys/tg_test/1/ampli sys/tg_test/1/double_scalar_w
```

--------------------------------

### Add Multiple Attributes to Taurus Form

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/forms_and_widgets.md

Specify multiple attributes directly on the command line with `taurus form` to add them to the widget.

```bash
taurus form sys/tg_test/1/ampli  sys/tg_test/1/double_scalar
```

--------------------------------

### Using Python Libraries with eval

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/forms_and_widgets.md

Evaluates a Python expression using the 'eval' command to check for file existence. This showcases the integration with Python libraries.

```bash
taurus form 'eval:@os.*/path.exists("/tmp/foo")'
```

--------------------------------

### Include Layer CSS and JavaScript

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/svg_synoptic.md

These lines must be present in the HTML file to enable the layer selector plugin for SVG Synoptic.

```html
<link rel="stylesheet" href="css/layers.css" />
...
<script src="js/layers.js"></script>
```

--------------------------------

### Display Attribute State and Status in Taurus

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/forms_and_widgets.md

Use `taurus form` to display both the state and status of a device attribute. Observe color changes based on attribute quality and device state.

```bash
taurus form sys/tg_test/1/short_scalar
```

```bash
taurus form sys/tg_test/1/state sys/tg_test/1/status
```

--------------------------------

### TaurusForm with Image Data

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/forms_and_widgets.md

When TaurusForm encounters image data, it displays a button that launches a dedicated TaurusImageDialog widget.

```python
double_image_ro
```

--------------------------------

### Open Taurus Form with Eval Scheme

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/environment.md

Opens a Taurus form using the 'eval:' scheme to display a random number. This does not require a running Tango system and tests the basic Taurus GUI functionality.

```bash
taurus form "eval:rand()"
```

--------------------------------

### Monitor Process Memory Usage with Taurus Trend

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/plotting.md

Use 'taurus trend' combined with 'eval' to monitor the memory usage (RSS) of a specific process. Replace 'REPLACE_THIS_BY_PID' with the actual Process ID.

```bash
taurus trend -r500 "eval:@psutil.*/Process(REPLACE_THIS_BY_PID).memory_info().rss/2**10"
```

--------------------------------

### Plot Data with TaurusPlot Command Line

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/plotting.md

Use the `taurus plot` command to visualize data arrays. You can plot generated data or Tango attributes.

```bash
taurus plot "eval:Q(rand(333),'mm')"
```

```bash
taurus plot "eval:Q(rand(333),'mm')" sys/tg_test/1/wave
```

--------------------------------

### Default Formatter Dictionary

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/custom_widgets_and_formatters.md

Define a dictionary of default formatters for different data types like float and Enum.

```python
defaultFormatDict = {
    float: "{:.{bc.modelObj.precision}f}",
    Enum: "{0.name}",
    Quantity: "{~.{bc.modelObj.precision}f}",
}
```

--------------------------------

### Redis Device Name Validator Path

Source: https://gitlab.com/taurus-org/taurus-training/-/blob/main/current/custom_schemes.md

Defines the regex path for the device name in Redis, considering a namespace separator. This is used in `RedisDeviceNameValidator`.

```python
REDIS_NAMESPACE_SEPARATOR = ":"

path = rf"/?(?P<devname>(?!{REDIS_NAMESPACE_SEPARATOR})[^/]+(?: {REDIS_NAMESPACE_SEPARATOR}[^/:]+)*)"
```