updates to version v0.7.4

feat: adds option for custom frontend_src directory

.vscode/extensions.json

@@ -2,6 +2,7 @@
     "recommendations": [
         "charliermarsh.ruff",
         "ms-python.python",
-        "ms-python.vscode-pylance"
+        "ms-python.vscode-pylance",
+        "ms-python.mypy-type-checker"
     ]
 }

.vscode/launch.json

@@ -6,7 +6,7 @@
             "type": "python",
             "request": "launch",
             "module": "foo",
-            "justMyCode": true,
+            "justMyCode": false,
             "env": {
                 "ENVIRONMENT": "development"
             }

.vscode/settings.json

@@ -8,8 +8,8 @@
         "editor.tabSize": 4,
         "editor.detectIndentation": false,
         "editor.codeActionsOnSave": {
-            "source.organizeImports": true,
-            "source.fixAll": true
+            "source.organizeImports": "explicit",
+            "source.fixAll": "explicit"
         }
     },
     "[yaml]": {
@@ -23,7 +23,7 @@
         "editor.formatOnType": false,
         "editor.formatOnSaveMode": "file",
         "editor.codeActionsOnSave": {
-            "source.fixAll.eslint": true
+            "source.fixAll.eslint": "explicit"
         }
     }
 }

README.md

@@ -17,16 +17,24 @@
   - [Method Components](#method-components)
   - [DataService Instances (Nested Classes)](#dataservice-instances-nested-classes)
   - [Custom Components (`pydase.components`)](#custom-components-pydasecomponents)
+    - [`DeviceConnection`](#deviceconnection)
+      - [Customizing Connection Logic](#customizing-connection-logic)
+      - [Reconnection Interval](#reconnection-interval)
     - [`Image`](#image)
     - [`NumberSlider`](#numberslider)
     - [`ColouredEnum`](#colouredenum)
     - [Extending with New Components](#extending-with-new-components)
-- [Customizing Web Interface Style](#customizing-web-interface-style)
 - [Understanding Service Persistence](#understanding-service-persistence)
   - [Controlling Property State Loading with `@load_state`](#controlling-property-state-loading-with-load_state)
 - [Understanding Tasks in pydase](#understanding-tasks-in-pydase)
 - [Understanding Units in pydase](#understanding-units-in-pydase)
-- [Changing the Log Level](#changing-the-log-level)
+- [Configuring pydase via Environment Variables](#configuring-pydase-via-environment-variables)
+- [Customizing the Web Interface](#customizing-the-web-interface)
+  - [Enhancing the Web Interface Style with Custom CSS](#enhancing-the-web-interface-style-with-custom-css)
+  - [Tailoring Frontend Component Layout](#tailoring-frontend-component-layout)
+  - [Specifying a Custom Frontend Source](#specifying-a-custom-frontend-source)
+- [Logging in pydase](#logging-in-pydase)
+  - [Changing the Log Level](#changing-the-log-level)
 - [Documentation](#documentation)
 - [Contributing](#contributing)
 - [License](#license)
@@ -48,7 +56,7 @@
 
 <!--installation-start-->
 
-Install pydase using [`poetry`](https://python-poetry.org/):
+Install `pydase` using [`poetry`](https://python-poetry.org/):
 
 ```bash
 poetry add pydase
@@ -76,6 +84,7 @@ Here's an example:
 
 ```python
 from pydase import DataService, Server
+from pydase.utils.decorators import frontend
 
 
 class Device(DataService):
@@ -113,6 +122,7 @@ class Device(DataService):
         # run code to set power state
         self._power = value
 
+    @frontend
     def reset(self) -> None:
         self.current = 0.0
         self.voltage = 0.0
@@ -186,11 +196,35 @@ In `pydase`, components are fundamental building blocks that bridge the Python b
 - `enum.Enum`: Presented as an `EnumComponent`, facilitating dropdown selection.
 
 ### Method Components
+Within the `DataService` class of `pydase`, only methods devoid of arguments can be represented in the frontend, classified into two distinct categories
 
-Methods within the `DataService` class have frontend representations:
+1. [**Tasks**](#understanding-tasks-in-pydase): Argument-free asynchronous functions, identified within `pydase` as tasks, are inherently designed for frontend interaction. These tasks are automatically rendered with a start/stop button, allowing users to initiate or halt the task execution directly from the web interface. 
+2. **Synchronous Methods with `@frontend` Decorator**: Synchronous methods without arguments can also be presented in the frontend. For this, they have to be decorated with the `@frontend` decorator.
 
-- Regular Methods: These are rendered as a `MethodComponent` in the frontend, allowing users to execute the method via an "execute" button.
-- Asynchronous Methods: These are manifested as the `AsyncMethodComponent` with "start"/"stop" buttons to manage the execution of [tasks](#understanding-tasks-in-pydase).
+```python
+import pydase
+import pydase.components
+import pydase.units as u
+from pydase.utils.decorators import frontend
+
+
+class MyService(pydase.DataService):
+    @frontend
+    def exposed_method(self) -> None:
+        ...
+
+    async def my_task(self) -> None:
+        while True:
+            # ...
+```
+
+![Method Components](docs/images/method_components.png)
+
+You can still define synchronous tasks with arguments and call them using a python client. However, decorating them with the `@frontend` decorator will raise a `FunctionDefinitionError`. Defining a task with arguments will raise a `TaskDefinitionError`.
+I decided against supporting function arguments for functions rendered in the frontend due to the following reasons:
+
+1. Feature Request Pitfall: supporting function arguments create a bottomless pit of feature requests. As users encounter the limitations of supported types, demands for extending support to more complex types would grow.
+2. Complexity in Supported Argument Types: while simple types like `int`, `float`, `bool` and `str` could be easily supported, more complicated types are not (representation, (de-)serialization).
 
 ### DataService Instances (Nested Classes)
 
@@ -204,9 +238,9 @@ from pydase import DataService, Server
 
 class Channel(DataService):
     def __init__(self, channel_id: int) -> None:
+        super().__init__()
         self._channel_id = channel_id
         self._current = 0.0
-        super().__init__()
 
     @property
     def current(self) -> float:
@@ -222,9 +256,8 @@ class Channel(DataService):
 
 class Device(DataService):
     def __init__(self) -> None:
-        self.channels = [Channel(i) for i in range(2)]
-
         super().__init__()
+        self.channels = [Channel(i) for i in range(2)]
 
 
 if __name__ == "__main__":
@@ -245,6 +278,89 @@ The custom components in `pydase` have two main parts:
 
 Below are the components available in the `pydase.components` module, accompanied by their Python usage:
 
+#### `DeviceConnection`
+
+The `DeviceConnection` component acts as a base class within the `pydase` framework for managing device connections. It provides a structured approach to handle connections by offering a customizable `connect` method and a `connected` property. This setup facilitates the implementation of automatic reconnection logic, which periodically attempts reconnection whenever the connection is lost.
+
+In the frontend, this class abstracts away the direct interaction with the `connect` method and the `connected` property. Instead, it showcases user-defined attributes, methods, and properties. When the `connected` status is `False`, the frontend displays an overlay that prompts manual reconnection through the `connect()` method. Successful reconnection removes the overlay.
+
+```python
+import pydase.components
+import pydase.units as u
+
+
+class Device(pydase.components.DeviceConnection):
+    def __init__(self) -> None:
+        super().__init__()
+        self._voltage = 10 * u.units.V
+
+    def connect(self) -> None:
+        if not self._connected:
+            self._connected = True
+
+    @property
+    def voltage(self) -> float:
+        return self._voltage
+
+
+class MyService(pydase.DataService):
+    def __init__(self) -> None:
+        super().__init__()
+        self.device = Device()
+
+
+if __name__ == "__main__":
+    service_instance = MyService()
+    pydase.Server(service_instance).run()
+```
+
+![DeviceConnection Component](docs/images/DeviceConnection_component.png)
+
+##### Customizing Connection Logic
+
+Users are encouraged to primarily override the `connect` method to tailor the connection process to their specific device. This method should adjust the `self._connected` attribute based on the outcome of the connection attempt:
+
+```python
+import pydase.components
+
+
+class MyDeviceConnection(pydase.components.DeviceConnection):
+    def __init__(self) -> None:
+        super().__init__()
+        # Add any necessary initialization code here
+
+    def connect(self) -> None:
+        # Implement device-specific connection logic here
+        # Update self._connected to `True` if the connection is successful,
+        # or `False` if unsuccessful
+        ...
+```
+
+Moreover, if the connection status requires additional logic, users can override the `connected` property:
+
+```python
+import pydase.components
+
+class MyDeviceConnection(pydase.components.DeviceConnection):
+    def __init__(self) -> None:
+        super().__init__()
+        # Add any necessary initialization code here
+
+    def connect(self) -> None:
+        # Implement device-specific connection logic here
+        # Ensure self._connected reflects the connection status accurately
+        ...
+
+    @property
+    def connected(self) -> bool:
+        # Implement custom logic to accurately report connection status
+        return self._connected
+```
+
+##### Reconnection Interval
+
+The `DeviceConnection` component automatically executes a task that checks for device availability at a default interval of 10 seconds. This interval is adjustable by modifying the `_reconnection_wait_time` attribute on the class instance.
+
 #### `Image`
 
 This component provides a versatile interface for displaying images within the application. Users can update and manage images from various sources, including local paths, URLs, and even matplotlib figures.
@@ -254,7 +370,6 @@ The component offers methods to load images seamlessly, ensuring that visual con
 ```python
 import matplotlib.pyplot as plt
 import numpy as np
-
 import pydase
 from pydase.components.image import Image
 
@@ -332,12 +447,14 @@ class MySlider(pydase.components.NumberSlider):
 
     @property
     def value(self) -> float:
+        """Slider value."""
         return self._value
 
     @value.setter
     def value(self, value: float) -> None:
         if value < self._min or value > self._max:
             raise ValueError("Value is either below allowed min or above max value.")
+
         self._value = value
 
 
@@ -413,7 +530,7 @@ In this example, `MySlider` overrides the `min`, `max`, `step_size`, and `value`
 
 - Incorporating units in `NumberSlider`
 
-  The `NumberSlider` is capable of displaying units alongside values, enhancing its usability in contexts where unit representation is crucial. When utilizing `pydase.units`, you can specify units for the slider's value, allowing the component to reflect these units in the frontend.
+  The `NumberSlider` is capable of [displaying units](#understanding-units-in-pydase) alongside values, enhancing its usability in contexts where unit representation is crucial. When utilizing `pydase.units`, you can specify units for the slider's value, allowing the component to reflect these units in the frontend.
 
   Here's how to implement a `NumberSlider` with unit display:
 
@@ -497,31 +614,6 @@ Users can also extend the library by creating custom components. This involves d
 
 <!-- Component User Guide End -->
 
-## Customizing Web Interface Style
-
-`pydase` allows you to enhance the user experience by customizing the web interface's appearance. You can apply your own styles globally across the web interface by passing a custom CSS file to the server during initialization.
-
-Here's how you can use this feature:
-
-1. Prepare your custom CSS file with the desired styles.
-
-2. When initializing your server, use the `css` parameter of the `Server` class to specify the path to your custom CSS file.
-
-```python
-from pydase import Server, DataService
-
-class Device(DataService):
-    # ... your service definition ...
-
-if __name__ == "__main__":
-    service = MyService()
-    server = Server(service, css="path/to/your/custom.css").run()
-```
-
-This will apply the styles defined in `custom.css` to the web interface, allowing you to maintain branding consistency or improve visual accessibility.
-
-Please ensure that the CSS file path is accessible from the server's running location. Relative or absolute paths can be used depending on your setup.
-
 ## Understanding Service Persistence
 
 `pydase` allows you to easily persist the state of your service by saving it to a file. This is especially useful when you want to maintain the service's state across different runs.
@@ -573,9 +665,9 @@ Note: If the service class structure has changed since the last time its state w
 
 ## Understanding Tasks in pydase
 
-In `pydase`, a task is defined as an asynchronous function contained in a class that inherits from `DataService`. These tasks usually contain a while loop and are designed to carry out periodic functions.
+In `pydase`, a task is defined as an asynchronous function without arguments contained in a class that inherits from `DataService`. These tasks usually contain a while loop and are designed to carry out periodic functions.
 
-For example, a task might be used to periodically read sensor data, update a database, or perform any other recurring job. The core feature of `pydase` is its ability to automatically generate start and stop functions for these tasks. This allows you to control task execution via both the frontend and an `rpyc` client, giving you flexible and powerful control over your service's operation.
+For example, a task might be used to periodically read sensor data, update a database, or perform any other recurring job. One core feature of `pydase` is its ability to automatically generate start and stop functions for these tasks. This allows you to control task execution via both the frontend and python clients, giving you flexible and powerful control over your service's operation.
 
 Another powerful feature of `pydase` is its ability to automatically start tasks upon initialization of the service. By specifying the tasks and their arguments in the `_autostart_tasks` dictionary in your service class's `__init__` method, `pydase` will automatically start these tasks when the server is started. Here's an example:
 
@@ -584,9 +676,9 @@ from pydase import DataService, Server
 
 class SensorService(DataService):
     def __init__(self):
-        self.readout_frequency = 1.0
-        self._autostart_tasks = {"read_sensor_data": ()}  # args passed to the function go there
         super().__init__()
+        self.readout_frequency = 1.0
+        self._autostart_tasks["read_sensor_data"] = ()
 
     def _process_data(self, data: ...) -> None:
         ...
@@ -606,22 +698,22 @@ if __name__ == "__main__":
     Server(service).run()
 ```
 
-In this example, `read_sensor_data` is a task that continuously reads data from a sensor. The readout frequency can be updated using the `readout_frequency` attribute.
-By listing it in the `_autostart_tasks` dictionary, it will automatically start running when `Server(service).run()` is executed.
-As with all tasks, `pydase` will also generate `start_read_sensor_data` and `stop_read_sensor_data` methods, which can be called to manually start and stop the data reading task.
+In this example, `read_sensor_data` is a task that continuously reads data from a sensor. By adding it to the `_autostart_tasks` dictionary, it will automatically start running when `Server(service).run()` is executed.
+As with all tasks, `pydase` will generate `start_read_sensor_data` and `stop_read_sensor_data` methods, which can be called to manually start and stop the data reading task. The readout frequency can be updated using the `readout_frequency` attribute.
 
 ## Understanding Units in pydase
 
 `pydase` integrates with the [`pint`](https://pint.readthedocs.io/en/stable/) package to allow you to work with physical quantities within your service. This enables you to define attributes with units, making your service more expressive and ensuring consistency in the handling of physical quantities.
 
-You can define quantities in your `DataService` subclass using `pydase`'s `units` functionality. These quantities can be set and accessed like regular attributes, and `pydase` will automatically handle the conversion between floats and quantities with units.
+You can define quantities in your `DataService` subclass using `pydase`'s `units` functionality.
 
 Here's an example:
 
 ```python
 from typing import Any
-from pydase import DataService, Server
+
 import pydase.units as u
+from pydase import DataService, Server
 
 
 class ServiceClass(DataService):
@@ -633,17 +725,15 @@ class ServiceClass(DataService):
         return self._current
 
     @current.setter
-    def current(self, value: Any) -> None:
+    def current(self, value: u.Quantity) -> None:
         self._current = value
 
 
 if __name__ == "__main__":
     service = ServiceClass()
 
-    # You can just set floats to the Quantity objects. The DataService __setattr__ will
-    # automatically convert this
-    service.voltage = 10.0
-    service.current = 1.5
+    service.voltage = 10.0 * u.units.V
+    service.current = 1.5 * u.units.mA
 
     Server(service).run()
 ```
@@ -676,6 +766,101 @@ if __name__ == "__main__":
 
 For more information about what you can do with the units, please consult the documentation of [`pint`](https://pint.readthedocs.io/en/stable/).
 
+## Configuring pydase via Environment Variables
+
+Configuring `pydase` through environment variables enhances flexibility, security, and reusability. This approach allows for easy adaptation of services across different environments without code changes, promoting scalability and maintainability. With that, it simplifies deployment processes and facilitates centralized configuration management. Moreover, environment variables enable separation of configuration from code, aiding in secure and collaborative development.
+
+`pydase` offers various configurable options:
+
+- **`ENVIRONMENT`**: Sets the operation mode to either "development" or "production". Affects logging behaviour (see [logging section](#logging-in-pydase)).
+- **`SERVICE_CONFIG_DIR`**: Specifies the directory for service configuration files, like `web_settings.json`. This directory can also be used to hold user-defined configuration files. Default is the `config` folder in the service root folder. The variable can be accessed through:
+
+    ```python
+    import pydase.config
+    pydase.config.ServiceConfig().config_dir
+    ```
+
+- **`SERVICE_WEB_PORT`**: Defines the port number for the web server. This has to be different for each services running on the same host. Default is 8001.
+- **`SERVICE_RPC_PORT`**: Defines the port number for the rpc server. This has to be different for each services running on the same host. Default is 18871.
+- **`GENERATE_WEB_SETTINGS`**: When set to true, generates / updates the `web_settings.json` file. If the file already exists, only new entries are appended.
+
+Some of those settings can also be altered directly in code when initializing the server: 
+
+```python
+import pathlib
+
+from pydase import Server
+from your_service_module import YourService
+
+
+server = Server(
+    YourService(),
+    web_port=8080,
+    rpc_port=18880,
+    config_dir=pathlib.Path("other_config_dir"),  # note that you need to provide an argument of type pathlib.Path
+    generate_web_settings=True
+).run()
+```
+
+## Customizing the Web Interface
+
+### Enhancing the Web Interface Style with Custom CSS
+
+`pydase` allows you to enhance the user experience by customizing the web interface's appearance. You can apply your own styles globally across the web interface by passing a custom CSS file to the server during initialization.
+
+Here's how you can use this feature:
+
+1. Prepare your custom CSS file with the desired styles.
+
+2. When initializing your server, use the `css` parameter of the `Server` class to specify the path to your custom CSS file.
+
+```python
+from pydase import Server, DataService
+
+class MyService(DataService):
+    # ... your service definition ...
+
+if __name__ == "__main__":
+    service = MyService()
+    server = Server(service, css="path/to/your/custom.css").run()
+```
+
+This will apply the styles defined in `custom.css` to the web interface, allowing you to maintain branding consistency or improve visual accessibility.
+
+Please ensure that the CSS file path is accessible from the server's running location. Relative or absolute paths can be used depending on your setup.
+
+### Tailoring Frontend Component Layout
+
+`pydase` enables users to customize the frontend layout via the `web_settings.json` file. Each key in the file corresponds to the full access path of public attributes, properties, and methods of the exposed service, using dot-notation.
+
+- **Custom Display Names**: Modify the `"displayName"` value in the file to change how each component appears in the frontend.
+- **Control Component Visibility**: Utilize the `"display"` key-value pair to control whether a component is rendered in the frontend. Set the value to `true` to make the component visible or `false` to hide it.
+<!-- - **Adjustable Component Order**: The `"displayOrder"` values determine the order of components. Alter these values to rearrange the components as desired. -->
+
+The `web_settings.json` file will be stored in the directory specified by `SERVICE_CONFIG_DIR`. You can generate a `web_settings.json` file by setting the `GENERATE_WEB_SETTINGS` to `True`. For more information, see the [configuration section](#configuring-pydase-via-environment-variables).
+
+### Specifying a Custom Frontend Source
+
+To further personalize your web interface, you can provide `pydase` with a custom frontend GUI. To do so, you can use the `frontend_src` keyword in the `pydase.Server`:
+
+```python
+from pathlib import Path
+
+import pydase
+
+
+class MyService(pydase.DataService):
+    # Service definition
+
+
+if __name__ == "__main__":
+    service = MyService()
+    pydase.Server(
+        service,
+        frontend_src=Path("path/to/your/frontend/directory"),
+    ).run()
+```
+
 ## Logging in pydase
 
 The `pydase` library organizes its loggers on a per-module basis, mirroring the Python package hierarchy. This structured approach allows for granular control over logging levels and behaviour across different parts of the library.

docs/dev-guide/Adding_Components.md

@@ -18,7 +18,7 @@ For example, for a `Image` component, create a file named `image.py`.
 
 ### Step 2: Define the Backend Class
 
-Within the newly created file, define a Python class representing the component. This class should inherit from `DataService` and contains the attributes that the frontend needs to render the component. Every public attribute defined in this class will synchronise across the clients. It can also contain methods which can be used to interact with the component from the backend.
+Within the newly created file, define a Python class representing the component. This class should inherit from `DataService` and contains the attributes that the frontend needs to render the component. Every public attribute defined in this class will synchronise across the clients. It can also contain (public) methods which you can provide for the user to interact with the component from the backend (or python clients).
 
 For the `Image` component, the class may look like this:
 
@@ -31,21 +31,25 @@ from pydase.data_service.data_service import DataService
 class Image(DataService):
     def __init__(
         self,
-        image_representation: bytes = b"",
     ) -> None:
-        self.image_representation = image_representation
         super().__init__()
+        self._value: str = ""
+        self._format: str = ""
 
-    # need to decode the bytes
-    def __setattr__(self, __name: str, __value: Any) -> None:
-        if __name == "value":
-            if isinstance(__value, bytes):
-                __value = __value.decode()
-        return super().__setattr__(__name, __value)
+    @property
+    def value(self) -> str:
+        return self._value
 
+    @property
+    def format(self) -> str:
+        return self._format
+
+    def load_from_path(self, path: Path | str) -> None:
+        # changing self._value and self._format
+        ...
 ```
 
-So, changing the `image_representation` will push the updated value to the browsers connected to the service.
+So, calling `load_from_path` will push the updated value and format to the browsers clients connected to the service.
 
 ### Step 3: Register the Backend Class
 
@@ -85,10 +89,11 @@ def test_Image(capsys: CaptureFixture) -> None:
     class ServiceClass(DataService):
         image = Image()
 
-    service = ServiceClass()
-    # ...
-```
+    service_instance = ServiceClass()
 
+    service_instance.image.load_from_path("<path/to/image>.png")
+    assert service_instance.image.format == "PNG"
+```
 
 ## Adding a Frontend Component to `pydase`
 
@@ -107,34 +112,41 @@ Write the React component code, following the structure and patterns used in exi
 For example, for the `Image` component, a template could look like this:
 
 ```tsx
-import { setAttribute, runMethod } from '../socket';  // use this when your component should sets values of attributes
-                                                      // or runs a method, respectively
-import { DocStringComponent } from './DocStringComponent';
 import React, { useEffect, useRef, useState } from 'react';
 import { Card, Collapse, Image } from 'react-bootstrap';
 import { DocStringComponent } from './DocStringComponent';
 import { ChevronDown, ChevronRight } from 'react-bootstrap-icons';
-import { getIdFromFullAccessPath } from '../utils/stringUtils';
 import { LevelName } from './NotificationsComponent';
 
-interface ImageComponentProps {
-  name: string;
-  parentPath: string;
-  readOnly: boolean;
-  docString: string;
+type ImageComponentProps = {
+  name: string;  // needed to create the fullAccessPath
+  parentPath: string;  // needed to create the fullAccessPath
+  readOnly: boolean;  // component changable through frontend?
+  docString: string;  // contains docstring of your component
+  displayName: string;  // name defined in the web_settings.json
+  id: string;  // unique identifier - created from fullAccessPath
   addNotification: (message: string, levelname?: LevelName) => void;
-  // Define your component specific props here
+  changeCallback?: (  // function used to communicate changes to the backend
+    value: unknown,
+    attributeName?: string,
+    prefix?: string,
+    callback?: (ack: unknown) => void
+  ) => void;
+  // component-specific properties 
   value: string;
   format: string;
-}
+};
 
 export const ImageComponent = React.memo((props: ImageComponentProps) => {
-  const { name, parentPath, value, docString, format, addNotification } = props;
+  const { value, docString, format, addNotification, displayName, id } = props;
 
   const renderCount = useRef(0);
   const [open, setOpen] = useState(true);  // add this if you want to expand/collapse your component
-  const fullAccessPath = parentPath.concat('.' + name);
-  const id = getIdFromFullAccessPath(fullAccessPath);
+  const fullAccessPath = [props.parentPath, props.name]
+    .filter((element) => element)
+    .join('.');
+
+  // Your component logic here
 
   useEffect(() => {
     renderCount.current++;
@@ -142,13 +154,11 @@ export const ImageComponent = React.memo((props: ImageComponentProps) => {
 
   // This will trigger a notification if notifications are enabled.
   useEffect(() => {
-    addNotification(`${parentPath}.${name} changed to ${value}.`);
+    addNotification(`${fullAccessPath} changed.`);
   }, [props.value]);
 
-  // Your component logic here
-
   return (
-    <div className={'imageComponent'} id={id}>
+    <div className="component imageComponent" id={id}>
       {/* Add the Card and Collapse components here if you want to be able to expand and
        collapse your component.  */}
       <Card>
@@ -156,14 +166,15 @@ export const ImageComponent = React.memo((props: ImageComponentProps) => {
           onClick={() => setOpen(!open)}
           style={{ cursor: 'pointer' }} // Change cursor style on hover
         >
-          {name} {open ? <ChevronDown /> : <ChevronRight />}
+          {displayName}
+          <DocStringComponent docString={docString} />
+          {open ? <ChevronDown /> : <ChevronRight />}
         </Card.Header>
         <Collapse in={open}>
           <Card.Body>
             {process.env.NODE_ENV === 'development' && (
               <p>Render count: {renderCount.current}</p>
             )}
-            <DocStringComponent docString={docString} />
             {/* Your component TSX here */}
           </Card.Body>
         </Collapse>
@@ -175,56 +186,98 @@ export const ImageComponent = React.memo((props: ImageComponentProps) => {
 
 ### Step 3: Emitting Updates to the Backend
 
-React components in the frontend often need to send updates to the backend, particularly when user interactions modify the component's state or data. In `pydase`, we use `socketio` for smooth communication of these changes. To handle updates, we primarily use two events: `setAttribute` for updating attributes, and `runMethod` for executing backend methods. Below is a detailed guide on how to emit these events from your frontend component:
+React components in the frontend often need to send updates to the backend, particularly when user interactions modify the component's state or data. In `pydase`, we use `socketio` for communicating these changes.<br>
+There are two different events a component might want to trigger: updating an attribute or triggering a method. Below is a guide on how to emit these events from your frontend component:
 
-1. **Setup for emitting events**:
-    First, ensure you've imported the necessary functions from the `socket` module for both updating attributes and executing methods:
+1. **Updating Attributes**
 
-    ```tsx
-    import { setAttribute, runMethod } from '../socket';
-    ```
+    Updating the value of an attribute or property in the backend is a very common requirement. However, we want to define components in a reusable way, i.e. they can be linked to the backend but also be used without emitting change events.<br>
+    This is why we pass a `changeCallback` function as a prop to the component which it can use to communicate changes. If no function is passed, the component can be used in forms, for example.
 
-2. **Event Parameters**:
+    The `changeCallback` function takes the following arguments:
 
-    - When using **`setAttribute`**, we send three main pieces of data:
-        - `name`: The name of the attribute within the `DataService` instance to update.
-        - `parentPath`: The access path for the parent object of the attribute to be updated.
-        - `value`: The new value for the attribute, which must match the backend attribute type.
-    - For **`runMethod`**, the parameters are slightly different:
-        - `name`: The name of the method to be executed in the backend.
-        - `parentPath`: Similar to `setAttribute`, it's the access path to the object containing the method.
-        - `kwargs`: A dictionary of keyword arguments that the method requires.
-
-3. **Implementation**:
-
-    For illustation, take the `ButtonComponent`. When the button state changes, we want to send this update to the backend:
-
-    ```tsx
-    import { setAttribute } from '../socket';
-    // ... (other imports)
+    - `value`: the new value for the attribute, which must match the backend attribute type.
+    - `attributeName`: the name of the attribute within the `DataService` instance to update. Defaults to the `name` prop of the component.
+    - `prefix`: the access path for the parent object of the attribute to be updated. Defaults to the `parentPath` prop of the component.
+    - `callback`: the function that will be called when the server sends an acknowledgement. Defaults to `undefined`
     
+    For illustration, take the `ButtonComponent`. When the button state changes, we want to send this update to the backend:
+
+    ```tsx
+    // file: frontend/src/components/ButtonComponent.tsx
+    // ... (import statements)
+    
+    type ButtonComponentProps = {
+      // ...
+      changeCallback?: (
+        value: unknown,
+        attributeName?: string,
+        prefix?: string,
+        callback?: (ack: unknown) => void
+      ) => void;
+    };
+
     export const ButtonComponent = React.memo((props: ButtonComponentProps) => {
-      // ... 
-      const { name, parentPath, value } = props;
+      const {
+        // ...
+        changeCallback = () => {},
+      } = props;
 
       const setChecked = (checked: boolean) => {
-        setAttribute(name, parentPath, checked);
+        changeCallback(checked);
       };
 
       return (
         <ToggleButton
-          checked={value}
-          value={parentPath}
           // ... other props
           onChange={(e) => setChecked(e.currentTarget.checked)}>
-          <p>{name}</p>
+          {/* component TSX */}
         </ToggleButton>
       );
     });
     ```
 
-    In this example, whenever the button's checked state changes (`onChange` event), we invoke the `setChecked` method, which in turn emits the new state to the backend using `setAttribute`.
+    In this example, whenever the button's checked state changes (`onChange` event), we invoke the `setChecked` method, which in turn emits the new state to the backend using `changeCallback`.
 
+2. **Triggering Methods**
+
+    To trigger method through your component, you can either use the `MethodComponent` (which will render a button in the frontend), or use the low-level `runMethod` function. Its parameters are slightly different to the `changeCallback` function:
+
+    - `name`: the name of the method to be executed in the backend.
+    - `parentPath`: the access path to the object containing the method.
+    - `kwargs`: a dictionary of keyword arguments that the method requires.
+
+    To see how to use the `MethodComponent` in your component, have a look at the `DeviceConnection.tsx` file. Here is an example that demonstrates the usage of the `runMethod` function (also, have a look at the `MethodComponent.tsx` file):
+
+    ```tsx
+    import { runMethod } from '../socket';
+    // ... (other imports)
+
+    type ComponentProps = {
+      name: string;
+      parentPath: string;
+      // ...
+    };
+
+    export const Component = React.memo((props: ComponentProps) => {
+      const {
+        name,
+        parentPath,
+        // ...
+      } = props;
+
+      // ...
+
+      const someFunction = () => {
+        // ...
+        runMethod(name, parentPath, {});
+      };
+
+      return (
+        {/* component TSX */}
+      );
+    });
+    ```
 
 ### Step 4: Add the New Component to the GenericComponent
 
@@ -271,15 +324,17 @@ Inside the `GenericComponent` function, add a new conditional branch to render t
     <ImageComponent
       name={name}
       parentPath={parentPath}
-      readOnly={attribute.readonly}
-      docString={attribute.doc}
+      docString={attribute.value['value'].doc}
+      displayName={displayName}
+      id={id}
       addNotification={addNotification}
+      changeCallback={changeCallback}
       // Add any other specific props for the ImageComponent here
       value={attribute.value['value']['value'] as string}
       format={attribute.value['format']['value'] as string}
     />
   );
-} else {
+} else if (...) {
   // other code
 ```
 
@@ -294,12 +349,14 @@ For example, updating an `Image` component corresponds to setting a very long st
 To create a custom notification message, you can update the message passed to the `addNotification` method in the `useEffect` hook in the component file file. For the `ImageComponent`, this could look like this:
 
 ```tsx
+const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
+
 useEffect(() => {
-  addNotification(`${parentPath}.${name} changed.`);
+  addNotification(`${fullAccessPath} changed.`);
 }, [props.value]);
 ```
 
-However, you might want to use the `addNotification` at different places. For an example, see the [MethodComponent](../../frontend/src/components/MethodComponent.tsx).
+However, you might want to use the `addNotification` at different places. For an example, see the `MethodComponent`.
 **Note**: you can specify the notification level by passing a string of type `LevelName` (one of 'CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG'). The default value is 'DEBUG'.
 
 ### Step 6: Write Tests for the Component (TODO)

frontend/src/App.css

@@ -5,11 +5,6 @@ body {
 input.instantUpdate {
   background-color: rgba(255, 0, 0, 0.1);
 }
-
-.numberComponentButton {
-  padding: 0.15em 6px !important;
-  font-size: 0.70rem !important;
-}
 .navbarOffset {
   padding-top: 60px !important;
 }
@@ -17,26 +12,41 @@ input.instantUpdate {
   position: fixed !important;
   padding: 5px;
 }
-.debugToast, .infoToast {
+.debugToast,
+.infoToast {
   background-color: rgba(114, 214, 253, 0.5) !important;
 }
 .warningToast {
   background-color: rgba(255, 181, 44, 0.603) !important;
 }
-.errorToast, .criticalToast {
+.errorToast,
+.criticalToast {
   background-color: rgba(216, 41, 18, 0.678) !important;
 }
-.buttonComponent {
+.component {
+  position: relative;
   float: left !important;
-  margin-right: 10px !important;
+  padding: 5px !important;
+  z-index: 1;
 }
-.stringComponent {
+.dataServiceComponent {
+  width: 100%;
+}
+.deviceConnectionComponent {
+  position: relative;
   float: left !important;
-  margin-right: 10px !important;
+  width: 100%;
+  z-index: 1;
 }
-.numberComponent {
-    float: left !important;
-    margin-right: 10px !important;
-    width: 270px !important;
+.overlayContent {
+  position: absolute;
+  inset: 5px; /* (see https://developer.mozilla.org/en-US/docs/Web/CSS/inset) */
+  background: rgba(155, 155, 155, 0.75);
+  z-index: 2;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  flex-direction: column; /* Stack children vertically */
+  border-radius: var(--bs-border-radius);
+  border: var(--bs-border-width) solid var(--bs-border-color-translucent)
 }
-

frontend/src/App.tsx

@@ -1,10 +1,6 @@
-import { useCallback, useEffect, useReducer, useRef, useState } from 'react';
+import { useCallback, useEffect, useReducer, useState } from 'react';
 import { Navbar, Form, Offcanvas, Container } from 'react-bootstrap';
 import { hostname, port, socket } from './socket';
-import {
-  DataServiceComponent,
-  DataServiceJSON
-} from './components/DataServiceComponent';
 import './App.css';
 import {
   Notifications,
@@ -12,7 +8,9 @@ import {
   LevelName
 } from './components/NotificationsComponent';
 import { ConnectionToast } from './components/ConnectionToast';
-import { SerializedValue, setNestedValueByPath, State } from './utils/stateUtils';
+import { setNestedValueByPath, State } from './utils/stateUtils';
+import { WebSettingsContext, WebSetting } from './WebSettings';
+import { SerializedValue, GenericComponent } from './components/GenericComponent';
 
 type Action =
   | { type: 'SET_DATA'; data: State }
@@ -34,7 +32,13 @@ const reducer = (state: State, action: Action): State => {
     case 'SET_DATA':
       return action.data;
     case 'UPDATE_ATTRIBUTE': {
-      return setNestedValueByPath(state, action.fullAccessPath, action.newValue);
+      if (state === null) {
+        return null;
+      }
+      return {
+        ...state,
+        value: setNestedValueByPath(state.value, action.fullAccessPath, action.newValue)
+      };
     }
     default:
       throw new Error();
@@ -42,18 +46,13 @@ const reducer = (state: State, action: Action): State => {
 };
 const App = () => {
   const [state, dispatch] = useReducer(reducer, null);
-  const stateRef = useRef(state); // Declare a reference to hold the current state
+  const [webSettings, setWebSettings] = useState<Record<string, WebSetting>>({});
   const [isInstantUpdate, setIsInstantUpdate] = useState(false);
   const [showSettings, setShowSettings] = useState(false);
   const [showNotification, setShowNotification] = useState(false);
   const [notifications, setNotifications] = useState<Notification[]>([]);
   const [connectionStatus, setConnectionStatus] = useState('connecting');
 
-  // Keep the state reference up to date
-  useEffect(() => {
-    stateRef.current = state;
-  }, [state]);
-
   useEffect(() => {
     // Allow the user to add a custom css file
     fetch(`http://${hostname}:${port}/custom.css`)
@@ -74,6 +73,9 @@ const App = () => {
       fetch(`http://${hostname}:${port}/service-properties`)
         .then((response) => response.json())
         .then((data: State) => dispatch({ type: 'SET_DATA', data }));
+      fetch(`http://${hostname}:${port}/web-settings`)
+        .then((response) => response.json())
+        .then((data: Record<string, WebSetting>) => setWebSettings(data));
       setConnectionStatus('connected');
     });
     socket.on('disconnect', () => {
@@ -184,12 +186,15 @@ const App = () => {
       </Offcanvas>
 
       <div className="App navbarOffset">
-        <DataServiceComponent
-          name={''}
-          props={state as DataServiceJSON}
-          isInstantUpdate={isInstantUpdate}
-          addNotification={addNotification}
-        />
+        <WebSettingsContext.Provider value={webSettings}>
+          <GenericComponent
+            name=""
+            parentPath=""
+            attribute={state as SerializedValue}
+            isInstantUpdate={isInstantUpdate}
+            addNotification={addNotification}
+          />
+        </WebSettingsContext.Provider>
       </div>
       <ConnectionToast connectionStatus={connectionStatus} />
     </>

frontend/src/WebSettings.tsx

@@ -0,0 +1,9 @@
+import { createContext } from 'react';
+
+export const WebSettingsContext = createContext<Record<string, WebSetting>>({});
+
+export type WebSetting = {
+  displayName: string;
+  display: boolean;
+  index: number;
+};

frontend/src/components/AsyncMethodComponent.tsx

@@ -1,55 +1,49 @@
 import React, { useEffect, useRef } from 'react';
 import { runMethod } from '../socket';
-import { InputGroup, Form, Button } from 'react-bootstrap';
+import { Form, Button, InputGroup } from 'react-bootstrap';
 import { DocStringComponent } from './DocStringComponent';
-import { getIdFromFullAccessPath } from '../utils/stringUtils';
 import { LevelName } from './NotificationsComponent';
 
-interface AsyncMethodProps {
+type AsyncMethodProps = {
   name: string;
   parentPath: string;
-  parameters: Record<string, string>;
-  value: Record<string, string>;
+  value: 'RUNNING' | null;
   docString?: string;
   hideOutput?: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
-}
+  displayName: string;
+  id: string;
+  render: boolean;
+};
 
 export const AsyncMethodComponent = React.memo((props: AsyncMethodProps) => {
-  const { name, parentPath, docString, value: runningTask, addNotification } = props;
+  const {
+    name,
+    parentPath,
+    docString,
+    value: runningTask,
+    addNotification,
+    displayName,
+    id
+  } = props;
+
+  // Conditional rendering based on the 'render' prop.
+  if (!props.render) {
+    return null;
+  }
+
   const renderCount = useRef(0);
   const formRef = useRef(null);
-  const id = getIdFromFullAccessPath(parentPath.concat('.' + name));
+  const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
 
   useEffect(() => {
     renderCount.current++;
-
-    // updates the value of each form control that has a matching name in the
-    // runningTask object
-    if (runningTask) {
-      const formElement = formRef.current;
-      if (formElement) {
-        Object.entries(runningTask).forEach(([name, value]) => {
-          const inputElement = formElement.elements.namedItem(name);
-          if (inputElement) {
-            inputElement.value = value;
-          }
-        });
-      }
-    }
-  }, [runningTask]);
-
-  useEffect(() => {
     let message: string;
 
     if (runningTask === null) {
-      message = `${parentPath}.${name} task was stopped.`;
+      message = `${fullAccessPath} task was stopped.`;
     } else {
-      const runningTaskEntries = Object.entries(runningTask)
-        .map(([key, value]) => `${key}: "${value}"`)
-        .join(', ');
-
-      message = `${parentPath}.${name} was started with parameters { ${runningTaskEntries} }.`;
+      message = `${fullAccessPath} was started.`;
     }
     addNotification(message);
   }, [props.value]);
@@ -57,52 +51,31 @@ export const AsyncMethodComponent = React.memo((props: AsyncMethodProps) => {
   const execute = async (event: React.FormEvent) => {
     event.preventDefault();
     let method_name: string;
-    const kwargs: Record<string, unknown> = {};
 
     if (runningTask !== undefined && runningTask !== null) {
       method_name = `stop_${name}`;
     } else {
-      Object.keys(props.parameters).forEach(
-        (name) => (kwargs[name] = event.target[name].value)
-      );
       method_name = `start_${name}`;
     }
 
-    runMethod(method_name, parentPath, kwargs);
+    runMethod(method_name, parentPath, {});
   };
 
-  const args = Object.entries(props.parameters).map(([name, type], index) => {
-    const form_name = `${name} (${type})`;
-    const value = runningTask && runningTask[name];
-    const isRunning = value !== undefined && value !== null;
-
-    return (
-      <InputGroup key={index}>
-        <InputGroup.Text className="component-label">{form_name}</InputGroup.Text>
-        <Form.Control
-          type="text"
-          name={name}
-          defaultValue={isRunning ? value : ''}
-          disabled={isRunning}
-        />
-      </InputGroup>
-    );
-  });
-
   return (
-    <div className="align-items-center asyncMethodComponent" id={id}>
+    <div className="component asyncMethodComponent" id={id}>
       {process.env.NODE_ENV === 'development' && (
         <div>Render count: {renderCount.current}</div>
       )}
-      <h5>
-        Function: {name}
-        <DocStringComponent docString={docString} />
-      </h5>
       <Form onSubmit={execute} ref={formRef}>
-        {args}
-        <Button id={`button-${id}`} name={name} value={parentPath} type="submit">
-          {runningTask ? 'Stop' : 'Start'}
-        </Button>
+        <InputGroup>
+          <InputGroup.Text>
+            {displayName}
+            <DocStringComponent docString={docString} />
+          </InputGroup.Text>
+          <Button id={`button-${id}`} type="submit">
+            {runningTask === 'RUNNING' ? 'Stop ' : 'Start '}
+          </Button>
+        </InputGroup>
       </Form>
     </div>
   );

frontend/src/components/ButtonComponent.tsx

@@ -1,11 +1,9 @@
 import React, { useEffect, useRef } from 'react';
 import { ToggleButton } from 'react-bootstrap';
-import { setAttribute } from '../socket';
 import { DocStringComponent } from './DocStringComponent';
-import { getIdFromFullAccessPath } from '../utils/stringUtils';
 import { LevelName } from './NotificationsComponent';
 
-interface ButtonComponentProps {
+type ButtonComponentProps = {
   name: string;
   parentPath?: string;
   value: boolean;
@@ -13,13 +11,30 @@ interface ButtonComponentProps {
   docString: string;
   mapping?: [string, string]; // Enforce a tuple of two strings
   addNotification: (message: string, levelname?: LevelName) => void;
-}
+  changeCallback?: (
+    value: unknown,
+    attributeName?: string,
+    prefix?: string,
+    callback?: (ack: unknown) => void
+  ) => void;
+  displayName: string;
+  id: string;
+};
 
 export const ButtonComponent = React.memo((props: ButtonComponentProps) => {
-  const { name, parentPath, value, readOnly, docString, mapping, addNotification } =
-    props;
-  const buttonName = mapping ? (value ? mapping[0] : mapping[1]) : name;
-  const id = getIdFromFullAccessPath(parentPath.concat('.' + name));
+  const {
+    value,
+    readOnly,
+    docString,
+    addNotification,
+    changeCallback = () => {},
+    displayName,
+    id
+  } = props;
+  // const buttonName = props.mapping ? (value ? props.mapping[0] : props.mapping[1]) : name;
+  const fullAccessPath = [props.parentPath, props.name]
+    .filter((element) => element)
+    .join('.');
 
   const renderCount = useRef(0);
 
@@ -28,29 +43,29 @@ export const ButtonComponent = React.memo((props: ButtonComponentProps) => {
   });
 
   useEffect(() => {
-    addNotification(`${parentPath}.${name} changed to ${value}.`);
+    addNotification(`${fullAccessPath} changed to ${value}.`);
   }, [props.value]);
 
   const setChecked = (checked: boolean) => {
-    setAttribute(name, parentPath, checked);
+    changeCallback(checked);
   };
 
   return (
-    <div className={'buttonComponent'} id={id}>
+    <div className={'component buttonComponent'} id={id}>
       {process.env.NODE_ENV === 'development' && (
         <div>Render count: {renderCount.current}</div>
       )}
 
-      <DocStringComponent docString={docString} />
       <ToggleButton
         id={`toggle-check-${id}`}
         type="checkbox"
         variant={value ? 'success' : 'secondary'}
         checked={value}
-        value={parentPath}
+        value={displayName}
         disabled={readOnly}
         onChange={(e) => setChecked(e.currentTarget.checked)}>
-        {buttonName}
+        {displayName}
+        <DocStringComponent docString={docString} />
       </ToggleButton>
     </div>
   );

frontend/src/components/ColouredEnumComponent.tsx

@@ -1,11 +1,9 @@
-import React, { useEffect, useRef } from 'react';
+import React, { useEffect, useRef, useState } from 'react';
 import { InputGroup, Form, Row, Col } from 'react-bootstrap';
-import { setAttribute } from '../socket';
 import { DocStringComponent } from './DocStringComponent';
-import { getIdFromFullAccessPath } from '../utils/stringUtils';
 import { LevelName } from './NotificationsComponent';
 
-interface ColouredEnumComponentProps {
+type ColouredEnumComponentProps = {
   name: string;
   parentPath: string;
   value: string;
@@ -13,56 +11,81 @@ interface ColouredEnumComponentProps {
   readOnly: boolean;
   enumDict: Record<string, string>;
   addNotification: (message: string, levelname?: LevelName) => void;
-}
+  changeCallback?: (
+    value: unknown,
+    attributeName?: string,
+    prefix?: string,
+    callback?: (ack: unknown) => void
+  ) => void;
+  displayName: string;
+  id: string;
+};
 
 export const ColouredEnumComponent = React.memo((props: ColouredEnumComponentProps) => {
   const {
     name,
-    parentPath: parentPath,
     value,
     docString,
     enumDict,
     readOnly,
-    addNotification
+    addNotification,
+    displayName,
+    id
   } = props;
+  let { changeCallback } = props;
+  if (changeCallback === undefined) {
+    changeCallback = (value: string) => {
+      setEnumValue(() => {
+        return value;
+      });
+    };
+  }
+
   const renderCount = useRef(0);
-  const id = getIdFromFullAccessPath(parentPath.concat('.' + name));
+  const [enumValue, setEnumValue] = useState(value);
+
+  const fullAccessPath = [props.parentPath, props.name]
+    .filter((element) => element)
+    .join('.');
 
   useEffect(() => {
     renderCount.current++;
   });
 
   useEffect(() => {
-    addNotification(`${parentPath}.${name} changed to ${value}.`);
+    setEnumValue(() => {
+      return props.value;
+    });
+    addNotification(`${fullAccessPath} changed to ${value}.`);
   }, [props.value]);
 
-  const handleValueChange = (newValue: string) => {
-    setAttribute(name, parentPath, newValue);
-  };
-
   return (
-    <div className={'enumComponent'} id={id}>
+    <div className={'component enumComponent'} id={id}>
       {process.env.NODE_ENV === 'development' && (
         <div>Render count: {renderCount.current}</div>
       )}
-      <DocStringComponent docString={docString} />
       <Row>
         <Col className="d-flex align-items-center">
-          <InputGroup.Text>{name}</InputGroup.Text>
+          <InputGroup.Text>
+            {displayName}
+            <DocStringComponent docString={docString} />
+          </InputGroup.Text>
           {readOnly ? (
             // Display the Form.Control when readOnly is true
             <Form.Control
-              value={value}
+              value={enumValue}
+              name={name}
               disabled={true}
-              style={{ backgroundColor: enumDict[value] }}
+              style={{ backgroundColor: enumDict[enumValue] }}
             />
           ) : (
             // Display the Form.Select when readOnly is false
             <Form.Select
               aria-label="coloured-enum-select"
-              value={value}
-              style={{ backgroundColor: enumDict[value] }}
-              onChange={(event) => handleValueChange(event.target.value)}>
+              value={enumValue}
+              name={name}
+              style={{ backgroundColor: enumDict[enumValue] }}
+              onChange={(event) => changeCallback(event.target.value)}>
               {Object.entries(enumDict).map(([key]) => (
                 <option key={key} value={key}>
                   {key}

frontend/src/components/DataServiceComponent.tsx

@@ -2,8 +2,7 @@ import { useState } from 'react';
 import React from 'react';
 import { Card, Collapse } from 'react-bootstrap';
 import { ChevronDown, ChevronRight } from 'react-bootstrap-icons';
-import { Attribute, GenericComponent } from './GenericComponent';
-import { getIdFromFullAccessPath } from '../utils/stringUtils';
+import { SerializedValue, GenericComponent } from './GenericComponent';
 import { LevelName } from './NotificationsComponent';
 
 type DataServiceProps = {
@@ -12,38 +11,35 @@ type DataServiceProps = {
   parentPath?: string;
   isInstantUpdate: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
+  displayName: string;
+  id: string;
 };
 
-export type DataServiceJSON = Record<string, Attribute>;
+export type DataServiceJSON = Record<string, SerializedValue>;
 
 export const DataServiceComponent = React.memo(
   ({
     name,
     props,
-    parentPath = 'DataService',
+    parentPath = undefined,
     isInstantUpdate,
-    addNotification
+    addNotification,
+    displayName,
+    id
   }: DataServiceProps) => {
     const [open, setOpen] = useState(true);
-    let fullAccessPath = parentPath;
-    if (name) {
-      fullAccessPath = parentPath.concat('.' + name);
-    }
-    const id = getIdFromFullAccessPath(fullAccessPath);
+    const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
 
-    return (
-      <div className="dataServiceComponent" id={id}>
-        <Card className="mb-3">
-          <Card.Header
-            onClick={() => setOpen(!open)}
-            style={{ cursor: 'pointer' }} // Change cursor style on hover
-          >
-            {fullAccessPath} {open ? <ChevronDown /> : <ChevronRight />}
-          </Card.Header>
-          <Collapse in={open}>
-            <Card.Body>
-              {Object.entries(props).map(([key, value]) => {
-                return (
+    if (displayName !== '') {
+      return (
+        <div className="component dataServiceComponent" id={id}>
+          <Card>
+            <Card.Header onClick={() => setOpen(!open)} style={{ cursor: 'pointer' }}>
+              {displayName} {open ? <ChevronDown /> : <ChevronRight />}
+            </Card.Header>
+            <Collapse in={open}>
+              <Card.Body>
+                {Object.entries(props).map(([key, value]) => (
                   <GenericComponent
                     key={key}
                     attribute={value}
@@ -52,12 +48,27 @@ export const DataServiceComponent = React.memo(
                     isInstantUpdate={isInstantUpdate}
                     addNotification={addNotification}
                   />
-                );
-              })}
-            </Card.Body>
-          </Collapse>
-        </Card>
-      </div>
-    );
+                ))}
+              </Card.Body>
+            </Collapse>
+          </Card>
+        </div>
+      );
+    } else {
+      return (
+        <div className="component dataServiceComponent" id={id}>
+          {Object.entries(props).map(([key, value]) => (
+            <GenericComponent
+              key={key}
+              attribute={value}
+              name={key}
+              parentPath={fullAccessPath}
+              isInstantUpdate={isInstantUpdate}
+              addNotification={addNotification}
+            />
+          ))}
+        </div>
+      );
+    }
   }
 );

frontend/src/components/DeviceConnection.tsx

@@ -0,0 +1,61 @@
+import React from 'react';
+import { LevelName } from './NotificationsComponent';
+import { DataServiceComponent, DataServiceJSON } from './DataServiceComponent';
+import { MethodComponent } from './MethodComponent';
+
+type DeviceConnectionProps = {
+  name: string;
+  props: DataServiceJSON;
+  parentPath: string;
+  isInstantUpdate: boolean;
+  addNotification: (message: string, levelname?: LevelName) => void;
+  displayName: string;
+  id: string;
+};
+
+export const DeviceConnectionComponent = React.memo(
+  ({
+    name,
+    props,
+    parentPath,
+    isInstantUpdate,
+    addNotification,
+    displayName,
+    id
+  }: DeviceConnectionProps) => {
+    const { connected, connect, ...updatedProps } = props;
+    const connectedVal = connected.value;
+
+    const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
+
+    return (
+      <div className="deviceConnectionComponent" id={id}>
+        {!connectedVal && (
+          <div className="overlayContent">
+            <div>
+              {displayName != '' ? displayName : 'Device'} is currently not available!
+            </div>
+            <MethodComponent
+              name="connect"
+              parentPath={fullAccessPath}
+              docString={connect.doc}
+              addNotification={addNotification}
+              displayName={'reconnect'}
+              id={id + '-connect'}
+              render={true}
+            />
+          </div>
+        )}
+        <DataServiceComponent
+          name={name}
+          props={updatedProps}
+          parentPath={parentPath}
+          isInstantUpdate={isInstantUpdate}
+          addNotification={addNotification}
+          displayName={displayName}
+          id={id}
+        />
+      </div>
+    );
+  }
+);

frontend/src/components/DocStringComponent.tsx

@@ -1,9 +1,9 @@
 import { Badge, Tooltip, OverlayTrigger } from 'react-bootstrap';
 import React from 'react';
 
-interface DocStringProps {
+type DocStringProps = {
   docString?: string;
-}
+};
 
 export const DocStringComponent = React.memo((props: DocStringProps) => {
   const { docString } = props;

frontend/src/components/EnumComponent.tsx

@@ -1,61 +1,93 @@
-import React, { useEffect, useRef } from 'react';
+import React, { useEffect, useRef, useState } from 'react';
 import { InputGroup, Form, Row, Col } from 'react-bootstrap';
-import { setAttribute } from '../socket';
 import { DocStringComponent } from './DocStringComponent';
 import { LevelName } from './NotificationsComponent';
 
-interface EnumComponentProps {
+type EnumComponentProps = {
   name: string;
   parentPath: string;
   value: string;
   docString?: string;
+  readOnly: boolean;
   enumDict: Record<string, string>;
   addNotification: (message: string, levelname?: LevelName) => void;
-}
+  changeCallback?: (
+    value: unknown,
+    attributeName?: string,
+    prefix?: string,
+    callback?: (ack: unknown) => void
+  ) => void;
+  displayName: string;
+  id: string;
+};
 
 export const EnumComponent = React.memo((props: EnumComponentProps) => {
   const {
     name,
-    parentPath: parentPath,
     value,
     docString,
     enumDict,
-    addNotification
+    addNotification,
+    displayName,
+    id,
+    readOnly
   } = props;
 
+  let { changeCallback } = props;
+  if (changeCallback === undefined) {
+    changeCallback = (value: string) => {
+      setEnumValue(() => {
+        return value;
+      });
+    };
+  }
   const renderCount = useRef(0);
+  const [enumValue, setEnumValue] = useState(value);
+
+  const fullAccessPath = [props.parentPath, props.name]
+    .filter((element) => element)
+    .join('.');
 
   useEffect(() => {
     renderCount.current++;
   });
 
   useEffect(() => {
-    addNotification(`${parentPath}.${name} changed to ${value}.`);
+    setEnumValue(() => {
+      return props.value;
+    });
+    addNotification(`${fullAccessPath} changed to ${value}.`);
   }, [props.value]);
 
-  const handleValueChange = (newValue: string) => {
-    setAttribute(name, parentPath, newValue);
-  };
-
   return (
-    <div className={'enumComponent'} id={parentPath.concat('.' + name)}>
+    <div className={'component enumComponent'} id={id}>
       {process.env.NODE_ENV === 'development' && (
         <div>Render count: {renderCount.current}</div>
       )}
-      <DocStringComponent docString={docString} />
       <Row>
         <Col className="d-flex align-items-center">
-          <InputGroup.Text>{name}</InputGroup.Text>
-          <Form.Select
-            aria-label="Default select example"
-            value={value}
-            onChange={(event) => handleValueChange(event.target.value)}>
-            {Object.entries(enumDict).map(([key, val]) => (
-              <option key={key} value={key}>
-                {key} - {val}
-              </option>
-            ))}
-          </Form.Select>
+          <InputGroup.Text>
+            {displayName}
+            <DocStringComponent docString={docString} />
+          </InputGroup.Text>
+
+          {readOnly ? (
+            // Display the Form.Control when readOnly is true
+            <Form.Control value={enumDict[enumValue]} name={name} disabled={true} />
+          ) : (
+            // Display the Form.Select when readOnly is false
+            <Form.Select
+              aria-label="example-select"
+              value={enumValue}
+              name={name}
+              onChange={(event) => changeCallback(event.target.value)}>
+              {Object.entries(enumDict).map(([key, val]) => (
+                <option key={key} value={key}>
+                  {val}
+                </option>
+              ))}
+            </Form.Select>
+          )}
         </Col>
       </Row>
     </div>

frontend/src/components/GenericComponent.tsx

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { useContext } from 'react';
 import { ButtonComponent } from './ButtonComponent';
 import { NumberComponent } from './NumberComponent';
 import { SliderComponent } from './SliderComponent';
@@ -8,9 +8,13 @@ import { AsyncMethodComponent } from './AsyncMethodComponent';
 import { StringComponent } from './StringComponent';
 import { ListComponent } from './ListComponent';
 import { DataServiceComponent, DataServiceJSON } from './DataServiceComponent';
+import { DeviceConnectionComponent } from './DeviceConnection';
 import { ImageComponent } from './ImageComponent';
 import { ColouredEnumComponent } from './ColouredEnumComponent';
 import { LevelName } from './NotificationsComponent';
+import { getIdFromFullAccessPath } from '../utils/stringUtils';
+import { WebSettingsContext } from '../WebSettings';
+import { setAttribute } from '../socket';
 
 type AttributeType =
   | 'str'
@@ -21,23 +25,24 @@ type AttributeType =
   | 'list'
   | 'method'
   | 'DataService'
+  | 'DeviceConnection'
   | 'Enum'
   | 'NumberSlider'
   | 'Image'
   | 'ColouredEnum';
 
-type ValueType = boolean | string | number | object;
-export interface Attribute {
+type ValueType = boolean | string | number | Record<string, unknown>;
+export type SerializedValue = {
   type: AttributeType;
   value?: ValueType | ValueType[];
   readonly: boolean;
   doc?: string | null;
-  parameters?: Record<string, string>;
   async?: boolean;
+  frontend_render?: boolean;
   enum?: Record<string, string>;
-}
+};
 type GenericComponentProps = {
-  attribute: Attribute;
+  attribute: SerializedValue;
   name: string;
   parentPath: string;
   isInstantUpdate: boolean;
@@ -52,6 +57,29 @@ export const GenericComponent = React.memo(
     isInstantUpdate,
     addNotification
   }: GenericComponentProps) => {
+    const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
+    const id = getIdFromFullAccessPath(fullAccessPath);
+    const webSettings = useContext(WebSettingsContext);
+    let displayName = name;
+
+    if (webSettings[fullAccessPath]) {
+      if (webSettings[fullAccessPath].display === false) {
+        return null;
+      }
+      if (webSettings[fullAccessPath].displayName) {
+        displayName = webSettings[fullAccessPath].displayName;
+      }
+    }
+
+    function changeCallback(
+      value: unknown,
+      attributeName: string = name,
+      prefix: string = parentPath,
+      callback: (ack: unknown) => void = undefined
+    ) {
+      setAttribute(attributeName, prefix, value, callback);
+    }
+
     if (attribute.type === 'bool') {
       return (
         <ButtonComponent
@@ -61,6 +89,9 @@ export const GenericComponent = React.memo(
           readOnly={attribute.readonly}
           value={Boolean(attribute.value)}
           addNotification={addNotification}
+          changeCallback={changeCallback}
+          displayName={displayName}
+          id={id}
         />
       );
     } else if (attribute.type === 'float' || attribute.type === 'int') {
@@ -74,6 +105,9 @@ export const GenericComponent = React.memo(
           value={Number(attribute.value)}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
+          changeCallback={changeCallback}
+          displayName={displayName}
+          id={id}
         />
       );
     } else if (attribute.type === 'Quantity') {
@@ -88,6 +122,9 @@ export const GenericComponent = React.memo(
           unit={attribute.value['unit']}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
+          changeCallback={changeCallback}
+          displayName={displayName}
+          id={id}
         />
       );
     } else if (attribute.type === 'NumberSlider') {
@@ -95,7 +132,7 @@ export const GenericComponent = React.memo(
         <SliderComponent
           name={name}
           parentPath={parentPath}
-          docString={attribute.doc}
+          docString={attribute.value['value'].doc}
           readOnly={attribute.readonly}
           value={attribute.value['value']}
           min={attribute.value['min']}
@@ -103,6 +140,9 @@ export const GenericComponent = React.memo(
           stepSize={attribute.value['step_size']}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
+          changeCallback={changeCallback}
+          displayName={displayName}
+          id={id}
         />
       );
     } else if (attribute.type === 'Enum') {
@@ -112,8 +152,12 @@ export const GenericComponent = React.memo(
           parentPath={parentPath}
           docString={attribute.doc}
           value={String(attribute.value)}
+          readOnly={attribute.readonly}
           enumDict={attribute.enum}
           addNotification={addNotification}
+          changeCallback={changeCallback}
+          displayName={displayName}
+          id={id}
         />
       );
     } else if (attribute.type === 'method') {
@@ -123,8 +167,10 @@ export const GenericComponent = React.memo(
             name={name}
             parentPath={parentPath}
             docString={attribute.doc}
-            parameters={attribute.parameters}
             addNotification={addNotification}
+            displayName={displayName}
+            id={id}
+            render={attribute.frontend_render}
           />
         );
       } else {
@@ -133,9 +179,11 @@ export const GenericComponent = React.memo(
             name={name}
             parentPath={parentPath}
             docString={attribute.doc}
-            parameters={attribute.parameters}
             value={attribute.value as Record<string, string>}
             addNotification={addNotification}
+            displayName={displayName}
+            id={id}
+            render={attribute.frontend_render}
           />
         );
       }
@@ -149,6 +197,9 @@ export const GenericComponent = React.memo(
           parentPath={parentPath}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
+          changeCallback={changeCallback}
+          displayName={displayName}
+          id={id}
         />
       );
     } else if (attribute.type === 'DataService') {
@@ -159,17 +210,32 @@ export const GenericComponent = React.memo(
           parentPath={parentPath}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
+          displayName={displayName}
+          id={id}
+        />
+      );
+    } else if (attribute.type === 'DeviceConnection') {
+      return (
+        <DeviceConnectionComponent
+          name={name}
+          props={attribute.value as DataServiceJSON}
+          parentPath={parentPath}
+          isInstantUpdate={isInstantUpdate}
+          addNotification={addNotification}
+          displayName={displayName}
+          id={id}
         />
       );
     } else if (attribute.type === 'list') {
       return (
         <ListComponent
           name={name}
-          value={attribute.value as Attribute[]}
+          value={attribute.value as SerializedValue[]}
           docString={attribute.doc}
           parentPath={parentPath}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
+          id={id}
         />
       );
     } else if (attribute.type === 'Image') {
@@ -177,16 +243,16 @@ export const GenericComponent = React.memo(
         <ImageComponent
           name={name}
           parentPath={parentPath}
-          value={attribute.value['value']['value'] as string}
-          readOnly={attribute.readonly}
-          docString={attribute.doc}
-          // Add any other specific props for the ImageComponent here
-          format={attribute.value['format']['value'] as string}
+          docString={attribute.value['value'].doc}
+          displayName={displayName}
+          id={id}
           addNotification={addNotification}
+          // Add any other specific props for the ImageComponent here
+          value={attribute.value['value']['value'] as string}
+          format={attribute.value['format']['value'] as string}
         />
       );
     } else if (attribute.type === 'ColouredEnum') {
-      console.log(attribute);
       return (
         <ColouredEnumComponent
           name={name}
@@ -196,6 +262,9 @@ export const GenericComponent = React.memo(
           readOnly={attribute.readonly}
           enumDict={attribute.enum}
           addNotification={addNotification}
+          changeCallback={changeCallback}
+          displayName={displayName}
+          id={id}
         />
       );
     } else {

frontend/src/components/ImageComponent.tsx

@@ -2,53 +2,52 @@ import React, { useEffect, useRef, useState } from 'react';
 import { Card, Collapse, Image } from 'react-bootstrap';
 import { DocStringComponent } from './DocStringComponent';
 import { ChevronDown, ChevronRight } from 'react-bootstrap-icons';
-import { getIdFromFullAccessPath } from '../utils/stringUtils';
 import { LevelName } from './NotificationsComponent';
 
-interface ImageComponentProps {
+type ImageComponentProps = {
   name: string;
   parentPath: string;
   value: string;
-  readOnly: boolean;
   docString: string;
   format: string;
   addNotification: (message: string, levelname?: LevelName) => void;
-}
+  displayName: string;
+  id: string;
+};
 
 export const ImageComponent = React.memo((props: ImageComponentProps) => {
-  const { name, parentPath, value, docString, format, addNotification } = props;
+  const { value, docString, format, addNotification, displayName, id } = props;
 
   const renderCount = useRef(0);
   const [open, setOpen] = useState(true);
-  const id = getIdFromFullAccessPath(parentPath.concat('.' + name));
+  const fullAccessPath = [props.parentPath, props.name]
+    .filter((element) => element)
+    .join('.');
 
   useEffect(() => {
     renderCount.current++;
   });
 
   useEffect(() => {
-    addNotification(`${parentPath}.${name} changed.`);
+    addNotification(`${fullAccessPath} changed.`);
   }, [props.value]);
 
   return (
-    <div className={'imageComponent'} id={id}>
-      {process.env.NODE_ENV === 'development' && (
-        <div>Render count: {renderCount.current}</div>
-      )}
+    <div className="component imageComponent" id={id}>
       <Card>
         <Card.Header
           onClick={() => setOpen(!open)}
           style={{ cursor: 'pointer' }} // Change cursor style on hover
         >
-          {name} {open ? <ChevronDown /> : <ChevronRight />}
+          {displayName}
+          <DocStringComponent docString={docString} />
+          {open ? <ChevronDown /> : <ChevronRight />}
         </Card.Header>
         <Collapse in={open}>
           <Card.Body>
             {process.env.NODE_ENV === 'development' && (
               <p>Render count: {renderCount.current}</p>
             )}
-            <DocStringComponent docString={docString} />
-            {/* Your component JSX here */}
             {format === '' && value === '' ? (
               <p>No image set in the backend.</p>
             ) : (

frontend/src/components/ListComponent.tsx

@@ -1,24 +1,23 @@
 import React, { useEffect, useRef } from 'react';
 import { DocStringComponent } from './DocStringComponent';
-import { Attribute, GenericComponent } from './GenericComponent';
-import { getIdFromFullAccessPath } from '../utils/stringUtils';
+import { SerializedValue, GenericComponent } from './GenericComponent';
 import { LevelName } from './NotificationsComponent';
 
-interface ListComponentProps {
+type ListComponentProps = {
   name: string;
   parentPath?: string;
-  value: Attribute[];
+  value: SerializedValue[];
   docString: string;
   isInstantUpdate: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
-}
+  id: string;
+};
 
 export const ListComponent = React.memo((props: ListComponentProps) => {
-  const { name, parentPath, value, docString, isInstantUpdate, addNotification } =
+  const { name, parentPath, value, docString, isInstantUpdate, addNotification, id } =
     props;
 
   const renderCount = useRef(0);
-  const id = getIdFromFullAccessPath(parentPath.concat('.' + name));
 
   useEffect(() => {
     renderCount.current++;

frontend/src/components/MethodComponent.tsx

@@ -1,110 +1,59 @@
-import React, { useState, useEffect, useRef } from 'react';
+import React, { useEffect, useRef } from 'react';
 import { runMethod } from '../socket';
-import { Button, InputGroup, Form, Collapse } from 'react-bootstrap';
+import { Button, Form } from 'react-bootstrap';
 import { DocStringComponent } from './DocStringComponent';
-import { getIdFromFullAccessPath } from '../utils/stringUtils';
 import { LevelName } from './NotificationsComponent';
 
-interface MethodProps {
+type MethodProps = {
   name: string;
   parentPath: string;
-  parameters: Record<string, string>;
   docString?: string;
-  hideOutput?: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
-}
+  displayName: string;
+  id: string;
+  render: boolean;
+};
 
 export const MethodComponent = React.memo((props: MethodProps) => {
-  const { name, parentPath, docString, addNotification } = props;
+  const { name, parentPath, docString, addNotification, displayName, id } = props;
+
+  // Conditional rendering based on the 'render' prop.
+  if (!props.render) {
+    return null;
+  }
 
   const renderCount = useRef(0);
-  const [hideOutput, setHideOutput] = useState(false);
-  // Add a new state variable to hold the list of function calls
-  const [functionCalls, setFunctionCalls] = useState([]);
-  const id = getIdFromFullAccessPath(parentPath.concat('.' + name));
+  const formRef = useRef(null);
+  const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
 
-  useEffect(() => {
-    renderCount.current++;
-    if (props.hideOutput !== undefined) {
-      setHideOutput(props.hideOutput);
-    }
-  });
+  const triggerNotification = () => {
+    const message = `Method ${fullAccessPath} was triggered.`;
 
-  const triggerNotification = (args: Record<string, string>) => {
-    const argsString = Object.entries(args)
-      .map(([key, value]) => `${key}: "${value}"`)
-      .join(', ');
-    let message = `Method ${parentPath}.${name} was triggered`;
-
-    if (argsString === '') {
-      message += '.';
-    } else {
-      message += ` with arguments {${argsString}}.`;
-    }
     addNotification(message);
   };
 
   const execute = async (event: React.FormEvent) => {
     event.preventDefault();
+    runMethod(name, parentPath, {});
 
-    const kwargs = {};
-    Object.keys(props.parameters).forEach(
-      (name) => (kwargs[name] = event.target[name].value)
-    );
-    runMethod(name, parentPath, kwargs, (ack) => {
-      // Update the functionCalls state with the new call if we get an acknowledge msg
-      if (ack !== undefined) {
-        setFunctionCalls((prevCalls) => [
-          ...prevCalls,
-          { name, args: kwargs, result: ack }
-        ]);
-      }
-    });
-
-    triggerNotification(kwargs);
+    triggerNotification();
   };
 
-  const args = Object.entries(props.parameters).map(([name, type], index) => {
-    const form_name = `${name} (${type})`;
-    return (
-      <InputGroup key={index}>
-        <InputGroup.Text className="component-label">{form_name}</InputGroup.Text>
-        <Form.Control type="text" name={name} />
-      </InputGroup>
-    );
+  useEffect(() => {
+    renderCount.current++;
   });
 
   return (
-    <div className="align-items-center methodComponent" id={id}>
+    <div className="component methodComponent" id={id}>
       {process.env.NODE_ENV === 'development' && (
         <div>Render count: {renderCount.current}</div>
       )}
-      <h5 onClick={() => setHideOutput(!hideOutput)} style={{ cursor: 'pointer' }}>
-        Function: {name}
-        <DocStringComponent docString={docString} />
-      </h5>
-      <Form onSubmit={execute}>
-        {args}
-        <Button variant="primary" type="submit">
-          Execute
+      <Form onSubmit={execute} ref={formRef}>
+        <Button className="component" variant="primary" type="submit">
+          {`${displayName} `}
+          <DocStringComponent docString={docString} />
         </Button>
       </Form>
-
-      <Collapse in={!hideOutput}>
-        <div id="function-output">
-          {functionCalls.map((call, index) => (
-            <div key={index}>
-              <div style={{ color: 'grey', fontSize: 'small' }}>
-                {Object.entries(call.args)
-                  .map(([key, val]) => `${key}=${JSON.stringify(val)}`)
-                  .join(', ') +
-                  ' => ' +
-                  JSON.stringify(call.result)}
-              </div>
-            </div>
-          ))}
-        </div>
-      </Collapse>
     </div>
   );
 });

frontend/src/components/NumberComponent.tsx

@@ -1,9 +1,7 @@
-import React, { useEffect, useRef, useState } from 'react';
+import React, { useEffect, useState, useRef } from 'react';
 import { Form, InputGroup } from 'react-bootstrap';
-import { setAttribute } from '../socket';
 import { DocStringComponent } from './DocStringComponent';
 import '../App.css';
-import { getIdFromFullAccessPath } from '../utils/stringUtils';
 import { LevelName } from './NotificationsComponent';
 
 // TODO: add button functionality
@@ -31,7 +29,7 @@ export type FloatObject = {
 };
 export type NumberObject = IntObject | FloatObject | QuantityObject;
 
-interface NumberComponentProps {
+type NumberComponentProps = {
   name: string;
   type: 'float' | 'int';
   parentPath?: string;
@@ -40,9 +38,16 @@ interface NumberComponentProps {
   docString: string;
   isInstantUpdate: boolean;
   unit?: string;
-  showName?: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
-}
+  changeCallback?: (
+    value: unknown,
+    attributeName?: string,
+    prefix?: string,
+    callback?: (ack: unknown) => void
+  ) => void;
+  displayName?: string;
+  id: string;
+};
 
 // TODO: highlight the digit that is being changed by setting both selectionStart and
 // selectionEnd
@@ -127,86 +132,57 @@ const handleDeleteKey = (
   return { value, selectionStart };
 };
 
+const handleNumericKey = (
+  key: string,
+  value: string,
+  selectionStart: number,
+  selectionEnd: number
+) => {
+  // Check if a number key or a decimal point key is pressed
+  if (key === '.' && value.includes('.')) {
+    // Check if value already contains a decimal. If so, ignore input.
+    console.warn('Invalid input! Ignoring...');
+    return { value, selectionStart };
+  }
+
+  let newValue = value;
+
+  // Add the new key at the cursor's position
+  if (selectionEnd > selectionStart) {
+    // If there is a selection, replace it with the key
+    newValue = value.slice(0, selectionStart) + key + value.slice(selectionEnd);
+  } else {
+    // otherwise, append the key after the selection start
+    newValue = value.slice(0, selectionStart) + key + value.slice(selectionStart);
+  }
+
+  return { value: newValue, selectionStart: selectionStart + 1 };
+};
+
 export const NumberComponent = React.memo((props: NumberComponentProps) => {
   const {
     name,
-    parentPath,
+    value,
     readOnly,
+    type,
     docString,
     isInstantUpdate,
     unit,
-    addNotification
+    addNotification,
+    changeCallback = () => {},
+    displayName,
+    id
   } = props;
 
-  // Whether to show the name infront of the component (false if used with a slider)
-  const showName = props.showName !== undefined ? props.showName : true;
-
-  const renderCount = useRef(0);
   // Create a state for the cursor position
   const [cursorPosition, setCursorPosition] = useState(null);
   // Create a state for the input string
-  const [inputString, setInputString] = useState(props.value.toString());
-  const fullAccessPath = parentPath.concat('.' + name);
-  const id = getIdFromFullAccessPath(fullAccessPath);
+  const [inputString, setInputString] = useState(value.toString());
+  const renderCount = useRef(0);
+  const fullAccessPath = [props.parentPath, props.name]
+    .filter((element) => element)
+    .join('.');
 
-  useEffect(() => {
-    renderCount.current++;
-
-    // Set the cursor position after the component re-renders
-    const inputElement = document.getElementsByName(
-      fullAccessPath
-    )[0] as HTMLInputElement;
-    if (inputElement && cursorPosition !== null) {
-      inputElement.setSelectionRange(cursorPosition, cursorPosition);
-    }
-  });
-
-  useEffect(() => {
-    // Parse the input string to a number for comparison
-    const numericInputString =
-      props.type === 'int' ? parseInt(inputString) : parseFloat(inputString);
-    // Only update the inputString if it's different from the prop value
-    if (props.value !== numericInputString) {
-      setInputString(props.value.toString());
-    }
-
-    // emitting notification
-    let notificationMsg = `${parentPath}.${name} changed to ${props.value}`;
-    if (unit === undefined) {
-      notificationMsg += '.';
-    } else {
-      notificationMsg += ` ${unit}.`;
-    }
-    addNotification(notificationMsg);
-  }, [props.value]);
-
-  const handleNumericKey = (
-    key: string,
-    value: string,
-    selectionStart: number,
-    selectionEnd: number
-  ) => {
-    // Check if a number key or a decimal point key is pressed
-    if (key === '.' && (value.includes('.') || props.type === 'int')) {
-      // Check if value already contains a decimal. If so, ignore input.
-      // eslint-disable-next-line no-console
-      console.warn('Invalid input! Ignoring...');
-      return { value, selectionStart };
-    }
-
-    let newValue = value;
-
-    // Add the new key at the cursor's position
-    if (selectionEnd > selectionStart) {
-      // If there is a selection, replace it with the key
-      newValue = value.slice(0, selectionStart) + key + value.slice(selectionEnd);
-    } else {
-      // otherwise, append the key after the selection start
-      newValue = value.slice(0, selectionStart) + key + value.slice(selectionStart);
-    }
-
-    return { value: newValue, selectionStart: selectionStart + 1 };
-  };
   const handleKeyDown = (event) => {
     const { key, target } = event;
     if (
@@ -249,7 +225,7 @@ export const NumberComponent = React.memo((props: NumberComponentProps) => {
         selectionStart,
         selectionEnd
       ));
-    } else if (key === '.') {
+    } else if (key === '.' && type === 'float') {
       ({ value: newValue, selectionStart } = handleNumericKey(
         key,
         value,
@@ -276,7 +252,7 @@ export const NumberComponent = React.memo((props: NumberComponentProps) => {
         selectionEnd
       ));
     } else if (key === 'Enter' && !isInstantUpdate) {
-      setAttribute(name, parentPath, Number(newValue));
+      changeCallback(Number(newValue));
       return;
     } else {
       console.debug(key);
@@ -285,7 +261,7 @@ export const NumberComponent = React.memo((props: NumberComponentProps) => {
 
     // Update the input value and maintain the cursor position
     if (isInstantUpdate) {
-      setAttribute(name, parentPath, Number(newValue));
+      changeCallback(Number(newValue));
     }
 
     setInputString(newValue);
@@ -297,31 +273,59 @@ export const NumberComponent = React.memo((props: NumberComponentProps) => {
   const handleBlur = () => {
     if (!isInstantUpdate) {
       // If not in "instant update" mode, emit an update when the input field loses focus
-      setAttribute(name, parentPath, Number(inputString));
+      changeCallback(Number(inputString));
     }
   };
+  useEffect(() => {
+    // Parse the input string to a number for comparison
+    const numericInputString =
+      type === 'int' ? parseInt(inputString) : parseFloat(inputString);
+    // Only update the inputString if it's different from the prop value
+    if (value !== numericInputString) {
+      setInputString(value.toString());
+    }
+
+    // emitting notification
+    let notificationMsg = `${fullAccessPath} changed to ${props.value}`;
+    if (unit === undefined) {
+      notificationMsg += '.';
+    } else {
+      notificationMsg += ` ${unit}.`;
+    }
+    addNotification(notificationMsg);
+  }, [value]);
+
+  useEffect(() => {
+    // Set the cursor position after the component re-renders
+    const inputElement = document.getElementsByName(name)[0] as HTMLInputElement;
+    if (inputElement && cursorPosition !== null) {
+      inputElement.setSelectionRange(cursorPosition, cursorPosition);
+    }
+  });
 
   return (
-    <div className="numberComponent" id={id}>
+    <div className="component numberComponent" id={id}>
       {process.env.NODE_ENV === 'development' && (
         <div>Render count: {renderCount.current}</div>
       )}
-      <DocStringComponent docString={docString} />
-      <div className="d-flex">
-        <InputGroup>
-          {showName && <InputGroup.Text>{name}</InputGroup.Text>}
-          <Form.Control
-            type="text"
-            value={inputString}
-            disabled={readOnly}
-            name={fullAccessPath}
-            onKeyDown={handleKeyDown}
-            onBlur={handleBlur}
-            className={isInstantUpdate && !readOnly ? 'instantUpdate' : ''}
-          />
-          {unit && <InputGroup.Text>{unit}</InputGroup.Text>}
-        </InputGroup>
-      </div>
+      <InputGroup>
+        {displayName && (
+          <InputGroup.Text>
+            {displayName}
+            <DocStringComponent docString={docString} />
+          </InputGroup.Text>
+        )}
+        <Form.Control
+          type="text"
+          value={inputString}
+          disabled={readOnly}
+          name={name}
+          onKeyDown={handleKeyDown}
+          onBlur={handleBlur}
+          className={isInstantUpdate && !readOnly ? 'instantUpdate' : ''}
+        />
+        {unit && <InputGroup.Text>{unit}</InputGroup.Text>}
+      </InputGroup>
     </div>
   );
 });

frontend/src/components/SliderComponent.tsx

@@ -1,13 +1,11 @@
 import React, { useEffect, useRef, useState } from 'react';
 import { InputGroup, Form, Row, Col, Collapse, ToggleButton } from 'react-bootstrap';
-import { setAttribute } from '../socket';
 import { DocStringComponent } from './DocStringComponent';
 import { Slider } from '@mui/material';
 import { NumberComponent, NumberObject } from './NumberComponent';
-import { getIdFromFullAccessPath } from '../utils/stringUtils';
 import { LevelName } from './NotificationsComponent';
 
-interface SliderComponentProps {
+type SliderComponentProps = {
   name: string;
   min: NumberObject;
   max: NumberObject;
@@ -18,7 +16,15 @@ interface SliderComponentProps {
   stepSize: NumberObject;
   isInstantUpdate: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
-}
+  changeCallback?: (
+    value: unknown,
+    attributeName?: string,
+    prefix?: string,
+    callback?: (ack: unknown) => void
+  ) => void;
+  displayName: string;
+  id: string;
+};
 
 export const SliderComponent = React.memo((props: SliderComponentProps) => {
   const renderCount = useRef(0);
@@ -32,29 +38,31 @@ export const SliderComponent = React.memo((props: SliderComponentProps) => {
     stepSize,
     docString,
     isInstantUpdate,
-    addNotification
+    addNotification,
+    changeCallback = () => {},
+    displayName,
+    id
   } = props;
-  const fullAccessPath = parentPath.concat('.' + name);
-  const id = getIdFromFullAccessPath(fullAccessPath);
+  const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
 
   useEffect(() => {
     renderCount.current++;
   });
 
   useEffect(() => {
-    addNotification(`${parentPath}.${name} changed to ${value}.`);
+    addNotification(`${fullAccessPath} changed to ${value.value}.`);
   }, [props.value]);
 
   useEffect(() => {
-    addNotification(`${parentPath}.${name}.min changed to ${min}.`);
+    addNotification(`${fullAccessPath}.min changed to ${min.value}.`);
   }, [props.min]);
 
   useEffect(() => {
-    addNotification(`${parentPath}.${name}.max changed to ${max}.`);
+    addNotification(`${fullAccessPath}.max changed to ${max.value}.`);
   }, [props.max]);
 
   useEffect(() => {
-    addNotification(`${parentPath}.${name}.stepSize changed to ${stepSize}.`);
+    addNotification(`${fullAccessPath}.stepSize changed to ${stepSize.value}.`);
   }, [props.stepSize]);
 
   const handleOnChange = (event, newNumber: number | number[]) => {
@@ -63,11 +71,11 @@ export const SliderComponent = React.memo((props: SliderComponentProps) => {
     if (Array.isArray(newNumber)) {
       newNumber = newNumber[0];
     }
-    setAttribute(`${name}.value`, parentPath, newNumber);
+    changeCallback(newNumber, `${name}.value`);
   };
 
   const handleValueChange = (newValue: number, valueType: string) => {
-    setAttribute(`${name}.${valueType}`, parentPath, newValue);
+    changeCallback(newValue, `${name}.${valueType}`);
   };
 
   const deconstructNumberDict = (
@@ -93,15 +101,17 @@ export const SliderComponent = React.memo((props: SliderComponentProps) => {
   const [stepSizeMagnitude, stepSizeReadOnly] = deconstructNumberDict(stepSize);
 
   return (
-    <div className="sliderComponent" id={id}>
+    <div className="component sliderComponent" id={id}>
       {process.env.NODE_ENV === 'development' && (
         <div>Render count: {renderCount.current}</div>
       )}
 
-      <DocStringComponent docString={docString} />
       <Row>
         <Col xs="auto" xl="auto">
-          <InputGroup.Text>{name}</InputGroup.Text>
+          <InputGroup.Text>
+            {displayName}
+            <DocStringComponent docString={docString} />
+          </InputGroup.Text>
         </Col>
         <Col xs="5" xl>
           <Slider
@@ -130,8 +140,9 @@ export const SliderComponent = React.memo((props: SliderComponentProps) => {
             type="float"
             value={valueMagnitude}
             unit={valueUnit}
-            showName={false}
-            addNotification={() => null}
+            addNotification={() => {}}
+            changeCallback={(value) => changeCallback(value, name + '.value')}
+            id={id + '-value'}
           />
         </Col>
         <Col xs="auto">

frontend/src/components/StringComponent.tsx

@@ -1,14 +1,12 @@
 import React, { useEffect, useRef, useState } from 'react';
 import { Form, InputGroup } from 'react-bootstrap';
-import { setAttribute } from '../socket';
 import { DocStringComponent } from './DocStringComponent';
 import '../App.css';
-import { getIdFromFullAccessPath } from '../utils/stringUtils';
 import { LevelName } from './NotificationsComponent';
 
 // TODO: add button functionality
 
-interface StringComponentProps {
+type StringComponentProps = {
   name: string;
   parentPath?: string;
   value: string;
@@ -16,16 +14,33 @@ interface StringComponentProps {
   docString: string;
   isInstantUpdate: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
-}
+  changeCallback?: (
+    value: unknown,
+    attributeName?: string,
+    prefix?: string,
+    callback?: (ack: unknown) => void
+  ) => void;
+  displayName: string;
+  id: string;
+};
 
 export const StringComponent = React.memo((props: StringComponentProps) => {
-  const { name, parentPath, readOnly, docString, isInstantUpdate, addNotification } =
-    props;
+  const {
+    name,
+    readOnly,
+    docString,
+    isInstantUpdate,
+    addNotification,
+    changeCallback = () => {},
+    displayName,
+    id
+  } = props;
 
   const renderCount = useRef(0);
   const [inputString, setInputString] = useState(props.value);
-  const fullAccessPath = parentPath.concat('.' + name);
-  const id = getIdFromFullAccessPath(fullAccessPath);
+  const fullAccessPath = [props.parentPath, props.name]
+    .filter((element) => element)
+    .join('.');
 
   useEffect(() => {
     renderCount.current++;
@@ -36,41 +51,44 @@ export const StringComponent = React.memo((props: StringComponentProps) => {
     if (props.value !== inputString) {
       setInputString(props.value);
     }
-    addNotification(`${parentPath}.${name} changed to ${props.value}.`);
+    addNotification(`${fullAccessPath} changed to ${props.value}.`);
   }, [props.value]);
 
   const handleChange = (event) => {
     setInputString(event.target.value);
     if (isInstantUpdate) {
-      setAttribute(name, parentPath, event.target.value);
+      changeCallback(event.target.value);
     }
   };
 
   const handleKeyDown = (event) => {
     if (event.key === 'Enter' && !isInstantUpdate) {
-      setAttribute(name, parentPath, inputString);
+      changeCallback(inputString);
+      event.preventDefault();
     }
   };
 
   const handleBlur = () => {
     if (!isInstantUpdate) {
-      setAttribute(name, parentPath, inputString);
+      changeCallback(inputString);
     }
   };
 
   return (
-    <div className={'stringComponent'} id={id}>
+    <div className="component stringComponent" id={id}>
       {process.env.NODE_ENV === 'development' && (
         <div>Render count: {renderCount.current}</div>
       )}
-      <DocStringComponent docString={docString} />
       <InputGroup>
-        <InputGroup.Text>{name}</InputGroup.Text>
+        <InputGroup.Text>
+          {displayName}
+          <DocStringComponent docString={docString} />
+        </InputGroup.Text>
         <Form.Control
           type="text"
+          name={name}
           value={inputString}
           disabled={readOnly}
-          name={name}
           onChange={handleChange}
           onKeyDown={handleKeyDown}
           onBlur={handleBlur}

frontend/src/utils/stateUtils.ts

@@ -1,12 +1,11 @@
-export interface SerializedValue {
+import { SerializedValue } from '../components/GenericComponent';
+
+export type State = {
   type: string;
-  value: Record<string, unknown> | Array<Record<string, unknown>>;
+  value: Record<string, SerializedValue> | null;
   readonly: boolean;
   doc: string | null;
-  async?: boolean;
-  parameters?: unknown;
-}
-export type State = Record<string, SerializedValue> | null;
+};
 
 export function setNestedValueByPath(
   serializationDict: Record<string, SerializedValue>,

frontend/src/utils/stringUtils.ts

@@ -1,12 +1,16 @@
 export function getIdFromFullAccessPath(fullAccessPath: string) {
-  // Replace '].' with a single dash
-  let id = fullAccessPath.replace(/\]\./g, '-');
+  if (fullAccessPath) {
+    // Replace '].' with a single dash
+    let id = fullAccessPath.replace(/\]\./g, '-');
 
-  // Replace any character that is not a word character or underscore with a dash
-  id = id.replace(/[^\w_]+/g, '-');
+    // Replace any character that is not a word character or underscore with a dash
+    id = id.replace(/[^\w_]+/g, '-');
 
-  // Remove any trailing dashes
-  id = id.replace(/-+$/, '');
+    // Remove any trailing dashes
+    id = id.replace(/-+$/, '');
 
-  return id;
+    return id;
+  } else {
+    return 'main';
+  }
 }

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pydase"
-version = "0.4.1"
+version = "0.7.4"
 description = "A flexible and robust Python library for creating, managing, and interacting with data services, with built-in support for web and RPC servers, and customizable features for diverse use cases."
 authors = ["Mose Mueller <mosmuell@ethz.ch>"]
 readme = "README.md"
@@ -10,11 +10,10 @@ packages = [{ include = "pydase", from = "src" }]
 [tool.poetry.dependencies]
 python = "^3.10"
 rpyc = "^5.3.1"
-fastapi = "^0.100.0"
-uvicorn = "^0.22.0"
+fastapi = "^0.108.0"
+uvicorn = "^0.27.0"
 toml = "^0.10.2"
 python-socketio = "^5.8.0"
-websockets = "^11.0.3"
 confz = "^2.0.0"
 pint = "^0.22"
 pillow = "^10.0.0"
@@ -30,7 +29,8 @@ mypy = "^1.4.1"
 matplotlib = "^3.7.2"
 pyright = "^1.1.323"
 pytest-mock = "^3.11.1"
-ruff = "^0.1.5"
+ruff = "^0.2.0"
+pytest-asyncio = "^0.23.2"
 
 [tool.poetry.group.docs]
 optional = true
@@ -47,6 +47,11 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.ruff]
 target-version = "py310" # Always generate Python 3.10-compatible code
+extend-exclude = [
+  "docs", "frontend"
+]
+
+[tool.ruff.lint]
 select = [
     "ASYNC", # flake8-async
     "C4",    # flake8-comprehensions
@@ -77,13 +82,9 @@ select = [
     "W",     # pycodestyle warnings
 ]
 ignore = [
-    "E203",     # whitespace-before-punctuation
-    "W292",     # missing-newline-at-end-of-file
+    "RUF006",  # asyncio-dangling-task
     "PERF203",  # try-except-in-loop
 ]
-extend-exclude = [
-  "docs", "frontend"
-]
 
 [tool.ruff.lint.mccabe]
 max-complexity = 7

src/pydase/components/__init__.py

@@ -28,6 +28,7 @@ print(my_service.voltage.value)  # Output: 5
 """
 
 from pydase.components.coloured_enum import ColouredEnum
+from pydase.components.device_connection import DeviceConnection
 from pydase.components.image import Image
 from pydase.components.number_slider import NumberSlider
 
@@ -35,4 +36,5 @@ __all__ = [
     "NumberSlider",
     "Image",
     "ColouredEnum",
+    "DeviceConnection",
 ]

src/pydase/components/device_connection.py

@@ -0,0 +1,77 @@
+import asyncio
+
+import pydase
+
+
+class DeviceConnection(pydase.DataService):
+    """
+    Base class for device connection management within the pydase framework.
+
+    This class serves as the foundation for subclasses that manage connections to
+    specific devices. It implements automatic reconnection logic that periodically
+    checks the device's availability and attempts to reconnect if the connection is
+    lost. The frequency of these checks is controlled by the `_reconnection_wait_time`
+    attribute.
+
+    Subclassing
+    -----------
+    Users should primarily override the `connect` method to establish a connection
+    to the device. This method should update the `self._connected` attribute to reflect
+    the connection status:
+
+    >>> class MyDeviceConnection(DeviceConnection):
+    ...     def connect(self) -> None:
+    ...         # Implementation to connect to the device
+    ...         # Update self._connected to `True` if connection is successful,
+    ...         # `False` otherwise
+    ...         ...
+
+    Optionally, if additional logic is needed to determine the connection status,
+    the `connected` property can also be overridden:
+
+    >>> class MyDeviceConnection(DeviceConnection):
+    ...     @property
+    ...     def connected(self) -> bool:
+    ...         # Custom logic to determine connection status
+    ...         return some_custom_condition
+    ...
+
+    Frontend Representation
+    -----------------------
+    In the frontend, this class is represented without directly exposing the `connect`
+    method and `connected` attribute. Instead, user-defined attributes, methods, and
+    properties are displayed. When `self.connected` is `False`, the frontend component
+    shows an overlay that allows manual triggering of the `connect()` method. This
+    overlay disappears once the connection is successfully re-established.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._connected = False
+        self._autostart_tasks["_handle_connection"] = ()  # type: ignore
+        self._reconnection_wait_time = 10.0
+
+    def connect(self) -> None:
+        """Tries connecting to the device and changes `self._connected` status
+        accordingly. This method is called every `self._reconnection_wait_time` seconds
+        when `self.connected` is False. Users should override this method to implement
+        device-specific connection logic.
+        """
+
+    @property
+    def connected(self) -> bool:
+        """Indicates if the device is currently connected or was recently connected.
+        Users may override this property to incorporate custom logic for determining
+        the connection status.
+        """
+        return self._connected
+
+    async def _handle_connection(self) -> None:
+        """Automatically tries reconnecting to the device if it is not connected.
+        This method leverages the `connect` method and the `connected` property to
+        manage the connection status.
+        """
+        while True:
+            if not self.connected:
+                self.connect()
+            await asyncio.sleep(self._reconnection_wait_time)

src/pydase/config.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 from typing import Literal
 
 from confz import BaseConfig, EnvSource
@@ -7,3 +8,17 @@ class OperationMode(BaseConfig):  # type: ignore[misc]
     environment: Literal["development", "production"] = "development"
 
     CONFIG_SOURCES = EnvSource(allow=["ENVIRONMENT"])
+
+
+class ServiceConfig(BaseConfig):  # type: ignore[misc]
+    config_dir: Path = Path("config")
+    web_port: int = 8001
+    rpc_port: int = 18871
+
+    CONFIG_SOURCES = EnvSource(allow_all=True, prefix="SERVICE_", file=".env")
+
+
+class WebServerConfig(BaseConfig):  # type: ignore[misc]
+    generate_web_settings: bool = False
+
+    CONFIG_SOURCES = EnvSource(allow=["GENERATE_WEB_SETTINGS"])

src/pydase/data_service/data_service.py

@@ -1,8 +1,7 @@
 import inspect
 import logging
-import warnings
 from enum import Enum
-from typing import TYPE_CHECKING, Any, get_type_hints
+from typing import Any, get_type_hints
 
 import rpyc  # type: ignore[import-untyped]
 
@@ -15,20 +14,13 @@ from pydase.observer_pattern.observable.observable import (
 from pydase.utils.helpers import (
     convert_arguments_to_hinted_types,
     get_class_and_instance_attributes,
-    get_object_attr_from_path_list,
     is_property_attribute,
-    parse_list_attr_and_index,
-    update_value_if_changed,
 )
 from pydase.utils.serializer import (
+    SerializedObject,
     Serializer,
-    generate_serialized_data_paths,
-    get_nested_dict_by_path,
 )
 
-if TYPE_CHECKING:
-    from pathlib import Path
-
 logger = logging.getLogger(__name__)
 
 
@@ -51,18 +43,7 @@ class DataService(rpyc.Service, AbstractDataService):
         if not hasattr(self, "_autostart_tasks"):
             self._autostart_tasks = {}
 
-        filename = kwargs.pop("filename", None)
-        if filename is not None:
-            warnings.warn(
-                "The 'filename' argument is deprecated and will be removed in a future "
-                "version. Please pass the 'filename' argument to `pydase.Server`.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            self._filename: str | Path = filename
-
         self.__check_instance_classes()
-        self._initialised = True
 
     def __setattr__(self, __name: str, __value: Any) -> None:
         # Check and warn for unexpected type changes in attributes
@@ -125,27 +106,6 @@ class DataService(rpyc.Service, AbstractDataService):
             ):
                 self.__warn_if_not_observable(attr_value)
 
-    def __set_attribute_based_on_type(  # noqa: PLR0913
-        self,
-        target_obj: Any,
-        attr_name: str,
-        attr: Any,
-        value: Any,
-        index: int | None,
-        path_list: list[str],
-    ) -> None:
-        if isinstance(attr, Enum):
-            update_value_if_changed(target_obj, attr_name, attr.__class__[value])
-        elif isinstance(attr, list) and index is not None:
-            update_value_if_changed(attr, index, value)
-        elif isinstance(attr, DataService) and isinstance(value, dict):
-            for key, v in value.items():
-                self.update_DataService_attribute([*path_list, attr_name], key, v)
-        elif callable(attr):
-            process_callable_attribute(attr, value["args"])
-        else:
-            update_value_if_changed(target_obj, attr_name, value)
-
     def _rpyc_getattr(self, name: str) -> Any:
         if name.startswith("_"):
             # disallow special and private attributes
@@ -166,72 +126,7 @@ class DataService(rpyc.Service, AbstractDataService):
         # allow all other attributes
         setattr(self, name, value)
 
-    def write_to_file(self) -> None:
-        """
-        Serialize the DataService instance and write it to a JSON file.
-
-        This method is deprecated and will be removed in a future version.
-        Service persistence is handled by `pydase.Server` now, instead.
-        """
-
-        warnings.warn(
-            "'write_to_file' is deprecated and will be removed in a future version. "
-            "Service persistence is handled by `pydase.Server` now, instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        if hasattr(self, "_state_manager"):
-            self._state_manager.save_state()
-
-    def load_DataService_from_JSON(  # noqa: N802
-        self, json_dict: dict[str, Any]
-    ) -> None:
-        warnings.warn(
-            "'load_DataService_from_JSON' is deprecated and will be removed in a "
-            "future version. "
-            "Service persistence is handled by `pydase.Server` now, instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        # Traverse the serialized representation and set the attributes of the class
-        serialized_class = self.serialize()
-        for path in generate_serialized_data_paths(json_dict):
-            nested_json_dict = get_nested_dict_by_path(json_dict, path)
-            value = nested_json_dict["value"]
-            value_type = nested_json_dict["type"]
-
-            nested_class_dict = get_nested_dict_by_path(serialized_class, path)
-            class_value_type = nested_class_dict.get("type", None)
-            if class_value_type == value_type:
-                class_attr_is_read_only = nested_class_dict["readonly"]
-                if class_attr_is_read_only:
-                    logger.debug(
-                        "Attribute '%s' is read-only. Ignoring value from JSON "
-                        "file...",
-                        path,
-                    )
-                    continue
-                # Split the path into parts
-                parts = path.split(".")
-                attr_name = parts[-1]
-
-                # Convert dictionary into Quantity
-                if class_value_type == "Quantity":
-                    value = u.convert_to_quantity(value)
-
-                self.update_DataService_attribute(parts[:-1], attr_name, value)
-            else:
-                logger.info(
-                    "Attribute type of '%s' changed from '%s' to "
-                    "'%s'. Ignoring value from JSON file...",
-                    path,
-                    value_type,
-                    class_value_type,
-                )
-
-    def serialize(self) -> dict[str, dict[str, Any]]:
+    def serialize(self) -> SerializedObject:
         """
         Serializes the instance into a dictionary, preserving the structure of the
         instance.
@@ -248,38 +143,4 @@ class DataService(rpyc.Service, AbstractDataService):
         Returns:
             dict: The serialized instance.
         """
-        return Serializer.serialize_object(self)["value"]
-
-    def update_DataService_attribute(  # noqa: N802
-        self,
-        path_list: list[str],
-        attr_name: str,
-        value: Any,
-    ) -> None:
-        warnings.warn(
-            "'update_DataService_attribute' is deprecated and will be removed in a "
-            "future version. "
-            "Service state management is handled by `pydase.data_service.state_manager`"
-            "now, instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        # If attr_name corresponds to a list entry, extract the attr_name and the index
-        attr_name, index = parse_list_attr_and_index(attr_name)
-        # Traverse the object according to the path parts
-        target_obj = get_object_attr_from_path_list(self, path_list)
-
-        # If the attribute is a property, change it using the setter without getting the
-        # property value (would otherwise be bad for expensive getter methods)
-        if is_property_attribute(target_obj, attr_name):
-            setattr(target_obj, attr_name, value)
-            return
-
-        attr = get_object_attr_from_path_list(target_obj, [attr_name])
-        if attr is None:
-            return
-
-        self.__set_attribute_based_on_type(
-            target_obj, attr_name, attr, value, index, path_list
-        )
+        return Serializer.serialize_object(self)

src/pydase/data_service/data_service_cache.py

@@ -1,9 +1,10 @@
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from pydase.utils.serializer import (
     SerializationPathError,
     SerializationValueError,
+    SerializedObject,
     get_nested_dict_by_path,
     set_nested_value_by_path,
 )
@@ -16,12 +17,12 @@ logger = logging.getLogger(__name__)
 
 class DataServiceCache:
     def __init__(self, service: "DataService") -> None:
-        self._cache: dict[str, Any] = {}
+        self._cache: SerializedObject
         self.service = service
         self._initialize_cache()
 
     @property
-    def cache(self) -> dict[str, Any]:
+    def cache(self) -> SerializedObject:
         return self._cache
 
     def _initialize_cache(self) -> None:
@@ -30,10 +31,22 @@ class DataServiceCache:
         self._cache = self.service.serialize()
 
     def update_cache(self, full_access_path: str, value: Any) -> None:
-        set_nested_value_by_path(self._cache, full_access_path, value)
+        set_nested_value_by_path(
+            cast(dict[str, SerializedObject], self._cache["value"]),
+            full_access_path,
+            value,
+        )
 
-    def get_value_dict_from_cache(self, full_access_path: str) -> dict[str, Any]:
+    def get_value_dict_from_cache(self, full_access_path: str) -> SerializedObject:
         try:
-            return get_nested_dict_by_path(self._cache, full_access_path)
+            return get_nested_dict_by_path(
+                cast(dict[str, SerializedObject], self._cache["value"]),
+                full_access_path,
+            )
         except (SerializationPathError, SerializationValueError, KeyError):
-            return {}
+            return {
+                "value": None,
+                "type": None,
+                "doc": None,
+                "readonly": False,
+            }

src/pydase/data_service/data_service_observer.py

@@ -9,7 +9,7 @@ from pydase.observer_pattern.observer.property_observer import (
     PropertyObserver,
 )
 from pydase.utils.helpers import get_object_attr_from_path_list
-from pydase.utils.serializer import dump
+from pydase.utils.serializer import SerializedObject, dump
 
 logger = logging.getLogger(__name__)
 
@@ -18,11 +18,18 @@ class DataServiceObserver(PropertyObserver):
     def __init__(self, state_manager: StateManager) -> None:
         self.state_manager = state_manager
         self._notification_callbacks: list[
-            Callable[[str, Any, dict[str, Any]], None]
+            Callable[[str, Any, SerializedObject], None]
         ] = []
         super().__init__(state_manager.service)
 
     def on_change(self, full_access_path: str, value: Any) -> None:
+        if any(
+            full_access_path.startswith(changing_attribute)
+            and full_access_path != changing_attribute
+            for changing_attribute in self.changing_attributes
+        ):
+            return
+
         cached_value_dict = deepcopy(
             self.state_manager._data_service_cache.get_value_dict_from_cache(
                 full_access_path
@@ -35,10 +42,16 @@ class DataServiceObserver(PropertyObserver):
         ):
             logger.debug("'%s' changed to '%s'", full_access_path, value)
 
-        self._update_cache_value(full_access_path, value, cached_value_dict)
+            self._update_cache_value(full_access_path, value, cached_value_dict)
 
-        for callback in self._notification_callbacks:
-            callback(full_access_path, value, cached_value_dict)
+            cached_value_dict = deepcopy(
+                self.state_manager._data_service_cache.get_value_dict_from_cache(
+                    full_access_path
+                )
+            )
+
+            for callback in self._notification_callbacks:
+                callback(full_access_path, value, cached_value_dict)
 
         if isinstance(value, ObservableObject):
             self._update_property_deps_dict()
@@ -46,7 +59,10 @@ class DataServiceObserver(PropertyObserver):
         self._notify_dependent_property_changes(full_access_path)
 
     def _update_cache_value(
-        self, full_access_path: str, value: Any, cached_value_dict: dict[str, Any]
+        self,
+        full_access_path: str,
+        value: Any,
+        cached_value_dict: SerializedObject | dict[str, Any],
     ) -> None:
         value_dict = dump(value)
         if cached_value_dict != {}:
@@ -80,7 +96,7 @@ class DataServiceObserver(PropertyObserver):
                 )
 
     def add_notification_callback(
-        self, callback: Callable[[str, Any, dict[str, Any]], None]
+        self, callback: Callable[[str, Any, SerializedObject], None]
     ) -> None:
         """
         Registers a callback function to be invoked upon attribute changes in the

src/pydase/data_service/state_manager.py

@@ -9,12 +9,15 @@ import pydase.units as u
 from pydase.data_service.data_service_cache import DataServiceCache
 from pydase.utils.helpers import (
     get_object_attr_from_path_list,
+    is_property_attribute,
     parse_list_attr_and_index,
 )
 from pydase.utils.serializer import (
+    SerializedObject,
     dump,
     generate_serialized_data_paths,
     get_nested_dict_by_path,
+    serialized_dict_is_nested_object,
 )
 
 if TYPE_CHECKING:
@@ -112,10 +115,17 @@ class StateManager:
         self._data_service_cache = DataServiceCache(self.service)
 
     @property
-    def cache(self) -> dict[str, Any]:
+    def cache(self) -> SerializedObject:
         """Returns the cached DataService state."""
         return self._data_service_cache.cache
 
+    @property
+    def cache_value(self) -> dict[str, SerializedObject]:
+        """Returns the "value" value of the DataService serialization."""
+        return cast(
+            dict[str, SerializedObject], self._data_service_cache.cache["value"]
+        )
+
     def save_state(self) -> None:
         """
         Saves the DataService's current state to a JSON file defined by `self.filename`.
@@ -124,7 +134,7 @@ class StateManager:
 
         if self.filename is not None:
             with open(self.filename, "w") as f:
-                json.dump(self.cache, f, indent=4)
+                json.dump(self.cache_value, f, indent=4)
         else:
             logger.info(
                 "State manager was not initialised with a filename. Skipping "
@@ -189,7 +199,7 @@ class StateManager:
             value: The new value to set for the attribute.
         """
 
-        current_value_dict = get_nested_dict_by_path(self.cache, path)
+        current_value_dict = get_nested_dict_by_path(self.cache_value, path)
 
         # This will also filter out methods as they are 'read-only'
         if current_value_dict["readonly"]:
@@ -214,10 +224,12 @@ class StateManager:
         return dump(value_object)["value"] != current_value
 
     def __convert_value_if_needed(
-        self, value: Any, current_value_dict: dict[str, Any]
+        self, value: Any, current_value_dict: SerializedObject
     ) -> Any:
         if current_value_dict["type"] == "Quantity":
-            return u.convert_to_quantity(value, current_value_dict["value"]["unit"])
+            return u.convert_to_quantity(
+                value, cast(dict[str, Any], current_value_dict["value"])["unit"]
+            )
         if current_value_dict["type"] == "float" and not isinstance(value, float):
             return float(value)
         return value
@@ -232,7 +244,7 @@ class StateManager:
         # Update path to reflect the attribute without list indices
         path = ".".join([*parent_path_list, attr_name])
 
-        attr_cache_type = get_nested_dict_by_path(self.cache, path)["type"]
+        attr_cache_type = get_nested_dict_by_path(self.cache_value, path)["type"]
 
         # Traverse the object according to the path parts
         target_obj = get_object_attr_from_path_list(self.service, parent_path_list)
@@ -246,7 +258,7 @@ class StateManager:
         else:
             setattr(target_obj, attr_name, value)
 
-    def __is_loadable_state_attribute(self, property_path: str) -> bool:
+    def __is_loadable_state_attribute(self, full_access_path: str) -> bool:
         """Checks if an attribute defined by a dot-separated path should be loaded from
         storage.
 
@@ -255,13 +267,12 @@ class StateManager:
         """
 
         parent_object = get_object_attr_from_path_list(
-            self.service, property_path.split(".")[:-1]
+            self.service, full_access_path.split(".")[:-1]
         )
-        attr_name = property_path.split(".")[-1]
+        attr_name = full_access_path.split(".")[-1]
 
-        prop = getattr(type(parent_object), attr_name, None)
-
-        if isinstance(prop, property):
+        if is_property_attribute(parent_object, attr_name):
+            prop = getattr(type(parent_object), attr_name)
             has_decorator = has_load_state_decorator(prop)
             if not has_decorator:
                 logger.debug(
@@ -270,4 +281,13 @@ class StateManager:
                     attr_name,
                 )
             return has_decorator
-        return True
+
+        cached_serialization_dict = get_nested_dict_by_path(
+            self.cache_value, full_access_path
+        )
+
+        if cached_serialization_dict["value"] == "method":
+            return False
+
+        # nested objects cannot be loaded
+        return not serialized_dict_is_nested_object(cached_serialization_dict)

src/pydase/data_service/task_manager.py

@@ -3,11 +3,15 @@ from __future__ import annotations
 import asyncio
 import inspect
 import logging
-from functools import wraps
-from typing import TYPE_CHECKING, Any, TypedDict
+from enum import Enum
+from typing import TYPE_CHECKING, Any
 
 from pydase.data_service.abstract_data_service import AbstractDataService
-from pydase.utils.helpers import get_class_and_instance_attributes
+from pydase.utils.helpers import (
+    function_has_arguments,
+    get_class_and_instance_attributes,
+    is_property_attribute,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -17,9 +21,12 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-class TaskDict(TypedDict):
-    task: asyncio.Task[None]
-    kwargs: dict[str, Any]
+class TaskDefinitionError(Exception):
+    pass
+
+
+class TaskStatus(Enum):
+    RUNNING = "running"
 
 
 class TaskManager:
@@ -78,9 +85,8 @@ class TaskManager:
 
     def __init__(self, service: DataService) -> None:
         self.service = service
-        self._loop = asyncio.get_event_loop()
 
-        self.tasks: dict[str, TaskDict] = {}
+        self.tasks: dict[str, asyncio.Task[None]] = {}
         """A dictionary to keep track of running tasks. The keys are the names of the
         tasks and the values are TaskDict instances which include the task itself and
         its kwargs.
@@ -88,14 +94,31 @@ class TaskManager:
 
         self._set_start_and_stop_for_async_methods()
 
+    @property
+    def _loop(self) -> asyncio.AbstractEventLoop:
+        return asyncio.get_running_loop()
+
     def _set_start_and_stop_for_async_methods(self) -> None:
-        # inspect the methods of the class
-        for name, method in inspect.getmembers(
-            self.service, predicate=inspect.iscoroutinefunction
-        ):
-            # create start and stop methods for each coroutine
-            setattr(self.service, f"start_{name}", self._make_start_task(name, method))
-            setattr(self.service, f"stop_{name}", self._make_stop_task(name))
+        for name in dir(self.service):
+            # circumvents calling properties
+            if is_property_attribute(self.service, name):
+                continue
+
+            method = getattr(self.service, name)
+            if inspect.iscoroutinefunction(method):
+                if function_has_arguments(method):
+                    raise TaskDefinitionError(
+                        "Asynchronous functions (tasks) should be defined without "
+                        f"arguments. The task '{method.__name__}' has at least one "
+                        "argument. Please remove the argument(s) from this function to "
+                        "use it."
+                    )
+
+                # create start and stop methods for each coroutine
+                setattr(
+                    self.service, f"start_{name}", self._make_start_task(name, method)
+                )
+                setattr(self.service, f"stop_{name}", self._make_stop_task(name))
 
     def _initiate_task_startup(self) -> None:
         if self.service._autostart_tasks is not None:
@@ -135,7 +158,7 @@ class TaskManager:
             # cancel the task
             task = self.tasks.get(name, None)
             if task is not None:
-                self._loop.call_soon_threadsafe(task["task"].cancel)
+                self._loop.call_soon_threadsafe(task.cancel)
 
         return stop_task
 
@@ -154,8 +177,7 @@ class TaskManager:
             method (callable): The coroutine to be turned into an asyncio task.
         """
 
-        @wraps(method)
-        def start_task(*args: Any, **kwargs: Any) -> None:
+        def start_task() -> None:
             def task_done_callback(task: asyncio.Task[None], name: str) -> None:
                 """Handles tasks that have finished.
 
@@ -179,36 +201,16 @@ class TaskManager:
                     )
                     raise exception
 
-            async def task(*args: Any, **kwargs: Any) -> None:
+            async def task() -> None:
                 try:
-                    await method(*args, **kwargs)
+                    await method()
                 except asyncio.CancelledError:
                     logger.info("Task '%s' was cancelled", name)
 
             if not self.tasks.get(name):
-                # Get the signature of the coroutine method to start
-                sig = inspect.signature(method)
-
-                # Create a list of the parameter names from the method signature.
-                parameter_names = list(sig.parameters.keys())
-
-                # Extend the list of positional arguments with None values to match
-                # the length of the parameter names list. This is done to ensure
-                # that zip can pair each parameter name with a corresponding value.
-                args_padded = list(args) + [None] * (len(parameter_names) - len(args))
-
-                # Create a dictionary of keyword arguments by pairing the parameter
-                # names with the values in 'args_padded'. Then merge this dictionary
-                # with the 'kwargs' dictionary. If a parameter is specified in both
-                # 'args_padded' and 'kwargs', the value from 'kwargs' is used.
-                kwargs_updated = {
-                    **dict(zip(parameter_names, args_padded, strict=True)),
-                    **kwargs,
-                }
-
                 # creating the task and adding the task_done_callback which checks
                 # if an exception has occured during the task execution
-                task_object = self._loop.create_task(task(*args, **kwargs))
+                task_object = self._loop.create_task(task())
                 task_object.add_done_callback(
                     lambda task: task_done_callback(task, name)
                 )
@@ -216,13 +218,10 @@ class TaskManager:
                 # Store the task and its arguments in the '__tasks' dictionary. The
                 # key is the name of the method, and the value is a dictionary
                 # containing the task object and the updated keyword arguments.
-                self.tasks[name] = {
-                    "task": task_object,
-                    "kwargs": kwargs_updated,
-                }
+                self.tasks[name] = task_object
 
                 # emit the notification that the task was started
-                self.service._notify_changed(name, kwargs_updated)
+                self.service._notify_changed(name, TaskStatus.RUNNING)
             else:
                 logger.error("Task '%s' is already running!", name)
 

src/pydase/frontend/asset-manifest.json

@@ -1,13 +1,13 @@
 {
   "files": {
-    "main.css": "/static/css/main.2d8458eb.css",
-    "main.js": "/static/js/main.da9f921a.js",
+    "main.css": "/static/css/main.7ef670d5.css",
+    "main.js": "/static/js/main.97ef73ea.js",
     "index.html": "/index.html",
-    "main.2d8458eb.css.map": "/static/css/main.2d8458eb.css.map",
-    "main.da9f921a.js.map": "/static/js/main.da9f921a.js.map"
+    "main.7ef670d5.css.map": "/static/css/main.7ef670d5.css.map",
+    "main.97ef73ea.js.map": "/static/js/main.97ef73ea.js.map"
   },
   "entrypoints": [
-    "static/css/main.2d8458eb.css",
-    "static/js/main.da9f921a.js"
+    "static/css/main.7ef670d5.css",
+    "static/js/main.97ef73ea.js"
   ]
 }

src/pydase/frontend/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="/favicon.ico"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Web site displaying a pydase UI."/><link rel="apple-touch-icon" href="/logo192.png"/><link rel="manifest" href="/manifest.json"/><title>pydase App</title><script defer="defer" src="/static/js/main.da9f921a.js"></script><link href="/static/css/main.2d8458eb.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="/favicon.ico"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Web site displaying a pydase UI."/><link rel="apple-touch-icon" href="/logo192.png"/><link rel="manifest" href="/manifest.json"/><title>pydase App</title><script defer="defer" src="/static/js/main.97ef73ea.js"></script><link href="/static/css/main.7ef670d5.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>

src/pydase/observer_pattern/observable/observable_object.py

@@ -148,6 +148,7 @@ class _ObservableList(ObservableObject, list[Any]):
         self._notify_changed(f"[{key}]", value)
 
     def append(self, __object: Any) -> None:
+        self._notify_change_start("")
         self._initialise_new_objects(f"[{len(self)}]", __object)
         super().append(__object)
         self._notify_changed("", self)

src/pydase/observer_pattern/observer/observer.py

@@ -14,11 +14,11 @@ class Observer(ABC):
         self.changing_attributes: list[str] = []
 
     def _notify_changed(self, changed_attribute: str, value: Any) -> None:
+        self.on_change(full_access_path=changed_attribute, value=value)
+
         if changed_attribute in self.changing_attributes:
             self.changing_attributes.remove(changed_attribute)
 
-        self.on_change(full_access_path=changed_attribute, value=value)
-
     def _notify_change_start(self, changing_attribute: str) -> None:
         self.changing_attributes.append(changing_attribute)
         self.on_change_start(changing_attribute)

src/pydase/server/__init__.py

@@ -1,3 +1,7 @@
 from pydase.server.server import Server
+from pydase.server.web_server.web_server import WebServer
 
-__all__ = ["Server"]
+__all__ = [
+    "Server",
+    "WebServer",
+]

src/pydase/server/server.py

@@ -8,16 +8,14 @@ from pathlib import Path
 from types import FrameType
 from typing import Any, Protocol, TypedDict
 
-import uvicorn
-from rpyc import ForkingServer, ThreadedServer  # type: ignore[import-untyped]
+from rpyc import ThreadedServer  # type: ignore[import-untyped]
 from uvicorn.server import HANDLED_SIGNALS
 
 from pydase import DataService
+from pydase.config import ServiceConfig
 from pydase.data_service.data_service_observer import DataServiceObserver
 from pydase.data_service.state_manager import StateManager
-from pydase.utils.serializer import dump
-
-from .web_server import WebAPI
+from pydase.server.web_server import WebServer
 
 logger = logging.getLogger(__name__)
 
@@ -31,35 +29,27 @@ class AdditionalServerProtocol(Protocol):
     any server implementing it should have an __init__ method for initialization and a
     serve method for starting the server.
 
-    Parameters:
-    -----------
-    service: DataService
-        The instance of DataService that the server will use. This could be the main
-        application or a specific service that the server will provide.
-
-    port: int
-        The port number at which the server will be accessible. This should be a valid
-        port number, typically in the range 1024-65535.
-
-    host: str
-        The hostname or IP address at which the server will be hosted. This could be a
-        local address (like '127.0.0.1' for localhost) or a public IP address.
-
-    state_manager: StateManager
-        The state manager managing the state cache and persistence of the exposed
-        service.
-
-    **kwargs: Any
-        Any additional parameters required for initializing the server. These parameters
-        are specific to the server's implementation.
+    Args:
+        data_service_observer:
+          Observer for the DataService, handling state updates and communication to
+          connected clients through injected callbacks. Can be utilized to access the
+          service and state manager, and to add custom state-update callbacks.
+        host:
+          Hostname or IP address where the server is accessible. Commonly '0.0.0.0' to
+          bind to all network interfaces.
+        port:
+          Port number on which the server listens. Typically in the range 1024-65535
+          (non-standard ports).
+        **kwargs:
+          Any additional parameters required for initializing the server. These
+          parameters are specific to the server's implementation.
     """
 
     def __init__(
         self,
-        service: DataService,
-        port: int,
+        data_service_observer: DataServiceObserver,
         host: str,
-        state_manager: StateManager,
+        port: int,
         **kwargs: Any,
     ) -> None:
         ...
@@ -89,87 +79,86 @@ class Server:
     """
     The `Server` class provides a flexible server implementation for the `DataService`.
 
-    Parameters:
-    -----------
-    service: DataService
-        The DataService instance that this server will manage.
-    host: str
-        The host address for the server. Default is '0.0.0.0', which means all available
-        network interfaces.
-    rpc_port: int
-        The port number for the RPC server. Default is 18871.
-    web_port: int
-        The port number for the web server. Default is 8001.
-    enable_rpc: bool
-        Whether to enable the RPC server. Default is True.
-    enable_web: bool
-        Whether to enable the web server. Default is True.
-    filename: str | Path | None
-        Filename of the file managing the service state persistence. Defaults to None.
-    use_forking_server: bool
-        Whether to use ForkingServer for multiprocessing. Default is False.
-    additional_servers : list[AdditionalServer]
-        A list of additional servers to run alongside the main server. Each entry in the
-        list should be a dictionary with the following structure:
+    Args:
+        service: DataService
+          The DataService instance that this server will manage.
+        host: str
+          The host address for the server. Default is '0.0.0.0', which means all
+          available network interfaces.
+        rpc_port: int
+          The port number for the RPC server. Default is
+          `pydase.config.ServiceConfig().rpc_port`.
+        web_port: int
+          The port number for the web server. Default is
+          `pydase.config.ServiceConfig().web_port`.
+        enable_rpc: bool
+          Whether to enable the RPC server. Default is True.
+        enable_web: bool
+          Whether to enable the web server. Default is True.
+        filename: str | Path | None
+          Filename of the file managing the service state persistence. Defaults to None.
+        use_forking_server: bool
+          Whether to use ForkingServer for multiprocessing. Default is False.
+        additional_servers : list[AdditionalServer]
+          A list of additional servers to run alongside the main server. Each entry in
+          the list should be a dictionary with the following structure:
+            - server: A class that adheres to the AdditionalServerProtocol. This class
+                should have an `__init__` method that accepts the DataService instance,
+                port, host, and optional keyword arguments, and a `serve` method that is
+                a coroutine responsible for starting the server.
+            - port: The port on which the additional server will be running.
+            - kwargs: A dictionary containing additional keyword arguments that will be
+                passed to the server's `__init__` method.
 
-        - server: A class that adheres to the AdditionalServerProtocol. This class
-            should have an `__init__` method that accepts the DataService instance,
-            port, host, and optional keyword arguments, and a `serve` method that is a
-            coroutine responsible for starting the server.
-        - port: The port on which the additional server will be running.
-        - kwargs: A dictionary containing additional keyword arguments that will be
-            passed to the server's `__init__` method.
-
-        Here's an example of how you might define an additional server:
+          Here's an example of how you might define an additional server:
 
 
-        >>>     class MyCustomServer:
-        ...         def __init__(
-        ...             self,
-        ...             service: DataService,
-        ...             port: int,
-        ...             host: str,
-        ...             state_manager: StateManager,
-        ...             **kwargs: Any
-        ...         ):
-        ...             self.service = service
-        ...             self.state_manager = state_manager
-        ...             self.port = port
-        ...             self.host = host
-        ...             # handle any additional arguments...
-        ...
-        ...         async def serve(self):
-        ...             # code to start the server...
+          >>>     class MyCustomServer:
+          ...         def __init__(
+          ...             self,
+          ...             data_service_observer: DataServiceObserver,
+          ...             host: str,
+          ...             port: int,
+          ...             **kwargs: Any,
+          ...         ) -> None:
+          ...             self.observer = data_service_observer
+          ...             self.state_manager = self.observer.state_manager
+          ...             self.service = self.state_manager.service
+          ...             self.port = port
+          ...             self.host = host
+          ...             # handle any additional arguments...
+          ...
+          ...         async def serve(self):
+          ...             # code to start the server...
 
-        And here's how you might add it to the `additional_servers` list when creating a
-        `Server` instance:
+          And here's how you might add it to the `additional_servers` list when creating
+          a `Server` instance:
 
-        >>>    server = Server(
-        ...        service=my_data_service,
-        ...        additional_servers=[
-        ...            {
-        ...                "server": MyCustomServer,
-        ...                "port": 12345,
-        ...                "kwargs": {"some_arg": "some_value"}
-        ...            }
-        ...        ],
-        ...    )
-        ...    server.run()
+          >>>    server = Server(
+          ...        service=my_data_service,
+          ...        additional_servers=[
+          ...            {
+          ...                "server": MyCustomServer,
+          ...                "port": 12345,
+          ...                "kwargs": {"some_arg": "some_value"}
+          ...            }
+          ...        ],
+          ...    )
+          ...    server.run()
 
-    **kwargs: Any
-        Additional keyword arguments.
+        **kwargs: Any
+          Additional keyword arguments.
     """
 
     def __init__(  # noqa: PLR0913
         self,
         service: DataService,
         host: str = "0.0.0.0",
-        rpc_port: int = 18871,
-        web_port: int = 8001,
+        rpc_port: int = ServiceConfig().rpc_port,
+        web_port: int = ServiceConfig().web_port,
         enable_rpc: bool = True,
         enable_web: bool = True,
         filename: str | Path | None = None,
-        use_forking_server: bool = False,
         additional_servers: list[AdditionalServer] | None = None,
         **kwargs: Any,
     ) -> None:
@@ -183,39 +172,21 @@ class Server:
         self._enable_web = enable_web
         self._kwargs = kwargs
         self._loop: asyncio.AbstractEventLoop
-        self._rpc_server_type = ForkingServer if use_forking_server else ThreadedServer
         self._additional_servers = additional_servers
         self.should_exit = False
         self.servers: dict[str, asyncio.Future[Any]] = {}
         self.executor: ThreadPoolExecutor | None = None
         self._state_manager = StateManager(self._service, filename)
-        if getattr(self._service, "_filename", None) is not None:
-            self._service._state_manager = self._state_manager
-        self._state_manager.load_state()
         self._observer = DataServiceObserver(self._state_manager)
+        self._state_manager.load_state()
 
     def run(self) -> None:
         """
         Initializes the asyncio event loop and starts the server.
 
         This method should be called to start the server after it's been instantiated.
-
-        Raises
-        ------
-        Exception
-            If there's an error while running the server, the error will be propagated
-            after the server is shut down.
         """
-        try:
-            self._loop = asyncio.get_event_loop()
-        except RuntimeError:
-            self._loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(self._loop)
-        try:
-            self._loop.run_until_complete(self.serve())
-        except Exception:
-            self._loop.run_until_complete(self.shutdown())
-            raise
+        asyncio.run(self.serve())
 
     async def serve(self) -> None:
         process_id = os.getpid()
@@ -230,7 +201,7 @@ class Server:
 
         logger.info("Finished server process [%s]", process_id)
 
-    async def startup(self) -> None:  # noqa: C901
+    async def startup(self) -> None:
         self._loop = asyncio.get_running_loop()
         self._loop.set_exception_handler(self.custom_exception_handler)
         self.install_signal_handlers()
@@ -238,7 +209,7 @@ class Server:
 
         if self._enable_rpc:
             self.executor = ThreadPoolExecutor()
-            self._rpc_server = self._rpc_server_type(
+            self._rpc_server = ThreadedServer(
                 self._service,
                 port=self._rpc_port,
                 protocol_config={
@@ -252,10 +223,9 @@ class Server:
             self.servers["rpyc"] = future_or_task
         for server in self._additional_servers:
             addin_server = server["server"](
-                self._service,
-                port=server["port"],
+                data_service_observer=self._observer,
                 host=self._host,
-                state_manager=self._state_manager,
+                port=server["port"],
                 **server["kwargs"],
             )
 
@@ -266,49 +236,13 @@ class Server:
             future_or_task = self._loop.create_task(addin_server.serve())
             self.servers[server_name] = future_or_task
         if self._enable_web:
-            self._wapi = WebAPI(
-                service=self._service,
-                state_manager=self._state_manager,
+            self._web_server = WebServer(
+                data_service_observer=self._observer,
+                host=self._host,
+                port=self._web_port,
                 **self._kwargs,
             )
-            web_server = uvicorn.Server(
-                uvicorn.Config(
-                    self._wapi.fastapi_app, host=self._host, port=self._web_port
-                )
-            )
-
-            def sio_callback(
-                full_access_path: str, value: Any, cached_value_dict: dict[str, Any]
-            ) -> None:
-                if cached_value_dict != {}:
-                    serialized_value = dump(value)
-                    if cached_value_dict["type"] != "method":
-                        cached_value_dict["type"] = serialized_value["type"]
-
-                    cached_value_dict["value"] = serialized_value["value"]
-
-                    async def notify() -> None:
-                        try:
-                            await self._wapi.sio.emit(
-                                "notify",
-                                {
-                                    "data": {
-                                        "full_access_path": full_access_path,
-                                        "value": cached_value_dict,
-                                    }
-                                },
-                            )
-                        except Exception as e:
-                            logger.warning("Failed to send notification: %s", e)
-
-                    self._loop.create_task(notify())
-
-            self._observer.add_notification_callback(sio_callback)
-
-            # overwrite uvicorn's signal handlers, otherwise it will bogart SIGINT and
-            # SIGTERM, which makes it impossible to escape out of
-            web_server.install_signal_handlers = lambda: None  # type: ignore[method-assign]
-            future_or_task = self._loop.create_task(web_server.serve())
+            future_or_task = self._loop.create_task(self._web_server.serve())
             self.servers["web"] = future_or_task
 
     async def main_loop(self) -> None:
@@ -319,8 +253,7 @@ class Server:
         logger.info("Shutting down")
 
         logger.info("Saving data to %s.", self._state_manager.filename)
-        if self._state_manager is not None:
-            self._state_manager.save_state()
+        self._state_manager.save_state()
 
         await self.__cancel_servers()
         await self.__cancel_tasks()
@@ -382,7 +315,7 @@ class Server:
 
                 async def emit_exception() -> None:
                     try:
-                        await self._wapi.sio.emit(
+                        await self._web_server._sio.emit(
                             "exception",
                             {
                                 "data": {

src/pydase/server/web_server.py

@@ -1,175 +0,0 @@
-import logging
-from pathlib import Path
-from typing import Any, TypedDict
-
-import socketio  # type: ignore[import-untyped]
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse
-from fastapi.staticfiles import StaticFiles
-
-from pydase import DataService
-from pydase.data_service.data_service import process_callable_attribute
-from pydase.data_service.state_manager import StateManager
-from pydase.utils.helpers import get_object_attr_from_path_list
-from pydase.utils.logging import SocketIOHandler
-from pydase.version import __version__
-
-logger = logging.getLogger(__name__)
-
-
-class UpdateDict(TypedDict):
-    """
-    A TypedDict subclass representing a dictionary used for updating attributes in a
-    DataService.
-
-    Attributes:
-    ----------
-    name : str
-        The name of the attribute to be updated in the DataService instance.
-        If the attribute is part of a nested structure, this would be the name of the
-        attribute in the last nested object. For example, for an attribute access path
-        'attr1.list_attr[0].attr2', 'attr2' would be the name.
-
-    parent_path : str
-        The access path for the parent object of the attribute to be updated. This is
-        used to construct the full access path for the attribute. For example, for an
-        attribute access path 'attr1.list_attr[0].attr2', 'attr1.list_attr[0]' would be
-        the parent_path.
-
-    value : Any
-        The new value to be assigned to the attribute. The type of this value should
-        match the type of the attribute to be updated.
-    """
-
-    name: str
-    parent_path: str
-    value: Any
-
-
-class RunMethodDict(TypedDict):
-    """
-    A TypedDict subclass representing a dictionary used for running methods from the
-    exposed DataService.
-
-    Attributes:
-        name (str): The name of the method to be run.
-        parent_path (str): The access path for the parent object of the method to be
-            run. This is used to construct the full access path for the method. For
-            example, for an method with access path 'attr1.list_attr[0].method_name',
-            'attr1.list_attr[0]' would be the parent_path.
-        kwargs (dict[str, Any]): The arguments passed to the method.
-    """
-
-    name: str
-    parent_path: str
-    kwargs: dict[str, Any]
-
-
-class WebAPI:
-    __sio_app: socketio.ASGIApp
-    __fastapi_app: FastAPI
-
-    def __init__(  # noqa: PLR0913
-        self,
-        service: DataService,
-        state_manager: StateManager,
-        frontend: str | Path | None = None,
-        css: str | Path | None = None,
-        enable_cors: bool = True,
-        *args: Any,
-        **kwargs: Any,
-    ) -> None:
-        self.service = service
-        self.state_manager = state_manager
-        self.frontend = frontend
-        self.css = css
-        self.enable_cors = enable_cors
-        self.args = args
-        self.kwargs = kwargs
-
-        self.setup_socketio()
-        self.setup_fastapi_app()
-        self.setup_logging_handler()
-
-    def setup_logging_handler(self) -> None:
-        logger = logging.getLogger()
-        logger.addHandler(SocketIOHandler(self.__sio))
-
-    def setup_socketio(self) -> None:
-        # the socketio ASGI app, to notify clients when params update
-        if self.enable_cors:
-            sio = socketio.AsyncServer(async_mode="asgi", cors_allowed_origins="*")
-        else:
-            sio = socketio.AsyncServer(async_mode="asgi")
-
-        @sio.event
-        def set_attribute(sid: str, data: UpdateDict) -> Any:
-            logger.debug("Received frontend update: %s", data)
-            path_list = [*data["parent_path"].split("."), data["name"]]
-            path_list.remove("DataService")  # always at the start, does not do anything
-            path = ".".join(path_list)
-            return self.state_manager.set_service_attribute_value_by_path(
-                path=path, value=data["value"]
-            )
-
-        @sio.event
-        def run_method(sid: str, data: RunMethodDict) -> Any:
-            logger.debug("Running method: %s", data)
-            path_list = [*data["parent_path"].split("."), data["name"]]
-            path_list.remove("DataService")  # always at the start, does not do anything
-            method = get_object_attr_from_path_list(self.service, path_list)
-            return process_callable_attribute(method, data["kwargs"])
-
-        self.__sio = sio
-        self.__sio_app = socketio.ASGIApp(self.__sio)
-
-    def setup_fastapi_app(self) -> None:
-        app = FastAPI()
-
-        if self.enable_cors:
-            app.add_middleware(
-                CORSMiddleware,
-                allow_credentials=True,
-                allow_origins=["*"],
-                allow_methods=["*"],
-                allow_headers=["*"],
-            )
-        app.mount("/ws", self.__sio_app)
-
-        @app.get("/version")
-        def version() -> str:
-            return __version__
-
-        @app.get("/name")
-        def name() -> str:
-            return self.service.get_service_name()
-
-        @app.get("/service-properties")
-        def service_properties() -> dict[str, Any]:
-            return self.state_manager.cache
-
-        # exposing custom.css file provided by user
-        if self.css is not None:
-
-            @app.get("/custom.css")
-            async def styles() -> FileResponse:
-                return FileResponse(str(self.css))
-
-        app.mount(
-            "/",
-            StaticFiles(
-                directory=Path(__file__).parent.parent / "frontend",
-                html=True,
-            ),
-        )
-
-        self.__fastapi_app = app
-
-    @property
-    def sio(self) -> socketio.AsyncServer:
-        return self.__sio
-
-    @property
-    def fastapi_app(self) -> FastAPI:
-        return self.__fastapi_app

src/pydase/server/web_server/__init__.py

@@ -0,0 +1,3 @@
+from pydase.server.web_server.web_server import WebServer
+
+__all__ = ["WebServer"]

src/pydase/server/web_server/sio_setup.py

@@ -0,0 +1,144 @@
+import asyncio
+import logging
+from typing import Any, TypedDict
+
+import socketio  # type: ignore[import-untyped]
+
+from pydase.data_service.data_service import process_callable_attribute
+from pydase.data_service.data_service_observer import DataServiceObserver
+from pydase.data_service.state_manager import StateManager
+from pydase.utils.helpers import get_object_attr_from_path_list
+from pydase.utils.logging import SocketIOHandler
+from pydase.utils.serializer import SerializedObject
+
+logger = logging.getLogger(__name__)
+
+
+class UpdateDict(TypedDict):
+    """
+    A TypedDict subclass representing a dictionary used for updating attributes in a
+    DataService.
+
+    Attributes:
+    ----------
+    name : str
+        The name of the attribute to be updated in the DataService instance.
+        If the attribute is part of a nested structure, this would be the name of the
+        attribute in the last nested object. For example, for an attribute access path
+        'attr1.list_attr[0].attr2', 'attr2' would be the name.
+
+    parent_path : str
+        The access path for the parent object of the attribute to be updated. This is
+        used to construct the full access path for the attribute. For example, for an
+        attribute access path 'attr1.list_attr[0].attr2', 'attr1.list_attr[0]' would be
+        the parent_path.
+
+    value : Any
+        The new value to be assigned to the attribute. The type of this value should
+        match the type of the attribute to be updated.
+    """
+
+    name: str
+    parent_path: str
+    value: Any
+
+
+class RunMethodDict(TypedDict):
+    """
+    A TypedDict subclass representing a dictionary used for running methods from the
+    exposed DataService.
+
+    Attributes:
+        name (str): The name of the method to be run.
+        parent_path (str): The access path for the parent object of the method to be
+            run. This is used to construct the full access path for the method. For
+            example, for an method with access path 'attr1.list_attr[0].method_name',
+            'attr1.list_attr[0]' would be the parent_path.
+        kwargs (dict[str, Any]): The arguments passed to the method.
+    """
+
+    name: str
+    parent_path: str
+    kwargs: dict[str, Any]
+
+
+def setup_sio_server(
+    observer: DataServiceObserver,
+    enable_cors: bool,
+    loop: asyncio.AbstractEventLoop,
+) -> socketio.AsyncServer:
+    """
+    Sets up and configures a Socket.IO asynchronous server.
+
+    Args:
+        observer (DataServiceObserver):
+          The observer managing state updates and communication.
+        enable_cors (bool):
+          Flag indicating whether CORS should be enabled for the server.
+        loop (asyncio.AbstractEventLoop):
+          The event loop in which the server will run.
+
+    Returns:
+        socketio.AsyncServer: The configured Socket.IO asynchronous server.
+    """
+
+    state_manager = observer.state_manager
+
+    if enable_cors:
+        sio = socketio.AsyncServer(async_mode="asgi", cors_allowed_origins="*")
+    else:
+        sio = socketio.AsyncServer(async_mode="asgi")
+
+    setup_sio_events(sio, state_manager)
+    setup_logging_handler(sio)
+
+    # Add notification callback to observer
+    def sio_callback(
+        full_access_path: str, value: Any, cached_value_dict: SerializedObject
+    ) -> None:
+        if cached_value_dict != {}:
+
+            async def notify() -> None:
+                try:
+                    await sio.emit(
+                        "notify",
+                        {
+                            "data": {
+                                "full_access_path": full_access_path,
+                                "value": cached_value_dict,
+                            }
+                        },
+                    )
+                except Exception as e:
+                    logger.warning("Failed to send notification: %s", e)
+
+            loop.create_task(notify())
+
+    observer.add_notification_callback(sio_callback)
+
+    return sio
+
+
+def setup_sio_events(sio: socketio.AsyncServer, state_manager: StateManager) -> None:
+    @sio.event
+    def set_attribute(sid: str, data: UpdateDict) -> Any:
+        logger.debug("Received frontend update: %s", data)
+        parent_path = data["parent_path"].split(".")
+        path_list = [element for element in parent_path if element] + [data["name"]]
+        path = ".".join(path_list)
+        return state_manager.set_service_attribute_value_by_path(
+            path=path, value=data["value"]
+        )
+
+    @sio.event
+    def run_method(sid: str, data: RunMethodDict) -> Any:
+        logger.debug("Running method: %s", data)
+        parent_path = data["parent_path"].split(".")
+        path_list = [element for element in parent_path if element] + [data["name"]]
+        method = get_object_attr_from_path_list(state_manager.service, path_list)
+        return process_callable_attribute(method, data["kwargs"])
+
+
+def setup_logging_handler(sio: socketio.AsyncServer) -> None:
+    logger = logging.getLogger()
+    logger.addHandler(SocketIOHandler(sio))

src/pydase/server/web_server/web_server.py

@@ -0,0 +1,190 @@
+import asyncio
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+import socketio  # type: ignore[import-untyped]
+import uvicorn
+from fastapi import FastAPI, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from pydase.config import ServiceConfig, WebServerConfig
+from pydase.data_service.data_service_observer import DataServiceObserver
+from pydase.server.web_server.sio_setup import (
+    setup_sio_server,
+)
+from pydase.utils.serializer import generate_serialized_data_paths
+from pydase.version import __version__
+
+logger = logging.getLogger(__name__)
+
+
+class WebServer:
+    """
+    Represents a web server that adheres to the AdditionalServerProtocol, designed to
+    work with a DataService instance. This server facilitates client-server
+    communication and state management through web protocols and socket connections.
+
+    The WebServer class initializes and manages a web server environment using FastAPI
+    and Socket.IO, allowing for HTTP and WebSocket communications. It incorporates CORS
+    (Cross-Origin Resource Sharing) support, custom CSS, and serves a frontend static
+    files directory. It also initializes web server settings based on configuration
+    files or generates default settings if necessary.
+
+    Configuration for the web server (like service configuration directory and whether
+    to generate new web settings) is determined in the following order of precedence:
+    1. Values provided directly to the constructor.
+    2. Environment variable settings (via configuration classes like
+      `pydase.config.ServiceConfig` and `pydase.config.WebServerConfig`).
+    3. Default values defined in the configuration classes.
+
+    Args:
+        data_service_observer (DataServiceObserver): Observer for the DataService,
+          handling state updates and communication to connected clients.
+        host (str): Hostname or IP address where the server is accessible. Commonly
+          '0.0.0.0' to bind to all network interfaces.
+        port (int): Port number on which the server listens. Typically in the range
+          1024-65535 (non-standard ports).
+        css (str | Path | None, optional): Path to a custom CSS file for styling the
+          frontend. If None, no custom styles are applied. Defaults to None.
+        enable_cors (bool, optional): Flag to enable or disable CORS policy. When True,
+          CORS is enabled, allowing cross-origin requests. Defaults to True.
+        config_dir (Path | None, optional): Path to the configuration
+          directory where the web settings will be stored. Defaults to
+          `pydase.config.ServiceConfig().config_dir`.
+        generate_new_web_settings (bool | None, optional): Flag to enable or disable
+          generation of new web settings if the configuration file is missing. Defaults
+          to `pydase.config.WebServerConfig().generate_new_web_settings`.
+        **kwargs (Any): Additional unused keyword arguments.
+    """
+
+    def __init__(  # noqa: PLR0913
+        self,
+        data_service_observer: DataServiceObserver,
+        host: str,
+        port: int,
+        css: str | Path | None = None,
+        enable_cors: bool = True,
+        config_dir: Path = ServiceConfig().config_dir,
+        generate_web_settings: bool = WebServerConfig().generate_web_settings,
+        frontend_src: Path = Path(__file__).parent.parent.parent / "frontend",
+    ) -> None:
+        self.observer = data_service_observer
+        self.state_manager = self.observer.state_manager
+        self.service = self.state_manager.service
+        self.port = port
+        self.host = host
+        self.css = css
+        self.enable_cors = enable_cors
+        self.frontend_src = frontend_src
+        self._service_config_dir = config_dir
+        self._generate_web_settings = generate_web_settings
+        self._loop: asyncio.AbstractEventLoop
+        self._initialise_configuration()
+
+    async def serve(self) -> None:
+        self._loop = asyncio.get_running_loop()
+        self._setup_socketio()
+        self._setup_fastapi_app()
+        self.web_server = uvicorn.Server(
+            uvicorn.Config(self.__fastapi_app, host=self.host, port=self.port)
+        )
+        # overwrite uvicorn's signal handlers, otherwise it will bogart SIGINT and
+        # SIGTERM, which makes it impossible to escape out of
+        self.web_server.install_signal_handlers = lambda: None  # type: ignore[method-assign]
+        await self.web_server.serve()
+
+    def _initialise_configuration(self) -> None:
+        logger.debug("Initialising web server configuration...")
+
+        file_path = self._service_config_dir / "web_settings.json"
+
+        if self._generate_web_settings:
+            # File does not exist, create it with default content
+            logger.debug("Generating web settings file...")
+            file_path.parent.mkdir(
+                parents=True, exist_ok=True
+            )  # Ensure directory exists
+            file_path.write_text(json.dumps(self.web_settings, indent=4))
+
+    def _get_web_settings_from_file(self) -> dict[str, dict[str, Any]]:
+        file_path = self._service_config_dir / "web_settings.json"
+        web_settings = {}
+
+        # File exists, read its content
+        if file_path.exists():
+            logger.debug(
+                "Reading configuration from file '%s' ...", file_path.absolute()
+            )
+
+            web_settings = json.loads(file_path.read_text())
+
+        return web_settings
+
+    @property
+    def web_settings(self) -> dict[str, dict[str, Any]]:
+        current_web_settings = self._get_web_settings_from_file()
+        for path in generate_serialized_data_paths(self.state_manager.cache_value):
+            if path in current_web_settings:
+                continue
+
+            current_web_settings[path] = {
+                "displayName": path.split(".")[-1],
+                "display": True,
+            }
+
+        return current_web_settings
+
+    def _setup_socketio(self) -> None:
+        self._sio = setup_sio_server(self.observer, self.enable_cors, self._loop)
+        self.__sio_app = socketio.ASGIApp(self._sio)
+
+    def _setup_fastapi_app(self) -> None:  # noqa: C901
+        app = FastAPI()
+
+        if self.enable_cors:
+            app.add_middleware(
+                CORSMiddleware,
+                allow_credentials=True,
+                allow_origins=["*"],
+                allow_methods=["*"],
+                allow_headers=["*"],
+            )
+        app.mount("/ws", self.__sio_app)
+
+        @app.get("/version")
+        def version() -> str:
+            return __version__
+
+        @app.get("/name")
+        def name() -> str:
+            return type(self.service).__name__
+
+        @app.get("/service-properties")
+        def service_properties() -> dict[str, Any]:
+            return self.state_manager.cache  # type: ignore
+
+        @app.get("/web-settings")
+        def web_settings() -> dict[str, Any]:
+            return self.web_settings
+
+        # exposing custom.css file provided by user
+        @app.get("/custom.css")
+        async def styles() -> Response:
+            if self.css is not None:
+                return FileResponse(str(self.css))
+
+            return Response(content="", media_type="text/css")
+
+        app.mount(
+            "/",
+            StaticFiles(
+                directory=self.frontend_src,
+                html=True,
+            ),
+        )
+
+        self.__fastapi_app = app

src/pydase/utils/decorators.py

@@ -0,0 +1,27 @@
+from collections.abc import Callable
+from typing import Any
+
+from pydase.utils.helpers import function_has_arguments
+
+
+class FunctionDefinitionError(Exception):
+    pass
+
+
+def frontend(func: Callable[..., Any]) -> Callable[..., Any]:
+    """
+    Decorator to mark a DataService method for frontend rendering. Ensures that the
+    method does not contain arguments, as they are not supported for frontend rendering.
+    """
+
+    if function_has_arguments(func):
+        raise FunctionDefinitionError(
+            "The @frontend decorator requires functions without arguments. Function "
+            f"'{func.__name__}' has at least one argument. "
+            "Please remove the argument(s) from this function to use it with the "
+            "@frontend decorator."
+        )
+
+    # Mark the function for frontend display.
+    func._display_in_frontend = True  # type: ignore
+    return func

src/pydase/utils/helpers.py

@@ -1,5 +1,6 @@
 import inspect
 import logging
+from collections.abc import Callable
 from itertools import chain
 from typing import Any
 
@@ -196,3 +197,29 @@ def get_data_service_class_reference() -> Any:
 
 def is_property_attribute(target_obj: Any, attr_name: str) -> bool:
     return isinstance(getattr(type(target_obj), attr_name, None), property)
+
+
+def function_has_arguments(func: Callable[..., Any]) -> bool:
+    sig = inspect.signature(func)
+    parameters = dict(sig.parameters)
+    # Remove 'self' parameter for instance methods.
+    parameters.pop("self", None)
+
+    # Check if there are any parameters left which would indicate additional arguments.
+    if len(parameters) > 0:
+        return True
+    return False
+
+
+def render_in_frontend(func: Callable[..., Any]) -> bool:
+    """Determines if the method should be rendered in the frontend.
+
+    It checks if the "@frontend" decorator was used or the method is a coroutine."""
+
+    if inspect.iscoroutinefunction(func):
+        return True
+
+    try:
+        return func._display_in_frontend  # type: ignore
+    except AttributeError:
+        return False

src/pydase/utils/serializer.py

@@ -1,18 +1,30 @@
+from __future__ import annotations
+
 import inspect
 import logging
-from collections.abc import Callable
+import sys
 from enum import Enum
-from typing import Any
+from typing import TYPE_CHECKING, Any, TypedDict, cast
+
+if sys.version_info < (3, 11):
+    from typing_extensions import NotRequired
+else:
+    from typing import NotRequired
 
 import pydase.units as u
 from pydase.data_service.abstract_data_service import AbstractDataService
+from pydase.data_service.task_manager import TaskStatus
 from pydase.utils.helpers import (
     get_attribute_doc,
     get_component_classes,
     get_data_service_class_reference,
     parse_list_attr_and_index,
+    render_in_frontend,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 logger = logging.getLogger(__name__)
 
 
@@ -24,10 +36,31 @@ class SerializationValueError(Exception):
     pass
 
 
+class SignatureDict(TypedDict):
+    parameters: dict[str, dict[str, Any]]
+    return_annotation: dict[str, Any]
+
+
+SerializedObject = TypedDict(
+    "SerializedObject",
+    {
+        "name": NotRequired[str],
+        "value": "list[SerializedObject] | float | int | str | bool | dict[str, Any] | None",  # noqa: E501
+        "type": str | None,
+        "doc": str | None,
+        "readonly": bool,
+        "enum": NotRequired[dict[str, Any]],
+        "async": NotRequired[bool],
+        "signature": NotRequired[SignatureDict],
+        "frontend_render": NotRequired[bool],
+    },
+)
+
+
 class Serializer:
     @staticmethod
-    def serialize_object(obj: Any) -> dict[str, Any]:
-        result: dict[str, Any] = {}
+    def serialize_object(obj: Any) -> SerializedObject:
+        result: SerializedObject
         if isinstance(obj, AbstractDataService):
             result = Serializer._serialize_data_service(obj)
 
@@ -64,11 +97,15 @@ class Serializer:
         return result
 
     @staticmethod
-    def _serialize_enum(obj: Enum) -> dict[str, Any]:
+    def _serialize_enum(obj: Enum) -> SerializedObject:
+        import pydase.components.coloured_enum
+
         value = obj.name
         readonly = False
-        doc = get_attribute_doc(obj)
-        if type(obj).__base__.__name__ == "ColouredEnum":
+        doc = obj.__doc__
+        if sys.version_info < (3, 11) and doc == "An enumeration.":
+            doc = None
+        if isinstance(obj, pydase.components.coloured_enum.ColouredEnum):
             obj_type = "ColouredEnum"
         else:
             obj_type = "Enum"
@@ -84,7 +121,7 @@ class Serializer:
         }
 
     @staticmethod
-    def _serialize_quantity(obj: u.Quantity) -> dict[str, Any]:
+    def _serialize_quantity(obj: u.Quantity) -> SerializedObject:
         obj_type = "Quantity"
         readonly = False
         doc = get_attribute_doc(obj)
@@ -97,7 +134,7 @@ class Serializer:
         }
 
     @staticmethod
-    def _serialize_dict(obj: dict[str, Any]) -> dict[str, Any]:
+    def _serialize_dict(obj: dict[str, Any]) -> SerializedObject:
         obj_type = "dict"
         readonly = False
         doc = get_attribute_doc(obj)
@@ -110,7 +147,7 @@ class Serializer:
         }
 
     @staticmethod
-    def _serialize_list(obj: list[Any]) -> dict[str, Any]:
+    def _serialize_list(obj: list[Any]) -> SerializedObject:
         obj_type = "list"
         readonly = False
         doc = get_attribute_doc(obj)
@@ -123,27 +160,24 @@ class Serializer:
         }
 
     @staticmethod
-    def _serialize_method(obj: Callable[..., Any]) -> dict[str, Any]:
+    def _serialize_method(obj: Callable[..., Any]) -> SerializedObject:
         obj_type = "method"
         value = None
         readonly = True
         doc = get_attribute_doc(obj)
+        frontend_render = render_in_frontend(obj)
 
         # Store parameters and their anotations in a dictionary
         sig = inspect.signature(obj)
-        parameters: dict[str, str | None] = {}
+        sig.return_annotation
+
+        signature: SignatureDict = {"parameters": {}, "return_annotation": {}}
 
         for k, v in sig.parameters.items():
-            annotation = v.annotation
-            if annotation is not inspect._empty:
-                if isinstance(annotation, type):
-                    # Handle regular types
-                    parameters[k] = annotation.__name__
-                else:
-                    # Union, string annotation, Literal types, ...
-                    parameters[k] = str(annotation)
-            else:
-                parameters[k] = None
+            signature["parameters"][k] = {
+                "annotation": str(v.annotation),
+                "default": {} if v.default == inspect._empty else dump(v.default),
+            }
 
         return {
             "type": obj_type,
@@ -151,14 +185,16 @@ class Serializer:
             "readonly": readonly,
             "doc": doc,
             "async": inspect.iscoroutinefunction(obj),
-            "parameters": parameters,
+            "signature": signature,
+            "frontend_render": frontend_render,
         }
 
     @staticmethod
-    def _serialize_data_service(obj: AbstractDataService) -> dict[str, Any]:
+    def _serialize_data_service(obj: AbstractDataService) -> SerializedObject:
         readonly = False
         doc = get_attribute_doc(obj)
         obj_type = "DataService"
+        obj_name = obj.__class__.__name__
 
         # Get component base class if any
         component_base_cls = next(
@@ -174,7 +210,7 @@ class Serializer:
         # Get the difference between the two sets
         derived_only_attr_set = obj_attr_set - data_service_attr_set
 
-        value = {}
+        value: dict[str, SerializedObject] = {}
 
         # Iterate over attributes, properties, class attributes, and methods
         for key in sorted(derived_only_attr_set):
@@ -197,8 +233,7 @@ class Serializer:
 
             # If there's a running task for this method
             if key in obj._task_manager.tasks:
-                task_info = obj._task_manager.tasks[key]
-                value[key]["value"] = task_info["kwargs"]
+                value[key]["value"] = TaskStatus.RUNNING.name
 
             # If the DataService attribute is a property
             if isinstance(getattr(obj.__class__, key, None), property):
@@ -207,6 +242,7 @@ class Serializer:
                 value[key]["doc"] = get_attribute_doc(prop)  # overwrite the doc
 
         return {
+            "name": obj_name,
             "type": obj_type,
             "value": value,
             "readonly": readonly,
@@ -214,12 +250,12 @@ class Serializer:
         }
 
 
-def dump(obj: Any) -> dict[str, Any]:
+def dump(obj: Any) -> SerializedObject:
     return Serializer.serialize_object(obj)
 
 
 def set_nested_value_by_path(
-    serialization_dict: dict[str, Any], path: str, value: Any
+    serialization_dict: dict[str, SerializedObject], path: str, value: Any
 ) -> None:
     """
     Set a value in a nested dictionary structure, which conforms to the serialization
@@ -241,53 +277,67 @@ def set_nested_value_by_path(
     """
 
     parent_path_parts, attr_name = path.split(".")[:-1], path.split(".")[-1]
-    current_dict: dict[str, Any] = serialization_dict
+    current_dict: dict[str, SerializedObject] = serialization_dict
 
     try:
         for path_part in parent_path_parts:
-            current_dict = get_next_level_dict_by_key(
+            next_level_serialized_object = get_next_level_dict_by_key(
                 current_dict, path_part, allow_append=False
             )
-            current_dict = current_dict["value"]
+            current_dict = cast(
+                dict[str, SerializedObject], next_level_serialized_object["value"]
+            )
 
-        current_dict = get_next_level_dict_by_key(
+        next_level_serialized_object = get_next_level_dict_by_key(
             current_dict, attr_name, allow_append=True
         )
     except (SerializationPathError, SerializationValueError, KeyError) as e:
         logger.error(e)
         return
 
-    # setting the new value
-    serialized_value = dump(value)
-    if "readonly" in current_dict:
-        if current_dict["type"] != "method":
-            current_dict["type"] = serialized_value["type"]
-        current_dict["value"] = serialized_value["value"]
+    if next_level_serialized_object["type"] == "method":  # state change of task
+        next_level_serialized_object["value"] = (
+            value.name if isinstance(value, Enum) else None
+        )
     else:
-        current_dict.update(serialized_value)
+        serialized_value = dump(value)
+        keys_to_keep = set(serialized_value.keys())
+
+        # TODO: you might also want to pop "doc" from serialized_value if
+        # it is overwriting the value of the current dict
+        serialized_value.pop("readonly")  # type: ignore
+
+        next_level_serialized_object.update(serialized_value)
+
+        # removes keys that are not present in the serialized new value
+        for key in list(next_level_serialized_object.keys()):
+            if key not in keys_to_keep:
+                next_level_serialized_object.pop(key, None)  # type: ignore
 
 
 def get_nested_dict_by_path(
-    serialization_dict: dict[str, Any],
+    serialization_dict: dict[str, SerializedObject],
     path: str,
-) -> dict[str, Any]:
+) -> SerializedObject:
     parent_path_parts, attr_name = path.split(".")[:-1], path.split(".")[-1]
-    current_dict: dict[str, Any] = serialization_dict
+    current_dict: dict[str, SerializedObject] = serialization_dict
 
     for path_part in parent_path_parts:
-        current_dict = get_next_level_dict_by_key(
+        next_level_serialized_object = get_next_level_dict_by_key(
             current_dict, path_part, allow_append=False
         )
-        current_dict = current_dict["value"]
+        current_dict = cast(
+            dict[str, SerializedObject], next_level_serialized_object["value"]
+        )
     return get_next_level_dict_by_key(current_dict, attr_name, allow_append=False)
 
 
 def get_next_level_dict_by_key(
-    serialization_dict: dict[str, Any],
+    serialization_dict: dict[str, SerializedObject],
     attr_name: str,
     *,
     allow_append: bool = False,
-) -> dict[str, Any]:
+) -> SerializedObject:
     """
     Retrieve a nested dictionary entry or list item from a data structure serialized
     with `pydase.utils.serializer.Serializer`.
@@ -312,14 +362,30 @@ def get_next_level_dict_by_key(
 
     try:
         if index is not None:
-            serialization_dict = serialization_dict[attr_name]["value"][index]
+            next_level_serialized_object = cast(
+                list[SerializedObject], serialization_dict[attr_name]["value"]
+            )[index]
         else:
-            serialization_dict = serialization_dict[attr_name]
+            next_level_serialized_object = serialization_dict[attr_name]
     except IndexError as e:
-        if allow_append and index == len(serialization_dict[attr_name]["value"]):
+        if (
+            index is not None
+            and allow_append
+            and index
+            == len(cast(list[SerializedObject], serialization_dict[attr_name]["value"]))
+        ):
             # Appending to list
-            serialization_dict[attr_name]["value"].append({})
-            serialization_dict = serialization_dict[attr_name]["value"][index]
+            cast(list[SerializedObject], serialization_dict[attr_name]["value"]).append(
+                {
+                    "value": None,
+                    "type": None,
+                    "doc": None,
+                    "readonly": False,
+                }
+            )
+            next_level_serialized_object = cast(
+                list[SerializedObject], serialization_dict[attr_name]["value"]
+            )[index]
         else:
             raise SerializationPathError(
                 f"Error occured trying to change '{attr_name}[{index}]': {e}"
@@ -331,13 +397,13 @@ def get_next_level_dict_by_key(
             "a 'value' key."
         )
 
-    if not isinstance(serialization_dict, dict):
+    if not isinstance(next_level_serialized_object, dict):
         raise SerializationValueError(
             f"Expected a dictionary at '{attr_name}', but found type "
-            f"'{type(serialization_dict).__name__}' instead."
+            f"'{type(next_level_serialized_object).__name__}' instead."
         )
 
-    return serialization_dict
+    return next_level_serialized_object
 
 
 def generate_serialized_data_paths(
@@ -346,36 +412,43 @@ def generate_serialized_data_paths(
     """
     Generate a list of access paths for all attributes in a dictionary representing
     data serialized with `pydase.utils.serializer.Serializer`, excluding those that are
-    methods.
+    methods. This function handles nested structures, including lists, by generating
+    paths for each element in the nested lists.
 
     Args:
-        data: The dictionary representing serialized data, typically produced by
-            `pydase.utils.serializer.Serializer`.
-        parent_path: The base path to prepend to the keys in the `data` dictionary to
-            form the access paths. Defaults to an empty string.
+        data (dict[str, Any]): The dictionary representing serialized data, typically
+            produced by `pydase.utils.serializer.Serializer`.
+        parent_path (str, optional): The base path to prepend to the keys in the `data`
+            dictionary to form the access paths. Defaults to an empty string.
 
     Returns:
-        A list of strings where each string is a dot-notation access path to an
-        attribute in the serialized data.
+        list[str]: A list of strings where each string is a dot-notation access path
+        to an attribute in the serialized data. For list elements, the path includes
+        the index in square brackets.
     """
 
     paths: list[str] = []
     for key, value in data.items():
-        if value["type"] == "method":
-            # ignoring methods
-            continue
         new_path = f"{parent_path}.{key}" if parent_path else key
-        if isinstance(value["value"], dict) and value["type"] != "Quantity":
-            paths.extend(generate_serialized_data_paths(value["value"], new_path))
-        elif isinstance(value["value"], list):
-            for index, item in enumerate(value["value"]):
-                indexed_key_path = f"{new_path}[{index}]"
-                if isinstance(item["value"], dict):
-                    paths.extend(
-                        generate_serialized_data_paths(item["value"], indexed_key_path)
-                    )
-                else:
+        paths.append(new_path)
+        if serialized_dict_is_nested_object(value):
+            if isinstance(value["value"], list):
+                for index, item in enumerate(value["value"]):
+                    indexed_key_path = f"{new_path}[{index}]"
                     paths.append(indexed_key_path)
-        else:
-            paths.append(new_path)
+                    if serialized_dict_is_nested_object(item):
+                        paths.extend(
+                            generate_serialized_data_paths(
+                                item["value"], indexed_key_path
+                            )
+                        )
+                continue
+            paths.extend(generate_serialized_data_paths(value["value"], new_path))
     return paths
+
+
+def serialized_dict_is_nested_object(serialized_dict: SerializedObject) -> bool:
+    return (
+        serialized_dict["type"] != "Quantity"
+        and isinstance(serialized_dict["value"], dict)
+    ) or isinstance(serialized_dict["value"], list)

tests/components/test_device_connection.py

@@ -0,0 +1,32 @@
+import asyncio
+import logging
+
+import pydase
+import pydase.components.device_connection
+from pytest import LogCaptureFixture
+
+from tests.utils.test_serializer import pytest
+
+logger = logging.getLogger(__name__)
+
+
+@pytest.mark.asyncio
+async def test_reconnection(caplog: LogCaptureFixture) -> None:
+    class MyService(pydase.components.device_connection.DeviceConnection):
+        def __init__(
+            self,
+        ) -> None:
+            super().__init__()
+            self._reconnection_wait_time = 0.01
+
+        def connect(self) -> None:
+            self._connected = True
+
+    service_instance = MyService()
+
+    assert service_instance._connected is False
+
+    service_instance._task_manager.start_autostart_tasks()
+
+    await asyncio.sleep(0.01)
+    assert service_instance._connected is True

tests/components/test_image.py

@@ -0,0 +1,141 @@
+import logging
+
+import pydase
+import pydase.components
+from pydase.data_service.data_service_observer import DataServiceObserver
+from pydase.data_service.state_manager import StateManager
+from pydase.utils.serializer import dump
+from pytest import LogCaptureFixture
+
+logger = logging.getLogger(__name__)
+
+
+def test_image_functions(caplog: LogCaptureFixture) -> None:
+    class MyService(pydase.DataService):
+        def __init__(self) -> None:
+            super().__init__()
+            self.my_image = pydase.components.Image()
+
+    service_instance = MyService()
+    state_manager = StateManager(service_instance)
+    DataServiceObserver(state_manager)
+
+    service_instance.my_image.load_from_url("https://cataas.com/cat")
+
+    caplog.clear()
+
+
+def test_image_serialization() -> None:
+    class MyService(pydase.DataService):
+        def __init__(self) -> None:
+            super().__init__()
+            self.my_image = pydase.components.Image()
+
+    assert dump(MyService()) == {
+        "name": "MyService",
+        "type": "DataService",
+        "value": {
+            "my_image": {
+                "name": "Image",
+                "type": "Image",
+                "value": {
+                    "format": {
+                        "type": "str",
+                        "value": "",
+                        "readonly": True,
+                        "doc": None,
+                    },
+                    "load_from_base64": {
+                        "type": "method",
+                        "value": None,
+                        "readonly": True,
+                        "doc": None,
+                        "async": False,
+                        "signature": {
+                            "parameters": {
+                                "value_": {
+                                    "annotation": "<class 'bytes'>",
+                                    "default": {},
+                                },
+                                "format_": {
+                                    "annotation": "str | None",
+                                    "default": {
+                                        "type": "NoneType",
+                                        "value": None,
+                                        "readonly": False,
+                                        "doc": None,
+                                    },
+                                },
+                            },
+                            "return_annotation": {},
+                        },
+                        "frontend_render": False,
+                    },
+                    "load_from_matplotlib_figure": {
+                        "type": "method",
+                        "value": None,
+                        "readonly": True,
+                        "doc": None,
+                        "async": False,
+                        "signature": {
+                            "parameters": {
+                                "fig": {"annotation": "Figure", "default": {}},
+                                "format_": {
+                                    "annotation": "<class 'str'>",
+                                    "default": {
+                                        "type": "str",
+                                        "value": "png",
+                                        "readonly": False,
+                                        "doc": None,
+                                    },
+                                },
+                            },
+                            "return_annotation": {},
+                        },
+                        "frontend_render": False,
+                    },
+                    "load_from_path": {
+                        "type": "method",
+                        "value": None,
+                        "readonly": True,
+                        "doc": None,
+                        "async": False,
+                        "signature": {
+                            "parameters": {
+                                "path": {
+                                    "annotation": "pathlib.Path | str",
+                                    "default": {},
+                                }
+                            },
+                            "return_annotation": {},
+                        },
+                        "frontend_render": False,
+                    },
+                    "load_from_url": {
+                        "type": "method",
+                        "value": None,
+                        "readonly": True,
+                        "doc": None,
+                        "async": False,
+                        "signature": {
+                            "parameters": {
+                                "url": {"annotation": "<class 'str'>", "default": {}}
+                            },
+                            "return_annotation": {},
+                        },
+                        "frontend_render": False,
+                    },
+                    "value": {
+                        "type": "str",
+                        "value": "",
+                        "readonly": True,
+                        "doc": None,
+                    },
+                },
+                "readonly": False,
+                "doc": None,
+            }
+        },
+        "readonly": False,
+        "doc": None,
+    }

tests/data_service/test_data_service.py

@@ -1,9 +1,14 @@
 from enum import Enum
+from typing import Any
 
+import pydase
 import pydase.units as u
+import pytest
 from pydase import DataService
 from pydase.data_service.data_service_observer import DataServiceObserver
 from pydase.data_service.state_manager import StateManager
+from pydase.data_service.task_manager import TaskDefinitionError
+from pydase.utils.decorators import FunctionDefinitionError, frontend
 from pytest import LogCaptureFixture
 
 
@@ -114,3 +119,19 @@ def test_protected_and_private_attribute_warning(caplog: LogCaptureFixture) -> N
         "Class 'SubClass' does not inherit from DataService. This may lead to "
         "unexpected behaviour!"
     ) not in caplog.text
+
+
+def test_exposing_methods() -> None:
+    class ClassWithTask(pydase.DataService):
+        async def some_task(self, sleep_time: int) -> None:
+            pass
+
+    with pytest.raises(TaskDefinitionError):
+        ClassWithTask()
+
+    with pytest.raises(FunctionDefinitionError):
+
+        class ClassWithMethod(pydase.DataService):
+            @frontend
+            def some_method(self, *args: Any) -> str:
+                return "some method"

tests/data_service/test_data_service_cache.py

@@ -1,6 +1,7 @@
 import logging
 
 import pydase
+import pytest
 from pydase.data_service.data_service_observer import DataServiceObserver
 from pydase.data_service.state_manager import StateManager
 
@@ -34,7 +35,8 @@ def test_nested_attributes_cache_callback() -> None:
     )
 
 
-def test_task_status_update() -> None:
+@pytest.mark.asyncio
+async def test_task_status_update() -> None:
     class ServiceClass(pydase.DataService):
         name = "World"
 
@@ -65,5 +67,5 @@ def test_task_status_update() -> None:
         state_manager._data_service_cache.get_value_dict_from_cache("my_method")[
             "value"
         ]
-        == {}
+        == "RUNNING"
     )

tests/data_service/test_data_service_observer.py

@@ -94,3 +94,31 @@ def test_protected_or_private_change_logs(caplog: pytest.LogCaptureFixture) -> N
 
     service.subclass._name = "Hello"
     assert "'subclass._name' changed to 'Hello'" not in caplog.text
+
+
+def test_dynamic_list_entry_with_property(caplog: pytest.LogCaptureFixture) -> None:
+    class PropertyClass(pydase.DataService):
+        _name = "Hello"
+
+        @property
+        def name(self) -> str:
+            """The name property."""
+            return self._name
+
+    class MyService(pydase.DataService):
+        def __init__(self) -> None:
+            super().__init__()
+            self.list_attr = []
+
+        def toggle_high_voltage(self) -> None:
+            self.list_attr = []
+            self.list_attr.append(PropertyClass())
+            self.list_attr[0]._name = "Hoooo"
+
+    service = MyService()
+    state_manager = StateManager(service)
+    DataServiceObserver(state_manager)
+    service.toggle_high_voltage()
+
+    assert "'list_attr[0].name' changed to 'Hello'" not in caplog.text
+    assert "'list_attr[0].name' changed to 'Hoooo'" in caplog.text

tests/data_service/test_state_manager.py

@@ -3,9 +3,8 @@ from pathlib import Path
 from typing import Any
 
 import pydase
+import pydase.components
 import pydase.units as u
-import pytest
-from pydase.components.coloured_enum import ColouredEnum
 from pydase.data_service.data_service_observer import DataServiceObserver
 from pydase.data_service.state_manager import (
     StateManager,
@@ -19,12 +18,53 @@ class SubService(pydase.DataService):
     name = "SubService"
 
 
-class State(ColouredEnum):
+class State(pydase.components.ColouredEnum):
     RUNNING = "#0000FF80"
     COMPLETED = "hsl(120, 100%, 50%)"
     FAILED = "hsla(0, 100%, 50%, 0.7)"
 
 
+class MySlider(pydase.components.NumberSlider):
+    @property
+    def min(self) -> float:
+        return self._min
+
+    @min.setter
+    @load_state
+    def min(self, value: float) -> None:
+        self._min = value
+
+    @property
+    def max(self) -> float:
+        return self._max
+
+    @max.setter
+    @load_state
+    def max(self, value: float) -> None:
+        self._max = value
+
+    @property
+    def step_size(self) -> float:
+        return self._step_size
+
+    @step_size.setter
+    @load_state
+    def step_size(self, value: float) -> None:
+        self._step_size = value
+
+    @property
+    def value(self) -> float:
+        return self._value
+
+    @value.setter
+    @load_state
+    def value(self, value: float) -> None:
+        if value < self._min or value > self._max:
+            raise ValueError("Value is either below allowed min or above max value.")
+
+        self._value = value
+
+
 class Service(pydase.DataService):
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
@@ -35,6 +75,7 @@ class Service(pydase.DataService):
         self._property_attr = 1337.0
         self._name = "Service"
         self.state = State.RUNNING
+        self.my_slider = MySlider()
 
     @property
     def name(self) -> str:
@@ -49,7 +90,7 @@ class Service(pydase.DataService):
         self._property_attr = value
 
 
-CURRENT_STATE = Service().serialize()
+CURRENT_STATE = Service().serialize()["value"]
 
 LOAD_STATE = {
     "list_attr": {
@@ -61,6 +102,37 @@ LOAD_STATE = {
         "readonly": False,
         "doc": None,
     },
+    "my_slider": {
+        "type": "NumberSlider",
+        "value": {
+            "max": {
+                "type": "float",
+                "value": 101.0,
+                "readonly": False,
+                "doc": "The min property.",
+            },
+            "min": {
+                "type": "float",
+                "value": 1.0,
+                "readonly": False,
+                "doc": "The min property.",
+            },
+            "step_size": {
+                "type": "float",
+                "value": 2.0,
+                "readonly": False,
+                "doc": "The min property.",
+            },
+            "value": {
+                "type": "float",
+                "value": 1.0,
+                "readonly": False,
+                "doc": "The value property.",
+            },
+        },
+        "readonly": False,
+        "doc": None,
+    },
     "name": {
         "type": "str",
         "value": "Another name",
@@ -153,6 +225,10 @@ def test_load_state(tmp_path: Path, caplog: LogCaptureFixture) -> None:
     assert service.name == "Service"  # has not changed as readonly
     assert service.some_float == 1.0  # has not changed due to different type
     assert service.subservice.name == "SubService"  # didn't change
+    assert service.my_slider.value == 1.0  # changed
+    assert service.my_slider.min == 1.0  # changed
+    assert service.my_slider.max == 101.0  # changed
+    assert service.my_slider.step_size == 2.0  # changed
 
     assert "'some_unit' changed to '12.0 A'" in caplog.text
     assert (
@@ -168,16 +244,10 @@ def test_load_state(tmp_path: Path, caplog: LogCaptureFixture) -> None:
         "Ignoring value from JSON file..." in caplog.text
     )
     assert "Value of attribute 'subservice.name' has not changed..." in caplog.text
-
-
-def test_filename_warning(tmp_path: Path, caplog: LogCaptureFixture) -> None:
-    file = tmp_path / "test_state.json"
-
-    with pytest.warns(DeprecationWarning):
-        service = Service(filename=str(file))
-        StateManager(service=service, filename=str(file))
-
-    assert f"Overwriting filename {str(file)!r} with {str(file)!r}." in caplog.text
+    assert "'my_slider.value' changed to '1.0'" in caplog.text
+    assert "'my_slider.min' changed to '1.0'" in caplog.text
+    assert "'my_slider.max' changed to '101.0'" in caplog.text
+    assert "'my_slider.step_size' changed to '2.0'" in caplog.text
 
 
 def test_filename_error(caplog: LogCaptureFixture) -> None:

tests/data_service/test_task_manager.py

@@ -1,6 +1,8 @@
+import asyncio
 import logging
 
 import pydase
+import pytest
 from pydase.data_service.data_service_observer import DataServiceObserver
 from pydase.data_service.state_manager import StateManager
 from pytest import LogCaptureFixture
@@ -8,13 +10,14 @@ from pytest import LogCaptureFixture
 logger = logging.getLogger()
 
 
-def test_autostart_task_callback(caplog: LogCaptureFixture) -> None:
+@pytest.mark.asyncio
+async def test_autostart_task_callback(caplog: LogCaptureFixture) -> None:
     class MyService(pydase.DataService):
         def __init__(self) -> None:
             super().__init__()
             self._autostart_tasks = {  # type: ignore
-                "my_task": (),
-                "my_other_task": (),
+                "my_task": (),  # type: ignore
+                "my_other_task": (),  # type: ignore
             }
 
         async def my_task(self) -> None:
@@ -23,16 +26,18 @@ def test_autostart_task_callback(caplog: LogCaptureFixture) -> None:
         async def my_other_task(self) -> None:
             logger.info("Triggered other task.")
 
+    # Your test code here
     service_instance = MyService()
     state_manager = StateManager(service_instance)
     DataServiceObserver(state_manager)
     service_instance._task_manager.start_autostart_tasks()
 
-    assert "'my_task' changed to '{}'" in caplog.text
-    assert "'my_other_task' changed to '{}'" in caplog.text
+    assert "'my_task' changed to 'TaskStatus.RUNNING'" in caplog.text
+    assert "'my_other_task' changed to 'TaskStatus.RUNNING'" in caplog.text
 
 
-def test_DataService_subclass_autostart_task_callback(
+@pytest.mark.asyncio
+async def test_DataService_subclass_autostart_task_callback(
     caplog: LogCaptureFixture,
 ) -> None:
     class MySubService(pydase.DataService):
@@ -57,11 +62,12 @@ def test_DataService_subclass_autostart_task_callback(
     DataServiceObserver(state_manager)
     service_instance._task_manager.start_autostart_tasks()
 
-    assert "'sub_service.my_task' changed to '{}'" in caplog.text
-    assert "'sub_service.my_other_task' changed to '{}'" in caplog.text
+    assert "'sub_service.my_task' changed to 'TaskStatus.RUNNING'" in caplog.text
+    assert "'sub_service.my_other_task' changed to 'TaskStatus.RUNNING'" in caplog.text
 
 
-def test_DataService_subclass_list_autostart_task_callback(
+@pytest.mark.asyncio
+async def test_DataService_subclass_list_autostart_task_callback(
     caplog: LogCaptureFixture,
 ) -> None:
     class MySubService(pydase.DataService):
@@ -86,7 +92,44 @@ def test_DataService_subclass_list_autostart_task_callback(
     DataServiceObserver(state_manager)
     service_instance._task_manager.start_autostart_tasks()
 
-    assert "'sub_services_list[0].my_task' changed to '{}'" in caplog.text
-    assert "'sub_services_list[0].my_other_task' changed to '{}'" in caplog.text
-    assert "'sub_services_list[1].my_task' changed to '{}'" in caplog.text
-    assert "'sub_services_list[1].my_other_task' changed to '{}'" in caplog.text
+    assert (
+        "'sub_services_list[0].my_task' changed to 'TaskStatus.RUNNING'" in caplog.text
+    )
+    assert (
+        "'sub_services_list[0].my_other_task' changed to 'TaskStatus.RUNNING'"
+        in caplog.text
+    )
+    assert (
+        "'sub_services_list[1].my_task' changed to 'TaskStatus.RUNNING'" in caplog.text
+    )
+    assert (
+        "'sub_services_list[1].my_other_task' changed to 'TaskStatus.RUNNING'"
+        in caplog.text
+    )
+
+
+@pytest.mark.asyncio
+async def test_start_and_stop_task_methods(caplog: LogCaptureFixture) -> None:
+    class MyService(pydase.DataService):
+        def __init__(self) -> None:
+            super().__init__()
+
+        async def my_task(self) -> None:
+            while True:
+                logger.debug("Logging message")
+                await asyncio.sleep(0.1)
+
+    # Your test code here
+    service_instance = MyService()
+    state_manager = StateManager(service_instance)
+    DataServiceObserver(state_manager)
+    service_instance.start_my_task()
+    await asyncio.sleep(0.01)
+
+    assert "'my_task' changed to 'TaskStatus.RUNNING'" in caplog.text
+    assert "Logging message" in caplog.text
+    caplog.clear()
+
+    service_instance.stop_my_task()
+    await asyncio.sleep(0.01)
+    assert "Task 'my_task' was cancelled" in caplog.text

tests/server/test_server.py

@@ -1,8 +1,15 @@
+import json
 import signal
-
-from pytest_mock import MockerFixture
+from pathlib import Path
+from typing import Any
 
 import pydase
+import pydase.components
+import pydase.units as u
+from pydase.data_service.state_manager import load_state
+from pydase.server.server import Server
+from pytest import LogCaptureFixture
+from pytest_mock import MockerFixture
 
 
 def test_signal_handling(mocker: MockerFixture):
@@ -33,3 +40,64 @@ def test_signal_handling(mocker: MockerFixture):
     # Simulate receiving a SIGINT signal for the second time
     server.handle_exit(signal.SIGINT, None)
     mock_exit.assert_called_once_with(1)
+
+
+class Service(pydase.DataService):
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.some_unit: u.Quantity = 1.2 * u.units.A
+        self.some_float = 1.0
+        self._property_attr = 1337.0
+
+    @property
+    def property_attr(self) -> float:
+        return self._property_attr
+
+    @property_attr.setter
+    @load_state
+    def property_attr(self, value: float) -> None:
+        self._property_attr = value
+
+
+CURRENT_STATE = Service().serialize()
+
+LOAD_STATE = {
+    "some_float": {
+        "type": "float",
+        "value": 10.0,
+        "readonly": False,
+        "doc": None,
+    },
+    "property_attr": {
+        "type": "float",
+        "value": 1337.1,
+        "readonly": False,
+        "doc": None,
+    },
+    "some_unit": {
+        "type": "Quantity",
+        "value": {"magnitude": 12.0, "unit": "A"},
+        "readonly": False,
+        "doc": None,
+    },
+}
+
+
+def test_load_state(tmp_path: Path, caplog: LogCaptureFixture) -> None:
+    # Create a StateManager instance with a temporary file
+    file = tmp_path / "test_state.json"
+
+    # Write a temporary JSON file to read back
+    with open(file, "w") as f:
+        json.dump(LOAD_STATE, f, indent=4)
+
+    service = Service()
+    Server(service, filename=str(file))
+
+    assert service.some_unit == u.Quantity(12, "A")
+    assert service.property_attr == 1337.1
+    assert service.some_float == 10.0
+
+    assert "'some_unit' changed to '12.0 A'" in caplog.text
+    assert "'some_float' changed to '10.0'" in caplog.text
+    assert "'property_attr' changed to '1337.1'" in caplog.text

tests/server/web_server/test_sio_setup.py

@@ -0,0 +1,68 @@
+import asyncio
+import logging
+
+import pydase
+import pytest
+from pydase.data_service.data_service_observer import DataServiceObserver
+from pydase.data_service.state_manager import StateManager
+from pydase.server.web_server.sio_setup import (
+    RunMethodDict,
+    UpdateDict,
+    setup_sio_server,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@pytest.mark.asyncio
+async def test_set_attribute_event() -> None:
+    class SubClass(pydase.DataService):
+        name = "SubClass"
+
+    class ServiceClass(pydase.DataService):
+        def __init__(self) -> None:
+            super().__init__()
+            self.sub_class = SubClass()
+
+        def some_method(self) -> None:
+            logger.info("Triggered 'test_method'.")
+
+    service_instance = ServiceClass()
+    state_manager = StateManager(service_instance)
+    observer = DataServiceObserver(state_manager)
+
+    server = setup_sio_server(observer, False, asyncio.get_running_loop())
+
+    test_sid = 1234
+    test_data: UpdateDict = {
+        "parent_path": "sub_class",
+        "name": "name",
+        "value": "new name",
+    }
+
+    server.handlers["/"]["set_attribute"](test_sid, test_data)
+
+    assert service_instance.sub_class.name == "new name"
+
+
+@pytest.mark.asyncio
+async def test_run_method_event(caplog: pytest.LogCaptureFixture):
+    class ServiceClass(pydase.DataService):
+        def test_method(self) -> None:
+            logger.info("Triggered 'test_method'.")
+
+    state_manager = StateManager(ServiceClass())
+    observer = DataServiceObserver(state_manager)
+
+    server = setup_sio_server(observer, False, asyncio.get_running_loop())
+
+    test_sid = 1234
+    test_data: RunMethodDict = {
+        "parent_path": "",
+        "name": "test_method",
+        "kwargs": {},
+    }
+
+    server.handlers["/"]["run_method"](test_sid, test_data)
+
+    assert "Triggered 'test_method'." in caplog.text

tests/server/web_server/test_web_server.py

@@ -0,0 +1,54 @@
+import json
+import logging
+import tempfile
+from pathlib import Path
+
+import pydase
+from pydase.data_service.data_service_observer import DataServiceObserver
+from pydase.data_service.state_manager import StateManager
+from pydase.server.web_server.web_server import WebServer
+
+logger = logging.getLogger(__name__)
+
+
+def test_web_settings() -> None:
+    class SubClass(pydase.DataService):
+        name = "Hello"
+
+    class ServiceClass(pydase.DataService):
+        def __init__(self) -> None:
+            super().__init__()
+            self.attr_1 = SubClass()
+            self.added = "added"
+
+    service_instance = ServiceClass()
+    state_manager = StateManager(service_instance)
+    observer = DataServiceObserver(state_manager)
+    with tempfile.TemporaryDirectory() as tmp:
+        web_settings = {
+            "attr_1": {"displayName": "Attribute", "display": False},
+            "attr_1.name": {"displayName": "Attribute name", "display": True},
+        }
+        web_settings_file = Path(tmp) / "web_settings.json"
+
+        with web_settings_file.open("w") as file:
+            file.write(json.dumps(web_settings))
+
+        server = WebServer(
+            observer,
+            host="0.0.0.0",
+            port=8001,
+            generate_web_settings=True,
+            config_dir=Path(tmp),
+        )
+        new_web_settings = server.web_settings
+
+        # existing entries are not overwritten, new entries are appended
+        assert new_web_settings == {
+            **web_settings,
+            "added": {"displayName": "added", "display": True},
+        }
+        assert json.loads(web_settings_file.read_text()) == {
+            **web_settings,
+            "added": {"displayName": "added", "display": True},
+        }

tests/test_units.py

@@ -1,9 +1,10 @@
 from typing import Any
 
+import pydase
 import pydase.units as u
 from pydase.data_service.data_service import DataService
 from pydase.data_service.data_service_observer import DataServiceObserver
-from pydase.data_service.state_manager import StateManager
+from pydase.data_service.state_manager import StateManager, load_state
 from pytest import LogCaptureFixture
 
 
@@ -99,7 +100,10 @@ def test_autoconvert_offset_to_baseunit() -> None:
 def test_loading_from_json(caplog: LogCaptureFixture) -> None:
     """This function tests if the quantity read from the json description is actually
     passed as a quantity to the property setter."""
-    JSON_DICT = {
+    import json
+    import tempfile
+
+    serialization_dict = {
         "some_unit": {
             "type": "Quantity",
             "value": {"magnitude": 10.0, "unit": "A"},
@@ -118,14 +122,17 @@ def test_loading_from_json(caplog: LogCaptureFixture) -> None:
             return self._unit
 
         @some_unit.setter
+        @load_state
         def some_unit(self, value: u.Quantity) -> None:
             assert isinstance(value, u.Quantity)
             self._unit = value
 
     service_instance = ServiceClass()
-    state_manager = StateManager(service_instance)
-    DataServiceObserver(state_manager)
 
-    service_instance.load_DataService_from_JSON(JSON_DICT)
+    fp = tempfile.NamedTemporaryFile("w+")
+    json.dump(serialization_dict, fp)
+    fp.seek(0)
+
+    pydase.Server(service_instance, filename=fp.name)
 
     assert "'some_unit' changed to '10.0 A'" in caplog.text

tests/utils/test_helpers.py

@@ -1,6 +1,8 @@
-import pytest
 
-from pydase.utils.helpers import is_property_attribute
+import pytest
+from pydase.utils.helpers import (
+    is_property_attribute,
+)
 
 
 @pytest.mark.parametrize(

tests/utils/test_logging.py

@@ -1,8 +1,7 @@
 import logging
 
-from pytest import LogCaptureFixture
-
 from pydase.utils.logging import setup_logging
+from pytest import LogCaptureFixture
 
 
 def test_log_error(caplog: LogCaptureFixture):

tests/utils/test_serializer.py

@@ -1,4 +1,5 @@
 import asyncio
+import enum
 from enum import Enum
 from typing import Any
 
@@ -6,15 +7,26 @@ import pydase
 import pydase.units as u
 import pytest
 from pydase.components.coloured_enum import ColouredEnum
+from pydase.data_service.task_manager import TaskStatus
+from pydase.utils.decorators import frontend
 from pydase.utils.serializer import (
     SerializationPathError,
+    SerializedObject,
     dump,
     get_nested_dict_by_path,
     get_next_level_dict_by_key,
+    serialized_dict_is_nested_object,
     set_nested_value_by_path,
 )
 
 
+class MyEnum(enum.Enum):
+    """MyEnum description"""
+
+    RUNNING = "running"
+    FINISHED = "finished"
+
+
 @pytest.mark.parametrize(
     "test_input, expected",
     [
@@ -99,6 +111,8 @@ def test_enum_serialize() -> None:
 
 def test_ColouredEnum_serialize() -> None:
     class Status(ColouredEnum):
+        """Status description."""
+
         PENDING = "#FFA500"
         RUNNING = "#0000FF80"
         PAUSED = "rgb(169, 169, 169)"
@@ -120,38 +134,44 @@ def test_ColouredEnum_serialize() -> None:
             "RUNNING": "#0000FF80",
         },
         "readonly": False,
-        "doc": None,
+        "doc": "Status description.",
     }
 
 
-def test_method_serialization() -> None:
+@pytest.mark.asyncio
+async def test_method_serialization() -> None:
     class ClassWithMethod(pydase.DataService):
         def some_method(self) -> str:
             return "some method"
 
-        async def some_task(self, sleep_time: int) -> None:
+        async def some_task(self) -> None:
             while True:
-                await asyncio.sleep(sleep_time)
+                await asyncio.sleep(10)
 
     instance = ClassWithMethod()
-    instance.start_some_task(10)  # type: ignore
+    instance.start_some_task()  # type: ignore
 
     assert dump(instance)["value"] == {
         "some_method": {
-            "async": False,
-            "doc": None,
-            "parameters": {},
-            "readonly": True,
             "type": "method",
             "value": None,
+            "readonly": True,
+            "doc": None,
+            "async": False,
+            "signature": {"parameters": {}, "return_annotation": {}},
+            "frontend_render": False,
         },
         "some_task": {
-            "async": True,
-            "doc": None,
-            "parameters": {"sleep_time": "int"},
-            "readonly": True,
             "type": "method",
-            "value": {"sleep_time": 10},
+            "value": TaskStatus.RUNNING.name,
+            "readonly": True,
+            "doc": None,
+            "async": True,
+            "signature": {
+                "parameters": {},
+                "return_annotation": {},
+            },
+            "frontend_render": True,
         },
     }
 
@@ -169,28 +189,79 @@ def test_methods_with_type_hints() -> None:
     assert dump(method_without_type_hint) == {
         "async": False,
         "doc": None,
-        "parameters": {"arg_without_type_hint": None},
+        "signature": {
+            "parameters": {
+                "arg_without_type_hint": {
+                    "annotation": "<class 'inspect._empty'>",
+                    "default": {},
+                }
+            },
+            "return_annotation": {},
+        },
         "readonly": True,
         "type": "method",
         "value": None,
+        "frontend_render": False,
     }
 
     assert dump(method_with_type_hint) == {
-        "async": False,
-        "doc": None,
-        "parameters": {"some_argument": "int"},
-        "readonly": True,
         "type": "method",
         "value": None,
+        "readonly": True,
+        "doc": None,
+        "async": False,
+        "signature": {
+            "parameters": {
+                "some_argument": {"annotation": "<class 'int'>", "default": {}}
+            },
+            "return_annotation": {},
+        },
+        "frontend_render": False,
+    }
+    assert dump(method_with_union_type_hint) == {
+        "type": "method",
+        "value": None,
+        "readonly": True,
+        "doc": None,
+        "async": False,
+        "signature": {
+            "parameters": {
+                "some_argument": {"annotation": "int | float", "default": {}}
+            },
+            "return_annotation": {},
+        },
+        "frontend_render": False,
     }
 
-    assert dump(method_with_union_type_hint) == {
-        "async": False,
-        "doc": None,
-        "parameters": {"some_argument": "int | float"},
-        "readonly": True,
+
+def test_exposed_function_serialization() -> None:
+    class MyService(pydase.DataService):
+        @frontend
+        def some_method(self) -> None:
+            pass
+
+    @frontend
+    def some_function() -> None:
+        pass
+
+    assert dump(MyService().some_method) == {
         "type": "method",
         "value": None,
+        "readonly": True,
+        "doc": None,
+        "async": False,
+        "signature": {"parameters": {}, "return_annotation": {}},
+        "frontend_render": True,
+    }
+
+    assert dump(some_function) == {
+        "type": "method",
+        "value": None,
+        "readonly": True,
+        "doc": None,
+        "async": False,
+        "signature": {"parameters": {}, "return_annotation": {}},
+        "frontend_render": True,
     }
 
 
@@ -220,6 +291,7 @@ def test_list_serialization() -> None:
                     "doc": None,
                     "readonly": False,
                     "type": "DataService",
+                    "name": "MySubclass",
                     "value": {
                         "bool_attr": {
                             "doc": None,
@@ -264,6 +336,7 @@ def test_dict_serialization() -> None:
         "type": "dict",
         "value": {
             "DataService_key": {
+                "name": "MyClass",
                 "doc": None,
                 "readonly": False,
                 "type": "DataService",
@@ -313,13 +386,18 @@ def test_derived_data_service_serialization() -> None:
     class DerivedService(BaseService):
         ...
 
-    base_instance = BaseService()
-    service_instance = DerivedService()
-    assert service_instance.serialize() == base_instance.serialize()
+    base_service_serialization = dump(BaseService())
+    derived_service_serialization = dump(DerivedService())
+
+    # Names of the classes obviously differ
+    base_service_serialization.pop("name")
+    derived_service_serialization.pop("name")
+
+    assert base_service_serialization == derived_service_serialization
 
 
 @pytest.fixture
-def setup_dict():
+def setup_dict() -> dict[str, Any]:
     class MySubclass(pydase.DataService):
         attr3 = 1.0
         list_attr = [1.0, 1]
@@ -327,32 +405,87 @@ def setup_dict():
     class ServiceClass(pydase.DataService):
         attr1 = 1.0
         attr2 = MySubclass()
+        enum_attr = MyEnum.RUNNING
         attr_list = [0, 1, MySubclass()]
 
-    return ServiceClass().serialize()
+        def my_task(self) -> None:
+            pass
+
+    return ServiceClass().serialize()["value"]
 
 
-def test_update_attribute(setup_dict):
+def test_update_attribute(setup_dict: dict[str, Any]) -> None:
     set_nested_value_by_path(setup_dict, "attr1", 15)
     assert setup_dict["attr1"]["value"] == 15
 
 
-def test_update_nested_attribute(setup_dict):
+def test_update_nested_attribute(setup_dict: dict[str, Any]) -> None:
     set_nested_value_by_path(setup_dict, "attr2.attr3", 25.0)
     assert setup_dict["attr2"]["value"]["attr3"]["value"] == 25.0
 
 
-def test_update_list_entry(setup_dict):
+def test_update_float_attribute_to_enum(setup_dict: dict[str, Any]) -> None:
+    set_nested_value_by_path(setup_dict, "attr2.attr3", MyEnum.RUNNING)
+    assert setup_dict["attr2"]["value"]["attr3"] == {
+        "doc": "MyEnum description",
+        "enum": {"FINISHED": "finished", "RUNNING": "running"},
+        "readonly": False,
+        "type": "Enum",
+        "value": "RUNNING",
+    }
+
+
+def test_update_enum_attribute_to_float(setup_dict: dict[str, Any]) -> None:
+    set_nested_value_by_path(setup_dict, "enum_attr", 1.01)
+    assert setup_dict["enum_attr"] == {
+        "doc": None,
+        "readonly": False,
+        "type": "float",
+        "value": 1.01,
+    }
+
+
+def test_update_task_state(setup_dict: dict[str, Any]) -> None:
+    assert setup_dict["my_task"] == {
+        "async": False,
+        "doc": None,
+        "frontend_render": False,
+        "readonly": True,
+        "signature": {"parameters": {}, "return_annotation": {}},
+        "type": "method",
+        "value": None,
+    }
+    set_nested_value_by_path(setup_dict, "my_task", TaskStatus.RUNNING)
+    assert setup_dict["my_task"] == {
+        "async": False,
+        "doc": None,
+        "frontend_render": False,
+        "readonly": True,
+        "signature": {"parameters": {}, "return_annotation": {}},
+        "type": "method",
+        "value": "RUNNING",
+    }
+
+
+def test_update_list_entry(setup_dict: dict[str, SerializedObject]) -> None:
     set_nested_value_by_path(setup_dict, "attr_list[1]", 20)
     assert setup_dict["attr_list"]["value"][1]["value"] == 20
 
 
-def test_update_list_append(setup_dict):
-    set_nested_value_by_path(setup_dict, "attr_list[3]", 20)
-    assert setup_dict["attr_list"]["value"][3]["value"] == 20
+def test_update_list_append(setup_dict: dict[str, SerializedObject]) -> None:
+    set_nested_value_by_path(setup_dict, "attr_list[3]", MyEnum.RUNNING)
+    assert setup_dict["attr_list"]["value"][3] == {
+        "doc": "MyEnum description",
+        "enum": {"FINISHED": "finished", "RUNNING": "running"},
+        "readonly": False,
+        "type": "Enum",
+        "value": "RUNNING",
+    }
 
 
-def test_update_invalid_list_index(setup_dict, caplog: pytest.LogCaptureFixture):
+def test_update_invalid_list_index(
+    setup_dict: dict[str, Any], caplog: pytest.LogCaptureFixture
+) -> None:
     set_nested_value_by_path(setup_dict, "attr_list[10]", 30)
     assert (
         "Error occured trying to change 'attr_list[10]': list index "
@@ -360,7 +493,9 @@ def test_update_invalid_list_index(setup_dict, caplog: pytest.LogCaptureFixture)
     )
 
 
-def test_update_invalid_path(setup_dict, caplog: pytest.LogCaptureFixture):
+def test_update_invalid_path(
+    setup_dict: dict[str, Any], caplog: pytest.LogCaptureFixture
+) -> None:
     set_nested_value_by_path(setup_dict, "invalid_path", 30)
     assert (
         "Error occured trying to access the key 'invalid_path': it is either "
@@ -369,66 +504,165 @@ def test_update_invalid_path(setup_dict, caplog: pytest.LogCaptureFixture):
     )
 
 
-def test_update_list_inside_class(setup_dict):
+def test_update_list_inside_class(setup_dict: dict[str, Any]) -> None:
     set_nested_value_by_path(setup_dict, "attr2.list_attr[1]", 40)
     assert setup_dict["attr2"]["value"]["list_attr"]["value"][1]["value"] == 40
 
 
-def test_update_class_attribute_inside_list(setup_dict):
+def test_update_class_attribute_inside_list(setup_dict: dict[str, Any]) -> None:
     set_nested_value_by_path(setup_dict, "attr_list[2].attr3", 50)
     assert setup_dict["attr_list"]["value"][2]["value"]["attr3"]["value"] == 50
 
 
-def test_get_next_level_attribute_nested_dict(setup_dict):
+def test_get_next_level_attribute_nested_dict(setup_dict: dict[str, Any]) -> None:
     nested_dict = get_next_level_dict_by_key(setup_dict, "attr1")
     assert nested_dict == setup_dict["attr1"]
 
 
-def test_get_next_level_list_entry_nested_dict(setup_dict):
+def test_get_next_level_list_entry_nested_dict(setup_dict: dict[str, Any]) -> None:
     nested_dict = get_next_level_dict_by_key(setup_dict, "attr_list[0]")
     assert nested_dict == setup_dict["attr_list"]["value"][0]
 
 
-def test_get_next_level_invalid_path_nested_dict(setup_dict):
+def test_get_next_level_invalid_path_nested_dict(setup_dict: dict[str, Any]) -> None:
     with pytest.raises(SerializationPathError):
         get_next_level_dict_by_key(setup_dict, "invalid_path")
 
 
-def test_get_next_level_invalid_list_index(setup_dict):
+def test_get_next_level_invalid_list_index(setup_dict: dict[str, Any]) -> None:
     with pytest.raises(SerializationPathError):
         get_next_level_dict_by_key(setup_dict, "attr_list[10]")
 
 
-def test_get_attribute(setup_dict):
+def test_get_attribute(setup_dict: dict[str, Any]) -> None:
     nested_dict = get_nested_dict_by_path(setup_dict, "attr1")
     assert nested_dict["value"] == 1.0
 
 
-def test_get_nested_attribute(setup_dict):
+def test_get_nested_attribute(setup_dict: dict[str, Any]) -> None:
     nested_dict = get_nested_dict_by_path(setup_dict, "attr2.attr3")
     assert nested_dict["value"] == 1.0
 
 
-def test_get_list_entry(setup_dict):
+def test_get_list_entry(setup_dict: dict[str, Any]) -> None:
     nested_dict = get_nested_dict_by_path(setup_dict, "attr_list[1]")
     assert nested_dict["value"] == 1
 
 
-def test_get_list_inside_class(setup_dict):
+def test_get_list_inside_class(setup_dict: dict[str, Any]) -> None:
     nested_dict = get_nested_dict_by_path(setup_dict, "attr2.list_attr[1]")
     assert nested_dict["value"] == 1.0
 
 
-def test_get_class_attribute_inside_list(setup_dict):
+def test_get_class_attribute_inside_list(setup_dict: dict[str, Any]) -> None:
     nested_dict = get_nested_dict_by_path(setup_dict, "attr_list[2].attr3")
     assert nested_dict["value"] == 1.0
 
 
-def test_get_invalid_list_index(setup_dict, caplog: pytest.LogCaptureFixture):
+def test_get_invalid_list_index(setup_dict: dict[str, Any]) -> None:
     with pytest.raises(SerializationPathError):
         get_nested_dict_by_path(setup_dict, "attr_list[10]")
 
 
-def test_get_invalid_path(setup_dict, caplog: pytest.LogCaptureFixture):
+def test_get_invalid_path(setup_dict: dict[str, Any]) -> None:
     with pytest.raises(SerializationPathError):
         get_nested_dict_by_path(setup_dict, "invalid_path")
+
+
+def test_serialized_dict_is_nested_object() -> None:
+    serialized_dict = {
+        "list_attr": {
+            "type": "list",
+            "value": [
+                {"type": "float", "value": 1.4, "readonly": False, "doc": None},
+                {"type": "float", "value": 2.0, "readonly": False, "doc": None},
+            ],
+            "readonly": False,
+            "doc": None,
+        },
+        "my_slider": {
+            "type": "NumberSlider",
+            "value": {
+                "max": {
+                    "type": "float",
+                    "value": 101.0,
+                    "readonly": False,
+                    "doc": "The min property.",
+                },
+                "min": {
+                    "type": "float",
+                    "value": 1.0,
+                    "readonly": False,
+                    "doc": "The min property.",
+                },
+                "step_size": {
+                    "type": "float",
+                    "value": 2.0,
+                    "readonly": False,
+                    "doc": "The min property.",
+                },
+                "value": {
+                    "type": "float",
+                    "value": 1.0,
+                    "readonly": False,
+                    "doc": "The value property.",
+                },
+            },
+            "readonly": False,
+            "doc": None,
+        },
+        "string": {
+            "type": "str",
+            "value": "Another name",
+            "readonly": True,
+            "doc": None,
+        },
+        "float": {
+            "type": "int",
+            "value": 10,
+            "readonly": False,
+            "doc": None,
+        },
+        "unit": {
+            "type": "Quantity",
+            "value": {"magnitude": 12.0, "unit": "A"},
+            "readonly": False,
+            "doc": None,
+        },
+        "state": {
+            "type": "ColouredEnum",
+            "value": "FAILED",
+            "readonly": True,
+            "doc": None,
+            "enum": {
+                "RUNNING": "#0000FF80",
+                "COMPLETED": "hsl(120, 100%, 50%)",
+                "FAILED": "hsla(0, 100%, 50%, 0.7)",
+            },
+        },
+        "subservice": {
+            "type": "DataService",
+            "value": {
+                "name": {
+                    "type": "str",
+                    "value": "SubService",
+                    "readonly": False,
+                    "doc": None,
+                }
+            },
+            "readonly": False,
+            "doc": None,
+        },
+    }
+
+    assert serialized_dict_is_nested_object(serialized_dict["list_attr"])
+    assert serialized_dict_is_nested_object(serialized_dict["my_slider"])
+    assert serialized_dict_is_nested_object(serialized_dict["subservice"])
+
+    assert not serialized_dict_is_nested_object(
+        serialized_dict["list_attr"]["value"][0]  # type: ignore[index]
+    )
+    assert not serialized_dict_is_nested_object(serialized_dict["string"])
+    assert not serialized_dict_is_nested_object(serialized_dict["unit"])
+    assert not serialized_dict_is_nested_object(serialized_dict["float"])
+    assert not serialized_dict_is_nested_object(serialized_dict["state"])