Merge pull request #152 from tiqi-group/feat/client_context_manager

feat: adds a context manager to the client, fixes running loop issue

.github/workflows/python-package.yml

@@ -16,15 +16,15 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.10", "3.11"]
+        python-version: ["3.10", "3.11", "3.12"]
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - uses: chartboost/ruff-action@v1
       with:
         src: "./src"
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies

.vscode/launch.json

@@ -25,7 +25,7 @@
             "type": "firefox",
             "request": "launch",
             "name": "react: firefox",
-            "url": "http://localhost:3000",
+            "url": "http://localhost:5173",
             "webRoot": "${workspaceFolder}/frontend"
         }
     ]

README.md

@@ -1,9 +1,9 @@
-# pydase (Python Data Service) <!-- omit from toc -->
+# pydase <!-- omit from toc -->
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Documentation Status](https://readthedocs.org/projects/pydase/badge/?version=latest)](https://pydase.readthedocs.io/en/latest/?badge=latest)
 
-`pydase` is a Python library for creating data service servers with integrated web and RPC servers. It's designed to handle the management of data structures, automated tasks, and callbacks, and provides built-in functionality for serving data over different protocols.
+`pydase` is a Python library designed to streamline the creation of services that interface with devices and data. It offers a unified API, simplifying the process of data querying and device interaction. Whether you're managing lab sensors, network devices, or any abstract data entity, `pydase` facilitates rapid service development and deployment.
 
 - [Features](#features)
 - [Installation](#installation)
@@ -11,7 +11,10 @@
   - [Defining a DataService](#defining-a-dataservice)
   - [Running the Server](#running-the-server)
   - [Accessing the Web Interface](#accessing-the-web-interface)
-  - [Connecting to the Service using rpyc](#connecting-to-the-service-using-rpyc)
+  - [Connecting to the Service via Python Client](#connecting-to-the-service-via-python-client)
+    - [Tab Completion Support](#tab-completion-support)
+    - [Integration within Another Service](#integration-within-another-service)
+  - [RESTful API](#restful-api)
 - [Understanding the Component System](#understanding-the-component-system)
   - [Built-in Type and Enum Components](#built-in-type-and-enum-components)
   - [Method Components](#method-components)
@@ -28,11 +31,9 @@
   - [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)
+- [Using `validate_set` to Validate Property Setters](#using-validate_set-to-validate-property-setters)
 - [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)
@@ -42,14 +43,15 @@
 ## Features
 
 <!-- no toc -->
-- [Simple data service definition through class-based interface](#defining-a-dataService)
-- [Integrated web interface for interactive access and control of your data service](#accessing-the-web-interface)
-- [Support for `rpyc` connections, allowing for programmatic control and interaction with your service](#connecting-to-the-service-using-rpyc)
+- [Simple service definition through class-based interface](#defining-a-dataService)
+- [Integrated web interface for interactive access and control of your service](#accessing-the-web-interface)
+- [Support for programmatic control and interaction with your service](#connecting-to-the-service-via-python-client)
 - [Component system bridging Python backend with frontend visual representation](#understanding-the-component-system)
-- [Customizable styling for the web interface through user-defined CSS](#customizing-web-interface-style)
+- [Customizable styling for the web interface](#customizing-web-interface-style)
 - [Saving and restoring the service state for service persistence](#understanding-service-persistence)
 - [Automated task management with built-in start/stop controls and optional autostart](#understanding-tasks-in-pydase)
 - [Support for units](#understanding-units-in-pydase)
+- [Validating Property Setters](#using-validate_set-to-validate-property-setters)
 <!-- Support for additional servers for specific use-cases -->
 
 ## Installation
@@ -74,11 +76,11 @@ pip install pydase
 
 <!--usage-start-->
 
-Using `pydase` involves three main steps: defining a `DataService` subclass, running the server, and then connecting to the service either programmatically using `rpyc` or through the web interface.
+Using `pydase` involves three main steps: defining a `DataService` subclass, running the server, and then connecting to the service either programmatically using `pydase.Client` or through the web interface.
 
 ### Defining a DataService
 
-To use pydase, you'll first need to create a class that inherits from `DataService`. This class represents your custom data service, which will be exposed via RPC (using rpyc) and a web server. Your class can implement class / instance attributes and synchronous and asynchronous tasks.
+To use pydase, you'll first need to create a class that inherits from `DataService`. This class represents your custom data service, which will be exposed via a web server. Your class can implement class / instance attributes and synchronous and asynchronous tasks.
 
 Here's an example:
 
@@ -149,7 +151,7 @@ if __name__ == "__main__":
     Server(service).run()
 ```
 
-This will start the server, making your Device service accessible via RPC and a web server at [http://localhost:8001](http://localhost:8001).
+This will start the server, making your Device service accessible on [http://localhost:8001](http://localhost:8001).
 
 ### Accessing the Web Interface
 
@@ -159,23 +161,47 @@ Once the server is running, you can access the web interface in a browser:
 
 In this interface, you can interact with the properties of your `Device` service.
 
-### Connecting to the Service using rpyc
+### Connecting to the Service via Python RPC Client
 
-You can also connect to the service using `rpyc`. Here's an example on how to establish a connection and interact with the service:
+You can connect to the service using the `pydase.Client`. Below is an example of how to establish a connection to a service and interact with it:
 
 ```python
-import rpyc
+import pydase
 
-# Connect to the service
-conn = rpyc.connect("<ip_addr>", 18871)
-client = conn.root
+# Replace the hostname and port with the IP address and the port of the machine where 
+# the service is running, respectively
+client_proxy = pydase.Client(url="ws://<ip_addr>:<service_port>").proxy
+# client_proxy = pydase.Client(url="wss://your-domain.ch").proxy  # if your service uses ssl-encryption
 
-# Interact with the service
-client.voltage = 5.0
-print(client.voltage)  # prints 5.0
+# After the connection, interact with the service attributes as if they were local
+client_proxy.voltage = 5.0
+print(client_proxy.voltage)  # Expected output: 5.0
 ```
 
-In this example, replace `<ip_addr>` with the IP address of the machine where the service is running. After establishing a connection, you can interact with the service attributes as if they were local attributes.
+This example demonstrates setting and retrieving the `voltage` attribute through the client proxy.
+The proxy acts as a local representative of the remote service, enabling straightforward interaction.
+
+The proxy class dynamically synchronizes with the server's exposed attributes. This synchronization allows the proxy to be automatically updated with any attributes or methods that the server exposes, essentially mirroring the server's API. This dynamic updating enables users to interact with the remote service as if they were working with a local object.
+
+The RPC client also supports tab completion support in the interpreter, can be used as a context manager and integrates very well with other pydase services. For more information, please refer to the [documentation](https://pydase.readthedocs.io/en/latest/user-guide/interaction/main/#python-client).
+
+### RESTful API
+The `pydase` RESTful API allows for standard HTTP-based interactions and provides access to various functionalities through specific routes. 
+
+For example, you can get a value like this:
+
+```python
+import json
+
+import requests
+
+response = requests.get(
+    "http://<hostname>:<port>/api/v1/get_value?access_path=<full_access_path>"
+)
+serialized_value = json.loads(response.text)
+```
+
+For more information, see [here](https://pydase.readthedocs.io/en/stable/user-guide/interaction/main/#restful-api).
 
 <!--usage-end-->
 
@@ -193,6 +219,7 @@ In `pydase`, components are fundamental building blocks that bridge the Python b
 - `int` and `float`: Manifested as the `NumberComponent`.
 - `bool`: Rendered as a `ButtonComponent`.
 - `list`: Each item displayed individually, named after the list attribute and its index.
+- `dict`: Each key-value pair displayed individually, named after the dictionary attribute and its key. **Note** that the dictionary keys must be strings.
 - `enum.Enum`: Presented as an `EnumComponent`, facilitating dropdown selection.
 
 ### Method Components
@@ -477,96 +504,96 @@ In this example, `MySlider` overrides the `min`, `max`, `step_size`, and `value`
 
 - Accessing parent class resources in `NumberSlider`
 
-  In scenarios where you need the slider component to interact with or access resources from its parent class, you can achieve this by passing a callback function to it. This method avoids directly passing the entire parent class instance (`self`) and offers a more encapsulated approach. The callback function can be designed to utilize specific attributes or methods of the parent class, allowing the slider to perform actions or retrieve data in response to slider events.
+    In scenarios where you need the slider component to interact with or access resources from its parent class, you can achieve this by passing a callback function to it. This method avoids directly passing the entire parent class instance (`self`) and offers a more encapsulated approach. The callback function can be designed to utilize specific attributes or methods of the parent class, allowing the slider to perform actions or retrieve data in response to slider events.
 
-  Here's an illustrative example:
+    Here's an illustrative example:
 
-  ```python
-  from collections.abc import Callable
+    ```python
+    from collections.abc import Callable
 
-  import pydase
-  import pydase.components
+    import pydase
+    import pydase.components
 
 
-  class MySlider(pydase.components.NumberSlider):
-      def __init__(
-          self,
-          value: float,
-          on_change: Callable[[float], None],
-      ) -> None:
-          super().__init__(value=value)
-          self._on_change = on_change
+    class MySlider(pydase.components.NumberSlider):
+        def __init__(
+            self,
+            value: float,
+            on_change: Callable[[float], None],
+        ) -> None:
+            super().__init__(value=value)
+            self._on_change = on_change
 
-      # ... other properties ...
+        # ... other properties ...
 
-      @property
-      def value(self) -> float:
-          return self._value
+        @property
+        def value(self) -> float:
+            return self._value
 
-      @value.setter
-      def value(self, new_value: float) -> None:
-          if new_value < self._min or new_value > self._max:
-              raise ValueError("Value is either below allowed min or above max value.")
-          self._value = new_value
-          self._on_change(new_value)
+        @value.setter
+        def value(self, new_value: float) -> None:
+            if new_value < self._min or new_value > self._max:
+                raise ValueError("Value is either below allowed min or above max value.")
+            self._value = new_value
+            self._on_change(new_value)
 
 
-  class MyService(pydase.DataService):
-      def __init__(self) -> None:
-          self.voltage = MySlider(
-              5,
-              on_change=self.handle_voltage_change,
-          )
+    class MyService(pydase.DataService):
+        def __init__(self) -> None:
+            self.voltage = MySlider(
+                5,
+                on_change=self.handle_voltage_change,
+            )
 
-      def handle_voltage_change(self, new_voltage: float) -> None:
-          print(f"Voltage changed to: {new_voltage}")
-          # Additional logic here
+        def handle_voltage_change(self, new_voltage: float) -> None:
+            print(f"Voltage changed to: {new_voltage}")
+            # Additional logic here
 
-  if __name__ == "__main__":
-     service_instance = MyService()
-     my_service.voltage.value = 7  # Output: "Voltage changed to: 7"
-     pydase.Server(service_instance).run()
-  ```
+    if __name__ == "__main__":
+       service_instance = MyService()
+       my_service.voltage.value = 7  # Output: "Voltage changed to: 7"
+       pydase.Server(service_instance).run()
+    ```
 
 - Incorporating units in `NumberSlider`
 
-  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.
+    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:
+    Here's how to implement a `NumberSlider` with unit display:
 
-  ```python
-  import pydase
-  import pydase.components
-  import pydase.units as u
+    ```python
+    import pydase
+    import pydase.components
+    import pydase.units as u
 
-  class MySlider(pydase.components.NumberSlider):
-      def __init__(
-          self,
-          value: u.Quantity = 0.0 * u.units.V,
-      ) -> None:
-          super().__init__(value)
+    class MySlider(pydase.components.NumberSlider):
+        def __init__(
+            self,
+            value: u.Quantity = 0.0 * u.units.V,
+        ) -> None:
+            super().__init__(value)
 
-      @property
-      def value(self) -> u.Quantity:
-          return self._value
+        @property
+        def value(self) -> u.Quantity:
+            return self._value
 
-      @value.setter
-      def value(self, value: u.Quantity) -> None:
-          if value.m < self._min or value.m > self._max:
-              raise ValueError("Value is either below allowed min or above max value.")
-          self._value = value
+        @value.setter
+        def value(self, value: u.Quantity) -> None:
+            if value.m < self._min or value.m > self._max:
+                raise ValueError("Value is either below allowed min or above max value.")
+            self._value = value
 
-  class MyService(pydase.DataService):
-      def __init__(self) -> None:
-          super().__init__()
-          self.voltage = MySlider()
+    class MyService(pydase.DataService):
+        def __init__(self) -> None:
+            super().__init__()
+            self.voltage = MySlider()
 
-  if __name__ == "__main__":
-      service_instance = MyService()
-      service_instance.voltage.value = 5 * u.units.V
-      print(service_instance.voltage.value)  # Output: 5 V
-      pydase.Server(service_instance).run()
-  ```
+    if __name__ == "__main__":
+        service_instance = MyService()
+        service_instance.voltage.value = 5 * u.units.V
+        print(service_instance.voltage.value)  # Output: 5 V
+        pydase.Server(service_instance).run()
+    ```
 
 #### `ColouredEnum`
 
@@ -608,6 +635,9 @@ my_service.status = MyStatus.FAILED
 
 ![ColouredEnum Component](docs/images/ColouredEnum_component.png)
 
+**Note** that each enumeration name and value must be unique.
+This means that you should use different colour formats when you want to use a colour multiple times.
+
 #### Extending with New Components
 
 Users can also extend the library by creating custom components. This involves defining the behavior on the Python backend and the visual representation on the frontend. For those looking to introduce new components, the [guide on adding components](https://pydase.readthedocs.io/en/latest/dev-guide/Adding_Components/) provides detailed steps on achieving this.
@@ -766,6 +796,45 @@ 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/).
 
+## Using `validate_set` to Validate Property Setters
+
+The `validate_set` decorator ensures that a property setter reads back the set value using the property getter and checks it against the desired value.
+This decorator can be used to validate that a parameter has been correctly set on a device within a specified precision and timeout.
+
+The decorator takes two keyword arguments: `timeout` and `precision`. The `timeout` argument specifies the maximum time (in seconds) to wait for the value to be within the precision boundary.
+If the value is not within the precision boundary after this time, an exception is raised.
+The `precision` argument defines the acceptable deviation from the desired value.
+If `precision` is `None`, the value must be exact.
+For example, if `precision` is set to `1e-5`, the value read from the device must be within ±0.00001 of the desired value.
+
+Here’s how to use the `validate_set` decorator in a `DataService` class:
+
+```python
+import pydase
+from pydase.observer_pattern.observable.decorators import validate_set
+
+
+class Service(pydase.DataService):
+    def __init__(self) -> None:
+        super().__init__()
+        self._device = RemoteDevice()  # dummy class
+
+    @property
+    def value(self) -> float:
+        # Implement how to get the value from the remote device...
+        return self._device.value
+
+    @value.setter
+    @validate_set(timeout=1.0, precision=1e-5)
+    def value(self, value: float) -> None:
+        # Implement how to set the value on the remote device...
+        self._device.value = value
+
+
+if __name__ == "__main__":
+    pydase.Server(Service()).run()
+```
+
 ## 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.
@@ -781,7 +850,6 @@ Configuring `pydase` through environment variables enhances flexibility, securit
     ```
 
 - **`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: 
@@ -796,7 +864,6 @@ 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()
@@ -804,62 +871,14 @@ server = Server(
 
 ## 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 through
 
-`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.
+1. a custom CSS file, and
+2. tailoring the frontend component layout and display style.
 
-Here's how you can use this feature:
+You can also provide a custom frontend source if you need even more flexibility.
 
-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()
-```
+For details, please see [here](https://pydase.readthedocs.io/en/stable/user-guide/interaction/main/#customization-options).
 
 ## Logging in pydase
 

docs/dev-guide/Adding_Components.md

@@ -111,7 +111,7 @@ 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
+```ts
 import React, { useEffect, useRef, useState } from 'react';
 import { Card, Collapse, Image } from 'react-bootstrap';
 import { DocStringComponent } from './DocStringComponent';
@@ -203,8 +203,7 @@ There are two different events a component might want to trigger: updating an at
     
     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
+    ```ts title="frontend/src/components/ButtonComponent.tsx"
     // ... (import statements)
     
     type ButtonComponentProps = {
@@ -249,7 +248,7 @@ There are two different events a component might want to trigger: updating an at
 
     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
+    ```ts title="frontend/src/components/_YourComponent_.tsx"
     import { runMethod } from '../socket';
     // ... (other imports)
 
@@ -287,9 +286,7 @@ The `GenericComponent` is responsible for rendering different types of component
 
 At the beginning of the `GenericComponent` file, import the newly created `ImageComponent`:
 
-```tsx
-// file: frontend/src/components/GenericComponent.tsx
-
+```ts title="frontend/src/components/GenericComponent.tsx"
 import { ImageComponent } from './ImageComponent';
 ```
 
@@ -299,7 +296,7 @@ Update the `AttributeType` type definition to include the new type for the `Imag
 
 For example, if the new attribute type is `'Image'` (which should correspond to the name of the backend component class), you can add it to the union:
 
-```tsx
+```ts
 type AttributeType =
   | 'str'
   | 'bool'
@@ -318,7 +315,7 @@ type AttributeType =
 
 Inside the `GenericComponent` function, add a new conditional branch to render the `ImageComponent` when the attribute type is `'Image'`:
 
-```tsx
+```ts
 } else if (attribute.type === 'Image') {
   return (
     <ImageComponent
@@ -348,7 +345,7 @@ 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
+```ts
 const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
 
 useEffect(() => {

docs/requirements.txt

@@ -1,20 +1,35 @@
+babel==2.15.0 ; python_version >= "3.10" and python_version < "4.0"
+beautifulsoup4==4.12.3 ; python_version >= "3.10" and python_version < "4.0"
+certifi==2024.7.4 ; python_version >= "3.10" and python_version < "4.0"
+charset-normalizer==3.3.2 ; python_version >= "3.10" and python_version < "4.0"
 click==8.1.7 ; python_version >= "3.10" and python_version < "4.0"
-colorama==0.4.6 ; python_version >= "3.10" and python_version < "4.0" and platform_system == "Windows"
+colorama==0.4.6 ; python_version >= "3.10" and python_version < "4.0"
 ghp-import==2.1.0 ; python_version >= "3.10" and python_version < "4.0"
-jinja2==3.1.2 ; python_version >= "3.10" and python_version < "4.0"
-markdown==3.4.4 ; python_version >= "3.10" and python_version < "4.0"
-markupsafe==2.1.3 ; python_version >= "3.10" and python_version < "4.0"
+idna==3.7 ; python_version >= "3.10" and python_version < "4.0"
+jinja2==3.1.4 ; python_version >= "3.10" and python_version < "4.0"
+markdown==3.6 ; python_version >= "3.10" and python_version < "4.0"
+markupsafe==2.1.5 ; python_version >= "3.10" and python_version < "4.0"
 mergedeep==1.3.4 ; python_version >= "3.10" and python_version < "4.0"
-mkdocs-autorefs==0.5.0 ; python_version >= "3.10" and python_version < "4.0"
+mkdocs-autorefs==1.0.1 ; python_version >= "3.10" and python_version < "4.0"
+mkdocs-get-deps==0.2.0 ; python_version >= "3.10" and python_version < "4.0"
 mkdocs-include-markdown-plugin==3.9.1 ; python_version >= "3.10" and python_version < "4.0"
-mkdocs==1.5.3 ; python_version >= "3.10" and python_version < "4.0"
+mkdocs-material-extensions==1.3.1 ; python_version >= "3.10" and python_version < "4.0"
+mkdocs-material==9.5.30 ; python_version >= "3.10" and python_version < "4.0"
+mkdocs-swagger-ui-tag==0.6.10 ; python_version >= "3.10" and python_version < "4.0"
+mkdocs==1.6.0 ; python_version >= "3.10" and python_version < "4.0"
 mkdocstrings==0.22.0 ; python_version >= "3.10" and python_version < "4.0"
-packaging==23.1 ; python_version >= "3.10" and python_version < "4.0"
-pathspec==0.11.2 ; python_version >= "3.10" and python_version < "4.0"
-platformdirs==3.10.0 ; python_version >= "3.10" and python_version < "4.0"
-pymdown-extensions==10.3 ; python_version >= "3.10" and python_version < "4.0"
-python-dateutil==2.8.2 ; python_version >= "3.10" and python_version < "4.0"
+packaging==24.1 ; python_version >= "3.10" and python_version < "4.0"
+paginate==0.5.6 ; python_version >= "3.10" and python_version < "4.0"
+pathspec==0.12.1 ; python_version >= "3.10" and python_version < "4.0"
+platformdirs==4.2.2 ; python_version >= "3.10" and python_version < "4.0"
+pygments==2.18.0 ; python_version >= "3.10" and python_version < "4.0"
+pymdown-extensions==10.9 ; python_version >= "3.10" and python_version < "4.0"
+python-dateutil==2.9.0.post0 ; python_version >= "3.10" and python_version < "4.0"
 pyyaml-env-tag==0.1 ; python_version >= "3.10" and python_version < "4.0"
 pyyaml==6.0.1 ; python_version >= "3.10" and python_version < "4.0"
+regex==2024.7.24 ; python_version >= "3.10" and python_version < "4.0"
+requests==2.32.3 ; python_version >= "3.10" and python_version < "4.0"
 six==1.16.0 ; python_version >= "3.10" and python_version < "4.0"
-watchdog==3.0.0 ; python_version >= "3.10" and python_version < "4.0"
+soupsieve==2.5 ; python_version >= "3.10" and python_version < "4.0"
+urllib3==2.2.2 ; python_version >= "3.10" and python_version < "4.0"
+watchdog==4.0.1 ; python_version >= "3.10" and python_version < "4.0"

docs/user-guide/interaction/Auto-generated Frontend.md

@@ -0,0 +1,167 @@
+# Auto-generated Frontend
+
+`pydase` automatically generates a frontend interface based on your service definition, representing the current state and controls of the service.
+It simplifies the process of visualization and control of the data and devices managed by your `pydase` service, making it accessible to both developers and end-users.
+
+Through the integration of Socket.IO, the frontend provides real-time updates, reflecting changes as they occur and allowing for immediate interaction with the backend.
+
+
+## Accessing the Frontend
+
+You can access the auto-generated frontend by navigating to the hostname of the device the service is hosted on, followed by the exposed port:
+
+```
+http://<hostname>:<port>/
+```
+
+The frontend uses a component-based approach, representing various data types and control mechanisms as distinct UI components. For more information about this, please refer to [Components Guide](../Components.md).
+
+## Customization Options
+
+`pydase` allows you to enhance the user experience by customizing the web interface's appearance through
+
+1. a custom CSS file, and
+2. tailoring the frontend component layout and display style.
+
+For more advanced customization, you can provide a completely custom frontend source.
+
+### Custom CSS Styling
+
+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
+
+You can customize the display names, visibility, and order of components 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 value defaults to [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER).
+
+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).
+
+For example, styling the following service 
+
+```python
+import pydase
+
+
+class Device(pydase.DataService):
+    name = "My Device"
+    temperature = 1.0
+    power = 1
+
+
+class Service(pydase.DataService):
+    device = Device()
+    state = "RUNNING"
+
+
+if __name__ == "__main__":
+    pydase.Server(Service()).run()
+```
+
+with the following `web_settings.json`
+
+```json
+{
+    "device": {
+        "displayName": "My Device",
+        "displayOrder": 1
+    },
+    "device.name": {
+        "display": false
+    },
+    "device.power": {
+        "displayName": "Power",
+        "displayOrder": 1
+    },
+    "device.temperature": {
+      "displayName": "Temperature",
+      "displayOrder": 0
+    },
+    "state": {
+        "displayOrder": 0
+    }
+}
+```
+
+looks like this:
+
+![Tailoring frontend component layout](../../images/Tailoring_frontend_component_layout.png)
+
+### Specifying a Custom Frontend Source
+
+To further customize your web interface, you can provide a custom frontend source.
+By specifying the `frontend_src` parameter when initializing the server, you can host a tailored frontend application:
+
+```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()
+```
+
+`pydase` expects a directory structured as follows:
+
+```bash  title="Frontend directory structure"
+<your_frontend_directory>
+├── assets
+│   └── ...
+└── index.html
+```
+
+Any CSS, js, image or other files need to be put into the assets folder for the web server to be able to provide access to it.
+
+#### Example: Custom React Frontend
+
+You can use vite to generate a react app template:
+
+```bash
+npm create vite@latest my-react-app -- --template react
+```
+
+*TODO: Add some useful information here...*
+
+To deploy the custom react frontend, build it with
+
+```bash
+npm run build
+```
+
+and pass the relative path of the output directory to the `frontend_src` parameter of the `pydase.Server`.
+
+**Note** that you have to make sure that all the generated files (except the `index.html`) are in the `assets` folder. In the react app, you can achieve this by not using the `public` folder, but instead using e.g. `src/assets`.

docs/user-guide/interaction/Python Client.md

@@ -0,0 +1,60 @@
+# Python RPC Client
+
+You can connect to the service using the `pydase.Client`. Below is an example of how to establish a connection to a service and interact with it:
+
+```python
+import pydase
+
+# Replace the hostname and port with the IP address and the port of the machine where 
+# the service is running, respectively
+client_proxy = pydase.Client(url="ws://<ip_addr>:<service_port>").proxy
+# client_proxy = pydase.Client(url="wss://your-domain.ch").proxy  # if your service uses ssl-encryption
+
+# Interact with the service attributes as if they were local
+client_proxy.voltage = 5.0
+print(client_proxy.voltage)  # Expected output: 5.0
+```
+
+This example demonstrates setting and retrieving the `voltage` attribute through the client proxy.
+The proxy acts as a local representative of the remote service, enabling straightforward interaction.
+
+The proxy class dynamically synchronizes with the server's exposed attributes. This synchronization allows the proxy to be automatically updated with any attributes or methods that the server exposes, essentially mirroring the server's API. This dynamic updating enables users to interact with the remote service as if they were working with a local object.
+
+## Context Manager
+
+You can also use the client as a context manager which automatically opens and closes the connection again:
+
+```python
+import pydase
+
+
+with pydase.Client(url="ws://localhost:8001") as client:
+    client.proxy.<my_method>()
+```
+
+
+## Tab Completion Support
+
+In interactive environments such as Python interpreters and Jupyter notebooks, the proxy class supports tab completion, which allows users to explore available methods and attributes.
+
+## Integration within Other Services
+
+You can also integrate a client proxy within another service. Here's how you can set it up:
+
+```python
+import pydase
+
+class MyService(pydase.DataService):
+    # Initialize the client without blocking the constructor
+    proxy = pydase.Client(url="ws://<ip_addr>:<service_port>", block_until_connected=False).proxy
+    # proxy = pydase.Client(url="wss://your-domain.ch", block_until_connected=False).proxy  # communicating with ssl-encrypted service
+
+if __name__ == "__main__":
+    service = MyService()
+    # Create a server that exposes this service; adjust the web_port as needed
+    server = pydase.Server(service, web_port=8002). run()
+```
+
+In this setup, the `MyService` class has a `proxy` attribute that connects to a `pydase` service located at `<ip_addr>:8001`.
+The `block_until_connected=False` argument allows the service to start up even if the initial connection attempt fails.
+This configuration is particularly useful in distributed systems where services may start in any order.

docs/user-guide/interaction/RESTful API.md

@@ -0,0 +1,22 @@
+# RESTful API
+
+The `pydase` RESTful API allows for standard HTTP-based interactions and provides access to various functionalities through specific routes. This is particularly useful for integrating `pydase` services with other applications or for scripting and automation.
+
+For example, you can get a value like this:
+
+```python
+import json
+
+import requests
+
+response = requests.get(
+    "http://<hostname>:<port>/api/v1/get_value?access_path=<full_access_path>"
+)
+serialized_value = json.loads(response.text)
+```
+
+To help developers understand and utilize the API, we provide an OpenAPI specification. This specification describes the available endpoints and corresponding request/response formats.
+
+## OpenAPI Specification
+
+<swagger-ui src="./openapi.yaml"/>

docs/user-guide/interaction/main.md

@@ -0,0 +1,81 @@
+# Interacting with `pydase` Services
+
+`pydase` offers multiple ways for users to interact with the services they create, providing flexibility and convenience for different use cases. This section outlines the primary interaction methods available, including an auto-generated frontend, a RESTful API, and a Python client based on Socket.IO.
+
+{%
+   include-markdown "./Auto-generated Frontend.md"
+   heading-offset=1
+%}
+
+{%
+   include-markdown "./RESTful API.md"
+   heading-offset=1
+%}
+
+{%
+   include-markdown "./Python Client.md"
+   heading-offset=1
+%}
+
+<!-- ## 2. **Socket.IO for Real-Time Updates** -->
+<!-- For scenarios requiring real-time data updates, `pydase` includes a Socket.IO server. This feature is ideal for applications where live data tracking is crucial, such as monitoring systems or interactive dashboards. -->
+<!---->
+<!-- ### Key Features: -->
+<!-- - **Live Data Streams**: Receive real-time updates for data changes. -->
+<!-- - **Event-Driven Communication**: Utilize event-based messaging to push updates and handle client actions. -->
+<!---->
+<!-- ### Example Usage: -->
+<!-- Clients can connect to the Socket.IO server to receive updates: -->
+<!-- ```javascript -->
+<!-- var socket = io.connect('http://<hostname>:<port>'); -->
+<!-- socket.on('<event_name>', function(data) { -->
+<!--     console.log(data); -->
+<!-- }); -->
+<!-- ``` -->
+<!---->
+<!-- **Use Cases:** -->
+<!---->
+<!-- - Real-time monitoring and alerts -->
+<!-- - Live data visualization -->
+<!-- - Collaborative applications -->
+<!---->
+<!-- ## 3. **Auto-Generated Frontend** -->
+<!-- `pydase` automatically generates a web frontend based on the service definitions. This frontend is a convenient interface for interacting with the service, especially for users who prefer a graphical interface over command-line or code-based interactions. -->
+<!---->
+<!-- ### Key Features: -->
+<!-- - **User-Friendly Interface**: Intuitive and easy to use, with real-time interaction capabilities. -->
+<!-- - **Customizable**: Adjust the frontend's appearance and functionality to suit specific needs. -->
+<!---->
+<!-- ### Accessing the Frontend: -->
+<!-- Once the service is running, access the frontend via a web browser: -->
+<!-- ``` -->
+<!-- http://<hostname>:<port> -->
+<!-- ``` -->
+<!---->
+<!-- **Use Cases:** -->
+<!---->
+<!-- - End-user interfaces for data control and visualization -->
+<!-- - Rapid prototyping and testing -->
+<!-- - Demonstrations and training -->
+<!---->
+<!-- ## 4. **Python Client** -->
+<!-- `pydase` also provides a Python client for programmatic interactions. This client is particularly useful for developers who want to integrate `pydase` services into other Python applications or automate interactions. -->
+<!---->
+<!-- ### Key Features: -->
+<!-- - **Direct Interaction**: Call methods and access properties as if they were local. -->
+<!-- - **Tab Completion**: Supports tab completion in interactive environments like Jupyter notebooks. -->
+<!---->
+<!-- ### Example Usage: -->
+<!-- ```python -->
+<!-- import pydase -->
+<!---->
+<!-- client = pydase.Client(hostname="<ip_addr>", port=8001) -->
+<!-- service = client.proxy -->
+<!-- service.some_method() -->
+<!-- ``` -->
+<!---->
+<!-- **Use Cases:** -->
+<!---->
+<!-- - Integrating with other Python applications -->
+<!-- - Automation and scripting -->
+<!-- - Data analysis and manipulation -->

docs/user-guide/interaction/openapi.yaml

@@ -0,0 +1,326 @@
+openapi: 3.1.0
+info:
+  version: 1.0.0
+  title: pydase API
+tags:
+  - name: /api/v1
+    description: Version 1
+paths:
+  /api/v1/get_value:
+    get:
+      tags:
+        - /api/v1
+      summary: Get the value of an existing attribute.
+      description: Get the value of an existing attribute by full access path.
+      operationId: getValue
+      parameters:
+        - in: query
+          name: access_path
+          schema:
+            type: string
+          example:  device.channel[0].voltage
+          required: true
+          description: Full access path of the service attribute.
+      responses:
+        '200':
+          description: Successful Operation
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SerializedAttribute'
+              examples:
+                Exists:
+                  summary: Attribute exists
+                  value:
+                    docs: My documentation string.
+                    full_access_path: device.channel[0].voltage
+                    readonly: false
+                    type: float
+                    value: 12.1
+        '400':
+          description: Could not get attribute
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SerializedException'
+              examples:
+                Attribute:
+                  summary: Attribute does not exist
+                  value:
+                    docs: null
+                    full_access_path: ""
+                    name: AttributeError
+                    readonly: true
+                    type: Exception
+                    value: "'MyService' object has no attribute 'invalid_attribute'"
+                List:
+                  summary: List index out of range
+                  value:
+                    docs: null
+                    full_access_path: ""
+                    name: IndexError
+                    readonly: true
+                    type: Exception
+                    value: "list index out of range"
+  /api/v1/update_value:
+    put:
+      tags:
+        - /api/v1
+      summary: Update an existing attribute.
+      description: Update an existing attribute by full access path.
+      operationId: updateValue
+      requestBody:
+        description: Update an existent attribute in the service
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/UpdateValue'
+        required: true
+      responses:
+        '200':
+          description: Successful Operation
+        '400':
+          description: Could not Update Attribute
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SerializedException'
+              examples:
+                Attribute:
+                  summary: Attribute does not exist
+                  value:
+                    docs: null
+                    full_access_path: ""
+                    name: AttributeError
+                    readonly: true
+                    type: Exception
+                    value: "'MyService' object has no attribute 'invalid_attribute'"
+                ReadOnly:
+                  summary: Attribute is read-only
+                  value:
+                    docs: null
+                    full_access_path: ""
+                    name: AttributeError
+                    readonly: true
+                    type: Exception
+                    value: "property 'readonly_property' of 'MyService' object has no setter"
+                List:
+                  summary: List index out of range
+                  value:
+                    docs: null
+                    full_access_path: ""
+                    name: IndexError
+                    readonly: true
+                    type: Exception
+                    value: "list index out of range"
+  /api/v1/trigger_method:
+    put:
+      tags:
+        - /api/v1
+      summary: Trigger method.
+      description: Trigger method with by full access path with provided args and kwargs.
+      operationId: triggerMethod
+      requestBody:
+        description: Update an existent attribute in the service
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/TriggerMethod'
+        required: true
+      responses:
+        '200':
+          description: Successful Operation
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SerializedAttribute'
+              examples:
+                NoneReturn:
+                  summary: Function returns None
+                  value:
+                    docs: null
+                    full_access_path: ""
+                    readonly: false
+                    type: "NoneType"
+                    value: null
+                FloatReturn:
+                  summary: Function returns float
+                  value:
+                    docs: null
+                    full_access_path: ""
+                    readonly: false
+                    type: "float"
+                    value: 23.2
+        '400':
+          description: Method does not exist
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SerializedException'
+              examples:
+                Args:
+                  summary: Wrong number of arguments
+                  value:
+                    docs: null
+                    full_access_path: ""
+                    name: TypeError
+                    readonly: true
+                    type: Exception
+                    value: "MyService.some_function() takes 1 positional argument but 2 were given"
+                Attribute:
+                  summary: Attribute does not exist
+                  value:
+                    docs: null
+                    full_access_path: ""
+                    name: AttributeError
+                    readonly: true
+                    type: Exception
+                    value: "'MyService' object has no attribute 'invalid_method'"
+                List:
+                  summary: List index out of range
+                  value:
+                    docs: null
+                    full_access_path: ""
+                    name: IndexError
+                    readonly: true
+                    type: Exception
+                    value: "list index out of range"
+                Dict:
+                  summary: Dictionary key does not exist
+                  value:
+                    docs: null
+                    full_access_path: ""
+                    name: KeyError
+                    readonly: true
+                    type: Exception
+                    value: "invalid_key"
+components:
+  schemas:
+    UpdateValue:
+      required:
+        - access_path
+        - value
+      type: object
+      properties:
+        access_path:
+          type: string
+          example: device.channel[0].voltage
+        value:
+          $ref: '#/components/schemas/SerializedValue'
+    TriggerMethod:
+      required:
+        - access_path
+      type: object
+      properties:
+        access_path:
+          type: string
+          example: device.channel[0].voltage
+        args:
+          type: object
+          required:
+            - type
+            - value
+            - full_access_path
+          properties:
+            full_access_path:
+              type: string
+              example: ""
+            type:
+              type: string
+              enum:
+                - list
+            value:
+              type: array
+              items:
+                $ref: '#/components/schemas/SerializedValue'
+        kwargs:
+          type: object
+          required:
+            - type
+            - value
+            - full_access_path
+          properties:
+            full_access_path:
+              type: string
+              example: ""
+            type:
+              type: string
+              enum:
+                - dict
+            value:
+              type: object
+              additionalProperties:
+                $ref: '#/components/schemas/SerializedValue'
+    SerializedValue:
+      required:
+        - full_access_path
+        - type
+        - value
+      type: object
+      properties:
+        docs:
+          type: string | null
+          example: null
+        full_access_path:
+          type: string
+          example: ""
+        readonly:
+          type: boolean
+          example: false
+        type:
+          type: string
+          example: float
+        value:
+          type: any
+          example: 22.0
+    SerializedAttribute:
+      required:
+        - full_access_path
+        - type
+        - value
+      type: object
+      properties:
+        docs:
+          type: string | null
+          example: My documentation string.
+        full_access_path:
+          type: string
+          example: device.channel[0].voltage
+        readonly:
+          type: boolean
+          example: false
+        type:
+          type: string
+          example: float
+        value:
+          type: any
+          example: 22.0
+    SerializedException:
+      required:
+        - full_access_path
+        - type
+        - value
+      type: object
+      properties:
+        docs:
+          type: string | null
+          example: Raised when the access path does not correspond to a valid attribute.
+        full_access_path:
+          type: string
+          example: ""
+        name:
+          type: string
+          example: SerializationPathError
+        readonly:
+          type: boolean
+          example: true
+        type:
+          type: string
+          example: Exception
+        value:
+          type: string
+          examples:
+            value:
+              "Index '2': list index out of range"
+            some:
+              "Index '2': list index out of range"

frontend/.eslintrc

@@ -1,16 +0,0 @@
-{
-    "root": true,
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-        "@typescript-eslint",
-        "prettier"
-    ],
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/recommended",
-        "prettier"
-    ],
-    "rules": {
-        "prettier/prettier": "error"
-    }
-}

frontend/.gitignore

@@ -1,20 +1,24 @@
-# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
-
-# dependencies
-/node_modules
-/.pnp
-.pnp.js
-
-# testing
-/coverage
-
-# misc
-.DS_Store
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
+# Logs
+logs
+*.log
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/.prettierrc

@@ -1,11 +1,9 @@
 {
-  "arrowParens": "always",
-  "bracketSameLine": true,
-  "endOfLine": "auto",
-  "semi": true,
-  "singleQuote": true,
-  "tabWidth": 2,
-  "vueIndentScriptAndStyle": true,
-  "printWidth": 88,
-  "trailingComma": "none"
+    "arrowParens": "always",
+    "bracketSameLine": true,
+    "endOfLine": "auto",
+    "semi": true,
+    "singleQuote": false,
+    "tabWidth": 2,
+    "printWidth": 88
 }

frontend/README.md

@@ -1,70 +1,30 @@
-# Getting Started with Create React App
+# React + TypeScript + Vite
 
-This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
 
-## Available Scripts
+Currently, two official plugins are available:
 
-In the project directory, you can run:
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
 
-### `npm start`
+## Expanding the ESLint configuration
 
-Runs the app in the development mode.\
-Open [http://localhost:3000](http://localhost:3000) to view it in your browser.
+If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:
 
-The page will reload when you make changes.\
-You may also see any lint errors in the console.
+- Configure the top-level `parserOptions` property like this:
 
-### `npm test`
+```js
+export default {
+  // other rules...
+  parserOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+    project: ['./tsconfig.json', './tsconfig.node.json'],
+    tsconfigRootDir: __dirname,
+  },
+}
+```
 
-Launches the test runner in the interactive watch mode.\
-See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.
-
-### `npm run build`
-
-Builds the app for production to the `build` folder.\
-It correctly bundles React in production mode and optimizes the build for the best performance.
-
-The build is minified and the filenames include the hashes.\
-Your app is ready to be deployed!
-
-See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
-
-### `npm run eject`
-
-**Note: this is a one-way operation. Once you `eject`, you can't go back!**
-
-If you aren't satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project.
-
-Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you're on your own.
-
-You don't have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn't feel obligated to use this feature. However we understand that this tool wouldn't be useful if you couldn't customize it when you are ready for it.
-
-## Learn More
-
-You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).
-
-To learn React, check out the [React documentation](https://reactjs.org/).
-
-### Code Splitting
-
-This section has moved here: [https://facebook.github.io/create-react-app/docs/code-splitting](https://facebook.github.io/create-react-app/docs/code-splitting)
-
-### Analyzing the Bundle Size
-
-This section has moved here: [https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size](https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size)
-
-### Making a Progressive Web App
-
-This section has moved here: [https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app](https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app)
-
-### Advanced Configuration
-
-This section has moved here: [https://facebook.github.io/create-react-app/docs/advanced-configuration](https://facebook.github.io/create-react-app/docs/advanced-configuration)
-
-### Deployment
-
-This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment)
-
-### `npm run build` fails to minify
-
-This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify)
+- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked`
+- Optionally add `plugin:@typescript-eslint/stylistic-type-checked`
+- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list

frontend/eslint.config.js

@@ -0,0 +1,24 @@
+import eslint from "@eslint/js";
+import tseslint from "typescript-eslint";
+import eslintPluginPrettierRecommended from "eslint-plugin-prettier/recommended";
+import reactRecommended from "eslint-plugin-react/configs/recommended.js";
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  ...tseslint.configs.stylistic,
+  {
+    files: ["**/*.{js,jsx,ts,tsx}"],
+    ...reactRecommended,
+    languageOptions: {
+      parser: tseslint.parser,
+    },
+    rules: {
+      "prettier/prettier": "error",
+      "react/react-in-jsx-scope": "off",
+      "react/prop-types": "off",
+      "@typescript-eslint/no-empty-function": "off",
+    },
+  },
+  eslintPluginPrettierRecommended,
+);

frontend/index.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="theme-color" content="#000000" />
+    <meta name="description" content="Web site displaying a pydase UI." />
+</head>
+
+<body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+    <script type="module" src="/src/index.tsx"></script>
+</body>
+
+</html>

frontend/package.json

@@ -1,58 +1,40 @@
 {
-  "name": "pydase",
-  "version": "0.1.0",
-  "private": true,
-  "dependencies": {
-    "@emotion/react": "^11.11.1",
-    "@emotion/styled": "^11.11.0",
-    "@fsouza/prettierd": "^0.25.1",
-    "@mui/material": "^5.14.1",
-    "@testing-library/jest-dom": "^5.16.5",
-    "@testing-library/react": "^13.4.0",
-    "@testing-library/user-event": "^13.5.0",
-    "bootstrap": "^5.3.0",
-    "react": "^18.2.0",
-    "react-bootstrap": "^2.8.0",
-    "react-bootstrap-icons": "^1.10.3",
-    "react-dom": "^18.2.0",
-    "react-scripts": "5.0.1",
-    "socket.io-client": "^4.7.1",
-    "web-vitals": "^3.4.0"
-  },
-  "scripts": {
-    "start": "NODE_ENV=development react-scripts start",
-    "build": "BUILD_PATH='../src/pydase/frontend' react-scripts build",
-    "test": "react-scripts test",
-    "eject": "react-scripts eject"
-  },
-  "eslintConfig": {
-    "extends": [
-      "react-app",
-      "react-app/jest"
-    ]
-  },
-  "browserslist": {
-    "production": [
-      ">0.2%",
-      "not dead",
-      "not op_mini all"
-    ],
-    "development": [
-      "last 1 chrome version",
-      "last 1 firefox version",
-      "last 1 safari version"
-    ]
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@types/react": "^18.0.0",
-    "@types/react-dom": "^18.0.0",
-    "@typescript-eslint/eslint-plugin": "^6.11.0",
-    "@typescript-eslint/parser": "^6.9.0",
-    "eslint": "^8.52.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-prettier": "^5.0.1",
-    "prettier": "^3.0.3",
-    "typescript": "^4.9.0"
-  }
+    "name": "pydase",
+    "private": true,
+    "version": "0.1.0",
+    "type": "module",
+    "scripts": {
+        "dev": "vite",
+        "build": "tsc -b && vite build --emptyOutDir",
+        "lint": "eslint . --report-unused-disable-directives --max-warnings 0",
+        "preview": "vite preview"
+    },
+    "dependencies": {
+        "@emotion/styled": "^11.11.0",
+        "@mui/material": "^5.14.1",
+        "bootstrap": "^5.3.3",
+        "deep-equal": "^2.2.3",
+        "react": "^18.3.1",
+        "react-bootstrap": "^2.10.0",
+        "react-bootstrap-icons": "^1.11.4",
+        "socket.io-client": "^4.7.1"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.6.0",
+        "@types/deep-equal": "^1.0.4",
+        "@types/eslint__js": "^8.42.3",
+        "@types/node": "^20.14.10",
+        "@types/react": "^18.3.3",
+        "@types/react-dom": "^18.3.0",
+        "@typescript-eslint/eslint-plugin": "^7.15.0",
+        "@vitejs/plugin-react-swc": "^3.5.0",
+        "eslint": "^8.57.0",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-plugin-prettier": "^5.1.3",
+        "eslint-plugin-react": "^7.34.3",
+        "prettier": "3.3.2",
+        "typescript": "^5.5.3",
+        "typescript-eslint": "^7.15.0",
+        "vite": "^5.3.1"
+    }
 }

frontend/public/index.html

@@ -1,43 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <link rel="icon" href="%PUBLIC_URL%/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="%PUBLIC_URL%/logo192.png" />
-    <!--
-      manifest.json provides metadata used when your web app is installed on a
-      user's mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/
-    -->
-    <link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
-    <!--
-      Notice the use of %PUBLIC_URL% in the tags above.
-      It will be replaced with the URL of the `public` folder during the build.
-      Only files inside the `public` folder can be referenced from the HTML.
-
-      Unlike "/favicon.ico" or "favicon.ico", "%PUBLIC_URL%/favicon.ico" will
-      work correctly both with client-side routing and a non-root public URL.
-      Learn how to configure a non-root public URL by running `npm run build`.
-    -->
-    <title>pydase App</title>
-  </head>
-  <body>
-    <noscript>You need to enable JavaScript to run this app.</noscript>
-    <div id="root"></div>
-    <!--
-      This HTML file is a template.
-      If you open it directly in the browser, you will see an empty page.
-
-      You can add webfonts, meta tags, or analytics to this file.
-      The build step will place the bundled scripts into the <body> tag.
-
-      To begin the development, run `npm start` or `yarn start`.
-      To create a production bundle, use `npm run build` or `yarn build`.
-    -->
-  </body>
-</html>

frontend/public/manifest.json

@@ -1,25 +0,0 @@
-{
-  "short_name": "React App",
-  "name": "Create React App Sample",
-  "icons": [
-    {
-      "src": "favicon.ico",
-      "sizes": "64x64 32x32 24x24 16x16",
-      "type": "image/x-icon"
-    },
-    {
-      "src": "logo192.png",
-      "type": "image/png",
-      "sizes": "192x192"
-    },
-    {
-      "src": "logo512.png",
-      "type": "image/png",
-      "sizes": "512x512"
-    }
-  ],
-  "start_url": ".",
-  "display": "standalone",
-  "theme_color": "#000000",
-  "background_color": "#ffffff"
-}

frontend/public/robots.txt

@@ -1,3 +0,0 @@
-# https://www.robotstxt.org/robotstxt.html
-User-agent: *
-Disallow:

frontend/src/App.tsx

@@ -1,43 +1,49 @@
-import { useCallback, useEffect, useReducer, useState } from 'react';
-import { Navbar, Form, Offcanvas, Container } from 'react-bootstrap';
-import { hostname, port, socket } from './socket';
-import './App.css';
+import { useCallback, useEffect, useReducer, useState } from "react";
+import { Navbar, Form, Offcanvas, Container } from "react-bootstrap";
+import { hostname, port, socket } from "./socket";
+import "./App.css";
 import {
   Notifications,
   Notification,
-  LevelName
-} from './components/NotificationsComponent';
-import { ConnectionToast } from './components/ConnectionToast';
-import { setNestedValueByPath, State } from './utils/stateUtils';
-import { WebSettingsContext, WebSetting } from './WebSettings';
-import { SerializedValue, GenericComponent } from './components/GenericComponent';
+  LevelName,
+} from "./components/NotificationsComponent";
+import { ConnectionToast } from "./components/ConnectionToast";
+import { setNestedValueByPath, State } from "./utils/stateUtils";
+import { WebSettingsContext, WebSetting } from "./WebSettings";
+import { GenericComponent } from "./components/GenericComponent";
+import { SerializedObject } from "./types/SerializedObject";
+import useLocalStorage from "./hooks/useLocalStorage";
 
 type Action =
-  | { type: 'SET_DATA'; data: State }
+  | { type: "SET_DATA"; data: State }
   | {
-      type: 'UPDATE_ATTRIBUTE';
+      type: "UPDATE_ATTRIBUTE";
       fullAccessPath: string;
-      newValue: SerializedValue;
+      newValue: SerializedObject;
     };
-type UpdateMessage = {
-  data: { full_access_path: string; value: SerializedValue };
-};
-type LogMessage = {
+interface UpdateMessage {
+  data: { full_access_path: string; value: SerializedObject };
+}
+interface LogMessage {
   levelname: LevelName;
   message: string;
-};
+}
 
-const reducer = (state: State, action: Action): State => {
+const reducer = (state: State | null, action: Action): State | null => {
   switch (action.type) {
-    case 'SET_DATA':
+    case "SET_DATA":
       return action.data;
-    case 'UPDATE_ATTRIBUTE': {
+    case "UPDATE_ATTRIBUTE": {
       if (state === null) {
         return null;
       }
       return {
         ...state,
-        value: setNestedValueByPath(state.value, action.fullAccessPath, action.newValue)
+        value: setNestedValueByPath(
+          state.value as Record<string, SerializedObject>,
+          action.fullAccessPath,
+          action.newValue,
+        ),
       };
     }
     default:
@@ -46,12 +52,19 @@ const reducer = (state: State, action: Action): State => {
 };
 const App = () => {
   const [state, dispatch] = useReducer(reducer, null);
+  const [serviceName, setServiceName] = useState<string | null>(null);
   const [webSettings, setWebSettings] = useState<Record<string, WebSetting>>({});
-  const [isInstantUpdate, setIsInstantUpdate] = useState(false);
+  const [isInstantUpdate, setIsInstantUpdate] = useLocalStorage(
+    "isInstantUpdate",
+    false,
+  );
   const [showSettings, setShowSettings] = useState(false);
-  const [showNotification, setShowNotification] = useState(false);
+  const [showNotification, setShowNotification] = useLocalStorage(
+    "showNotification",
+    false,
+  );
   const [notifications, setNotifications] = useState<Notification[]>([]);
-  const [connectionStatus, setConnectionStatus] = useState('connecting');
+  const [connectionStatus, setConnectionStatus] = useState("connecting");
 
   useEffect(() => {
     // Allow the user to add a custom css file
@@ -59,49 +72,54 @@ const App = () => {
       .then((response) => {
         if (response.ok) {
           // If the file exists, create a link element for the custom CSS
-          const link = document.createElement('link');
+          const link = document.createElement("link");
           link.href = `http://${hostname}:${port}/custom.css`;
-          link.type = 'text/css';
-          link.rel = 'stylesheet';
+          link.type = "text/css";
+          link.rel = "stylesheet";
           document.head.appendChild(link);
         }
       })
       .catch(console.error); // Handle the error appropriately
 
-    socket.on('connect', () => {
+    socket.on("connect", () => {
       // Fetch data from the API when the client connects
       fetch(`http://${hostname}:${port}/service-properties`)
         .then((response) => response.json())
-        .then((data: State) => dispatch({ type: 'SET_DATA', data }));
+        .then((data: State) => {
+          dispatch({ type: "SET_DATA", data });
+          setServiceName(data.name);
+
+          document.title = data.name; // Setting browser tab title
+        });
       fetch(`http://${hostname}:${port}/web-settings`)
         .then((response) => response.json())
         .then((data: Record<string, WebSetting>) => setWebSettings(data));
-      setConnectionStatus('connected');
+      setConnectionStatus("connected");
     });
-    socket.on('disconnect', () => {
-      setConnectionStatus('disconnected');
+    socket.on("disconnect", () => {
+      setConnectionStatus("disconnected");
       setTimeout(() => {
         // Only set "reconnecting" is the state is still "disconnected"
         // E.g. when the client has already reconnected
         setConnectionStatus((currentState) =>
-          currentState === 'disconnected' ? 'reconnecting' : currentState
+          currentState === "disconnected" ? "reconnecting" : currentState,
         );
       }, 2000);
     });
 
-    socket.on('notify', onNotify);
-    socket.on('log', onLogMessage);
+    socket.on("notify", onNotify);
+    socket.on("log", onLogMessage);
 
     return () => {
-      socket.off('notify', onNotify);
-      socket.off('log', onLogMessage);
+      socket.off("notify", onNotify);
+      socket.off("log", onLogMessage);
     };
   }, []);
 
   // Adding useCallback to prevent notify to change causing a re-render of all
   // components
   const addNotification = useCallback(
-    (message: string, levelname: LevelName = 'DEBUG') => {
+    (message: string, levelname: LevelName = "DEBUG") => {
       // Getting the current time in the required format
       const timeStamp = new Date().toISOString().substring(11, 19);
       // Adding an id to the notification to provide a way of removing it
@@ -110,15 +128,15 @@ const App = () => {
       // Custom logic for notifications
       setNotifications((prevNotifications) => [
         { levelname, id, message, timeStamp },
-        ...prevNotifications
+        ...prevNotifications,
       ]);
     },
-    []
+    [],
   );
 
   const removeNotificationById = (id: number) => {
     setNotifications((prevNotifications) =>
-      prevNotifications.filter((n) => n.id !== id)
+      prevNotifications.filter((n) => n.id !== id),
     );
   };
 
@@ -131,9 +149,9 @@ const App = () => {
 
     // Dispatching the update to the reducer
     dispatch({
-      type: 'UPDATE_ATTRIBUTE',
+      type: "UPDATE_ATTRIBUTE",
       fullAccessPath,
-      newValue
+      newValue,
     });
   }
 
@@ -149,7 +167,7 @@ const App = () => {
     <>
       <Navbar expand={false} bg="primary" variant="dark" fixed="top">
         <Container fluid>
-          <Navbar.Brand>Data Service App</Navbar.Brand>
+          <Navbar.Brand>{serviceName}</Navbar.Brand>
           <Navbar.Toggle aria-controls="offcanvasNavbar" onClick={handleShowSettings} />
         </Container>
       </Navbar>
@@ -188,9 +206,7 @@ const App = () => {
       <div className="App navbarOffset">
         <WebSettingsContext.Provider value={webSettings}>
           <GenericComponent
-            name=""
-            parentPath=""
-            attribute={state as SerializedValue}
+            attribute={state as SerializedObject}
             isInstantUpdate={isInstantUpdate}
             addNotification={addNotification}
           />

frontend/src/WebSettings.tsx

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

frontend/src/components/AsyncMethodComponent.tsx

@@ -1,30 +1,29 @@
-import React, { useEffect, useRef } from 'react';
-import { runMethod } from '../socket';
-import { Form, Button, InputGroup } from 'react-bootstrap';
-import { DocStringComponent } from './DocStringComponent';
-import { LevelName } from './NotificationsComponent';
+import React, { useEffect, useRef, useState } from "react";
+import { runMethod } from "../socket";
+import { Form, Button, InputGroup, Spinner } from "react-bootstrap";
+import { DocStringComponent } from "./DocStringComponent";
+import { LevelName } from "./NotificationsComponent";
+import useRenderCount from "../hooks/useRenderCount";
 
-type AsyncMethodProps = {
-  name: string;
-  parentPath: string;
-  value: 'RUNNING' | null;
-  docString?: string;
+interface AsyncMethodProps {
+  fullAccessPath: string;
+  value: "RUNNING" | null;
+  docString: string | null;
   hideOutput?: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
   displayName: string;
   id: string;
   render: boolean;
-};
+}
 
 export const AsyncMethodComponent = React.memo((props: AsyncMethodProps) => {
   const {
-    name,
-    parentPath,
+    fullAccessPath,
     docString,
     value: runningTask,
     addNotification,
     displayName,
-    id
+    id,
   } = props;
 
   // Conditional rendering based on the 'render' prop.
@@ -32,12 +31,13 @@ export const AsyncMethodComponent = React.memo((props: AsyncMethodProps) => {
     return null;
   }
 
-  const renderCount = useRef(0);
+  const renderCount = useRenderCount();
   const formRef = useRef(null);
-  const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
+  const [spinning, setSpinning] = useState(false);
+  const name = fullAccessPath.split(".").at(-1)!;
+  const parentPath = fullAccessPath.slice(0, -(name.length + 1));
 
   useEffect(() => {
-    renderCount.current++;
     let message: string;
 
     if (runningTask === null) {
@@ -46,6 +46,7 @@ export const AsyncMethodComponent = React.memo((props: AsyncMethodProps) => {
       message = `${fullAccessPath} was started.`;
     }
     addNotification(message);
+    setSpinning(false);
   }, [props.value]);
 
   const execute = async (event: React.FormEvent) => {
@@ -58,14 +59,14 @@ export const AsyncMethodComponent = React.memo((props: AsyncMethodProps) => {
       method_name = `start_${name}`;
     }
 
-    runMethod(method_name, parentPath, {});
+    const accessPath = [parentPath, method_name].filter((element) => element).join(".");
+    setSpinning(true);
+    runMethod(accessPath);
   };
 
   return (
     <div className="component asyncMethodComponent" id={id}>
-      {process.env.NODE_ENV === 'development' && (
-        <div>Render count: {renderCount.current}</div>
-      )}
+      {process.env.NODE_ENV === "development" && <div>Render count: {renderCount}</div>}
       <Form onSubmit={execute} ref={formRef}>
         <InputGroup>
           <InputGroup.Text>
@@ -73,10 +74,18 @@ export const AsyncMethodComponent = React.memo((props: AsyncMethodProps) => {
             <DocStringComponent docString={docString} />
           </InputGroup.Text>
           <Button id={`button-${id}`} type="submit">
-            {runningTask === 'RUNNING' ? 'Stop ' : 'Start '}
+            {spinning ? (
+              <Spinner size="sm" role="status" aria-hidden="true" />
+            ) : runningTask === "RUNNING" ? (
+              "Stop "
+            ) : (
+              "Start "
+            )}
           </Button>
         </InputGroup>
       </Form>
     </div>
   );
 });
+
+AsyncMethodComponent.displayName = "AsyncMethodComponent";

frontend/src/components/ButtonComponent.tsx

@@ -1,65 +1,59 @@
-import React, { useEffect, useRef } from 'react';
-import { ToggleButton } from 'react-bootstrap';
-import { DocStringComponent } from './DocStringComponent';
-import { LevelName } from './NotificationsComponent';
+import React, { useEffect } from "react";
+import { ToggleButton } from "react-bootstrap";
+import { DocStringComponent } from "./DocStringComponent";
+import { LevelName } from "./NotificationsComponent";
+import { SerializedObject } from "../types/SerializedObject";
+import useRenderCount from "../hooks/useRenderCount";
 
-type ButtonComponentProps = {
-  name: string;
-  parentPath?: string;
+interface ButtonComponentProps {
+  fullAccessPath: string;
   value: boolean;
   readOnly: boolean;
-  docString: string;
+  docString: string | null;
   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;
+  changeCallback?: (value: SerializedObject, callback?: (ack: unknown) => void) => void;
   displayName: string;
   id: string;
-};
+}
 
 export const ButtonComponent = React.memo((props: ButtonComponentProps) => {
   const {
     value,
+    fullAccessPath,
     readOnly,
     docString,
     addNotification,
     changeCallback = () => {},
     displayName,
-    id
+    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);
-
-  useEffect(() => {
-    renderCount.current++;
-  });
+  const renderCount = useRenderCount();
 
   useEffect(() => {
     addNotification(`${fullAccessPath} changed to ${value}.`);
   }, [props.value]);
 
   const setChecked = (checked: boolean) => {
-    changeCallback(checked);
+    changeCallback({
+      type: "bool",
+      value: checked,
+      full_access_path: fullAccessPath,
+      readonly: readOnly,
+      doc: docString,
+    });
   };
 
   return (
-    <div className={'component buttonComponent'} id={id}>
-      {process.env.NODE_ENV === 'development' && (
-        <div>Render count: {renderCount.current}</div>
-      )}
+    <div className={"component buttonComponent"} id={id}>
+      {process.env.NODE_ENV === "development" && <div>Render count: {renderCount}</div>}
 
       <ToggleButton
         id={`toggle-check-${id}`}
         type="checkbox"
-        variant={value ? 'success' : 'secondary'}
+        variant={value ? "success" : "secondary"}
         checked={value}
         value={displayName}
         disabled={readOnly}
@@ -70,3 +64,5 @@ export const ButtonComponent = React.memo((props: ButtonComponentProps) => {
     </div>
   );
 });
+
+ButtonComponent.displayName = "ButtonComponent";

frontend/src/components/ColouredEnumComponent.tsx

@@ -1,100 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react';
-import { InputGroup, Form, Row, Col } from 'react-bootstrap';
-import { DocStringComponent } from './DocStringComponent';
-import { LevelName } from './NotificationsComponent';
-
-type ColouredEnumComponentProps = {
-  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 ColouredEnumComponent = React.memo((props: ColouredEnumComponentProps) => {
-  const {
-    name,
-    value,
-    docString,
-    enumDict,
-    readOnly,
-    addNotification,
-    displayName,
-    id
-  } = 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(() => {
-    setEnumValue(() => {
-      return props.value;
-    });
-    addNotification(`${fullAccessPath} changed to ${value}.`);
-  }, [props.value]);
-
-  return (
-    <div className={'component enumComponent'} id={id}>
-      {process.env.NODE_ENV === 'development' && (
-        <div>Render count: {renderCount.current}</div>
-      )}
-      <Row>
-        <Col className="d-flex align-items-center">
-          <InputGroup.Text>
-            {displayName}
-            <DocStringComponent docString={docString} />
-          </InputGroup.Text>
-          {readOnly ? (
-            // Display the Form.Control when readOnly is true
-            <Form.Control
-              value={enumValue}
-              name={name}
-              disabled={true}
-              style={{ backgroundColor: enumDict[enumValue] }}
-            />
-          ) : (
-            // Display the Form.Select when readOnly is false
-            <Form.Select
-              aria-label="coloured-enum-select"
-              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}
-                </option>
-              ))}
-            </Form.Select>
-          )}
-        </Col>
-      </Row>
-    </div>
-  );
-});

frontend/src/components/ConnectionToast.tsx

@@ -1,9 +1,9 @@
-import React, { useEffect, useState } from 'react';
-import { Toast, Button, ToastContainer } from 'react-bootstrap';
+import React, { useEffect, useState } from "react";
+import { Toast, Button, ToastContainer } from "react-bootstrap";
 
-type ConnectionToastProps = {
+interface ConnectionToastProps {
   connectionStatus: string;
-};
+}
 
 /**
  * ConnectionToast Component
@@ -36,31 +36,31 @@ export const ConnectionToast = React.memo(
       delay: number | undefined;
     } => {
       switch (connectionStatus) {
-        case 'connecting':
+        case "connecting":
           return {
-            message: 'Connecting...',
-            bg: 'info',
-            delay: undefined
+            message: "Connecting...",
+            bg: "info",
+            delay: undefined,
           };
-        case 'connected':
-          return { message: 'Connected', bg: 'success', delay: 1000 };
-        case 'disconnected':
+        case "connected":
+          return { message: "Connected", bg: "success", delay: 1000 };
+        case "disconnected":
           return {
-            message: 'Disconnected',
-            bg: 'danger',
-            delay: undefined
+            message: "Disconnected",
+            bg: "danger",
+            delay: undefined,
           };
-        case 'reconnecting':
+        case "reconnecting":
           return {
-            message: 'Reconnecting...',
-            bg: 'info',
-            delay: undefined
+            message: "Reconnecting...",
+            bg: "info",
+            delay: undefined,
           };
         default:
           return {
-            message: '',
-            bg: 'info',
-            delay: undefined
+            message: "",
+            bg: "info",
+            delay: undefined,
           };
       }
     };
@@ -82,5 +82,7 @@ export const ConnectionToast = React.memo(
         </Toast>
       </ToastContainer>
     );
-  }
+  },
 );
+
+ConnectionToast.displayName = "ConnectionToast";

frontend/src/components/DataServiceComponent.tsx

@@ -1,50 +1,42 @@
-import { useState } from 'react';
-import React from 'react';
-import { Card, Collapse } from 'react-bootstrap';
-import { ChevronDown, ChevronRight } from 'react-bootstrap-icons';
-import { SerializedValue, GenericComponent } from './GenericComponent';
-import { LevelName } from './NotificationsComponent';
+import React from "react";
+import { Card, Collapse } from "react-bootstrap";
+import { ChevronDown, ChevronRight } from "react-bootstrap-icons";
+import { GenericComponent } from "./GenericComponent";
+import { LevelName } from "./NotificationsComponent";
+import { SerializedObject } from "../types/SerializedObject";
+import useLocalStorage from "../hooks/useLocalStorage";
+import useSortedEntries from "../hooks/useSortedEntries";
 
-type DataServiceProps = {
-  name: string;
+interface DataServiceProps {
   props: DataServiceJSON;
-  parentPath?: string;
   isInstantUpdate: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
   displayName: string;
   id: string;
-};
+}
 
-export type DataServiceJSON = Record<string, SerializedValue>;
+export type DataServiceJSON = Record<string, SerializedObject>;
 
 export const DataServiceComponent = React.memo(
-  ({
-    name,
-    props,
-    parentPath = undefined,
-    isInstantUpdate,
-    addNotification,
-    displayName,
-    id
-  }: DataServiceProps) => {
-    const [open, setOpen] = useState(true);
-    const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
+  ({ props, isInstantUpdate, addNotification, displayName, id }: DataServiceProps) => {
+    // Retrieve the initial state from localStorage, default to true if not found
+    const [open, setOpen] = useLocalStorage(`dataServiceComponent-${id}-open`, true);
 
-    if (displayName !== '') {
+    const sortedEntries = useSortedEntries(props);
+
+    if (displayName !== "") {
       return (
         <div className="component dataServiceComponent" id={id}>
           <Card>
-            <Card.Header onClick={() => setOpen(!open)} style={{ cursor: 'pointer' }}>
+            <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]) => (
+                {sortedEntries.map((value) => (
                   <GenericComponent
-                    key={key}
+                    key={value.full_access_path}
                     attribute={value}
-                    name={key}
-                    parentPath={fullAccessPath}
                     isInstantUpdate={isInstantUpdate}
                     addNotification={addNotification}
                   />
@@ -57,12 +49,10 @@ export const DataServiceComponent = React.memo(
     } else {
       return (
         <div className="component dataServiceComponent" id={id}>
-          {Object.entries(props).map(([key, value]) => (
+          {sortedEntries.map((value) => (
             <GenericComponent
-              key={key}
+              key={value.full_access_path}
               attribute={value}
-              name={key}
-              parentPath={fullAccessPath}
               isInstantUpdate={isInstantUpdate}
               addNotification={addNotification}
             />
@@ -70,5 +60,7 @@ export const DataServiceComponent = React.memo(
         </div>
       );
     }
-  }
+  },
 );
+
+DataServiceComponent.displayName = "DataServiceComponent";

frontend/src/components/DeviceConnection.tsx

@@ -1,55 +1,48 @@
-import React from 'react';
-import { LevelName } from './NotificationsComponent';
-import { DataServiceComponent, DataServiceJSON } from './DataServiceComponent';
-import { MethodComponent } from './MethodComponent';
+import React from "react";
+import { LevelName } from "./NotificationsComponent";
+import { DataServiceComponent, DataServiceJSON } from "./DataServiceComponent";
+import { MethodComponent } from "./MethodComponent";
 
-type DeviceConnectionProps = {
-  name: string;
+interface DeviceConnectionProps {
+  fullAccessPath: string;
   props: DataServiceJSON;
-  parentPath: string;
   isInstantUpdate: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
   displayName: string;
   id: string;
-};
+}
 
 export const DeviceConnectionComponent = React.memo(
   ({
-    name,
+    fullAccessPath,
     props,
-    parentPath,
     isInstantUpdate,
     addNotification,
     displayName,
-    id
+    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!
+              {displayName != "" ? displayName : "Device"} is currently not available!
             </div>
             <MethodComponent
-              name="connect"
-              parentPath={fullAccessPath}
+              fullAccessPath={`${fullAccessPath}.connect`}
               docString={connect.doc}
               addNotification={addNotification}
-              displayName={'reconnect'}
-              id={id + '-connect'}
+              displayName={"reconnect"}
+              id={id + "-connect"}
               render={true}
             />
           </div>
         )}
         <DataServiceComponent
-          name={name}
           props={updatedProps}
-          parentPath={parentPath}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
           displayName={displayName}
@@ -57,5 +50,7 @@ export const DeviceConnectionComponent = React.memo(
         />
       </div>
     );
-  }
+  },
 );
+
+DeviceConnectionComponent.displayName = "DeviceConnectionComponent";

frontend/src/components/DictComponent.tsx

@@ -0,0 +1,41 @@
+import React from "react";
+import { DocStringComponent } from "./DocStringComponent";
+import { GenericComponent } from "./GenericComponent";
+import { LevelName } from "./NotificationsComponent";
+import { SerializedObject } from "../types/SerializedObject";
+import useRenderCount from "../hooks/useRenderCount";
+import useSortedEntries from "../hooks/useSortedEntries";
+
+interface DictComponentProps {
+  value: Record<string, SerializedObject>;
+  docString: string | null;
+  isInstantUpdate: boolean;
+  addNotification: (message: string, levelname?: LevelName) => void;
+  id: string;
+}
+
+export const DictComponent = React.memo((props: DictComponentProps) => {
+  const { docString, isInstantUpdate, addNotification, id } = props;
+
+  const sortedEntries = useSortedEntries(props.value);
+  const renderCount = useRenderCount();
+
+  return (
+    <div className={"listComponent"} id={id}>
+      {process.env.NODE_ENV === "development" && <div>Render count: {renderCount}</div>}
+      <DocStringComponent docString={docString} />
+      {sortedEntries.map((item) => {
+        return (
+          <GenericComponent
+            key={item.full_access_path}
+            attribute={item}
+            isInstantUpdate={isInstantUpdate}
+            addNotification={addNotification}
+          />
+        );
+      })}
+    </div>
+  );
+});
+
+DictComponent.displayName = "DictComponent";

frontend/src/components/DocStringComponent.tsx

@@ -1,9 +1,9 @@
-import { Badge, Tooltip, OverlayTrigger } from 'react-bootstrap';
-import React from 'react';
+import { Badge, Tooltip, OverlayTrigger } from "react-bootstrap";
+import React from "react";
 
-type DocStringProps = {
-  docString?: string;
-};
+interface DocStringProps {
+  docString?: string | null;
+}
 
 export const DocStringComponent = React.memo((props: DocStringProps) => {
   const { docString } = props;
@@ -21,3 +21,5 @@ export const DocStringComponent = React.memo((props: DocStringProps) => {
     </OverlayTrigger>
   );
 });
+
+DocStringComponent.displayName = "DocStringComponent";

frontend/src/components/EnumComponent.tsx

@@ -1,69 +1,40 @@
-import React, { useEffect, useRef, useState } from 'react';
-import { InputGroup, Form, Row, Col } from 'react-bootstrap';
-import { DocStringComponent } from './DocStringComponent';
-import { LevelName } from './NotificationsComponent';
+import React, { useEffect } from "react";
+import { InputGroup, Form, Row, Col } from "react-bootstrap";
+import { DocStringComponent } from "./DocStringComponent";
+import { LevelName } from "./NotificationsComponent";
+import { SerializedObject, SerializedEnum } from "../types/SerializedObject";
+import { propsAreEqual } from "../utils/propsAreEqual";
+import useRenderCount from "../hooks/useRenderCount";
 
-type EnumComponentProps = {
-  name: string;
-  parentPath: string;
-  value: string;
-  docString?: string;
-  readOnly: boolean;
-  enumDict: Record<string, string>;
+interface EnumComponentProps extends SerializedEnum {
   addNotification: (message: string, levelname?: LevelName) => void;
-  changeCallback?: (
-    value: unknown,
-    attributeName?: string,
-    prefix?: string,
-    callback?: (ack: unknown) => void
-  ) => void;
   displayName: string;
   id: string;
-};
+  changeCallback: (value: SerializedObject, callback?: (ack: unknown) => void) => void;
+}
 
 export const EnumComponent = React.memo((props: EnumComponentProps) => {
   const {
-    name,
-    value,
-    docString,
-    enumDict,
     addNotification,
     displayName,
     id,
-    readOnly
+    value,
+    full_access_path: fullAccessPath,
+    enum: enumDict,
+    doc: docString,
+    readonly: readOnly,
+    changeCallback,
   } = 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('.');
+  const renderCount = useRenderCount();
 
   useEffect(() => {
-    renderCount.current++;
-  });
-
-  useEffect(() => {
-    setEnumValue(() => {
-      return props.value;
-    });
     addNotification(`${fullAccessPath} changed to ${value}.`);
-  }, [props.value]);
+  }, [value]);
 
   return (
-    <div className={'component enumComponent'} id={id}>
-      {process.env.NODE_ENV === 'development' && (
-        <div>Render count: {renderCount.current}</div>
-      )}
+    <div className={"component enumComponent"} id={id}>
+      {process.env.NODE_ENV === "development" && <div>Render count: {renderCount}</div>}
       <Row>
         <Col className="d-flex align-items-center">
           <InputGroup.Text>
@@ -73,17 +44,37 @@ export const EnumComponent = React.memo((props: EnumComponentProps) => {
 
           {readOnly ? (
             // Display the Form.Control when readOnly is true
-            <Form.Control value={enumDict[enumValue]} name={name} disabled={true} />
+            <Form.Control
+              style={
+                props.type == "ColouredEnum" ? { backgroundColor: enumDict[value] } : {}
+              }
+              value={props.type == "ColouredEnum" ? value : enumDict[value]}
+              name={fullAccessPath}
+              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)}>
+              value={value}
+              name={fullAccessPath}
+              style={
+                props.type == "ColouredEnum" ? { backgroundColor: enumDict[value] } : {}
+              }
+              onChange={(event) =>
+                changeCallback({
+                  type: props.type,
+                  name: props.name,
+                  enum: enumDict,
+                  value: event.target.value,
+                  full_access_path: fullAccessPath,
+                  readonly: props.readonly,
+                  doc: props.doc,
+                })
+              }>
               {Object.entries(enumDict).map(([key, val]) => (
                 <option key={key} value={key}>
-                  {val}
+                  {props.type == "ColouredEnum" ? key : val}
                 </option>
               ))}
             </Form.Select>
@@ -92,4 +83,6 @@ export const EnumComponent = React.memo((props: EnumComponentProps) => {
       </Row>
     </div>
   );
-});
+}, propsAreEqual);
+
+EnumComponent.displayName = "EnumComponent";

frontend/src/components/GenericComponent.tsx

@@ -1,66 +1,67 @@
-import React, { useContext } from 'react';
-import { ButtonComponent } from './ButtonComponent';
-import { NumberComponent } from './NumberComponent';
-import { SliderComponent } from './SliderComponent';
-import { EnumComponent } from './EnumComponent';
-import { MethodComponent } from './MethodComponent';
-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';
+import React, { useContext } from "react";
+import { ButtonComponent } from "./ButtonComponent";
+import { NumberComponent, NumberObject } from "./NumberComponent";
+import { SliderComponent } from "./SliderComponent";
+import { EnumComponent } from "./EnumComponent";
+import { MethodComponent } from "./MethodComponent";
+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 { LevelName } from "./NotificationsComponent";
+import { getIdFromFullAccessPath } from "../utils/stringUtils";
+import { WebSettingsContext } from "../WebSettings";
+import { updateValue } from "../socket";
+import { DictComponent } from "./DictComponent";
+import { parseFullAccessPath } from "../utils/stateUtils";
+import { SerializedEnum, SerializedObject } from "../types/SerializedObject";
 
-type AttributeType =
-  | 'str'
-  | 'bool'
-  | 'float'
-  | 'int'
-  | 'Quantity'
-  | 'list'
-  | 'method'
-  | 'DataService'
-  | 'DeviceConnection'
-  | 'Enum'
-  | 'NumberSlider'
-  | 'Image'
-  | 'ColouredEnum';
-
-type ValueType = boolean | string | number | Record<string, unknown>;
-export type SerializedValue = {
-  type: AttributeType;
-  value?: ValueType | ValueType[];
-  readonly: boolean;
-  doc?: string | null;
-  async?: boolean;
-  frontend_render?: boolean;
-  enum?: Record<string, string>;
-};
-type GenericComponentProps = {
-  attribute: SerializedValue;
-  name: string;
-  parentPath: string;
+interface GenericComponentProps {
+  attribute: SerializedObject;
   isInstantUpdate: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
+}
+
+const getPathFromPathParts = (pathParts: string[]): string => {
+  let path = "";
+  for (const pathPart of pathParts) {
+    if (!pathPart.startsWith("[") && path !== "") {
+      path += ".";
+    }
+    path += pathPart;
+  }
+  return path;
 };
 
+const createDisplayNameFromAccessPath = (fullAccessPath: string): string => {
+  const displayNameParts = [];
+  const parsedFullAccessPath = parseFullAccessPath(fullAccessPath);
+  for (let i = parsedFullAccessPath.length - 1; i >= 0; i--) {
+    const item = parsedFullAccessPath[i];
+    displayNameParts.unshift(item);
+    if (!item.startsWith("[")) {
+      break;
+    }
+  }
+  return getPathFromPathParts(displayNameParts);
+};
+
+function changeCallback(
+  value: SerializedObject,
+  callback: (ack: unknown) => void = () => {},
+) {
+  updateValue(value, callback);
+}
+
 export const GenericComponent = React.memo(
-  ({
-    attribute,
-    name,
-    parentPath,
-    isInstantUpdate,
-    addNotification
-  }: GenericComponentProps) => {
-    const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
+  ({ attribute, isInstantUpdate, addNotification }: GenericComponentProps) => {
+    const { full_access_path: fullAccessPath } = attribute;
     const id = getIdFromFullAccessPath(fullAccessPath);
     const webSettings = useContext(WebSettingsContext);
-    let displayName = name;
+
+    let displayName = createDisplayNameFromAccessPath(fullAccessPath);
 
     if (webSettings[fullAccessPath]) {
       if (webSettings[fullAccessPath].display === false) {
@@ -71,20 +72,10 @@ export const GenericComponent = React.memo(
       }
     }
 
-    function changeCallback(
-      value: unknown,
-      attributeName: string = name,
-      prefix: string = parentPath,
-      callback: (ack: unknown) => void = undefined
-    ) {
-      setAttribute(attributeName, prefix, value, callback);
-    }
-
-    if (attribute.type === 'bool') {
+    if (attribute.type === "bool") {
       return (
         <ButtonComponent
-          name={name}
-          parentPath={parentPath}
+          fullAccessPath={fullAccessPath}
           docString={attribute.doc}
           readOnly={attribute.readonly}
           value={Boolean(attribute.value)}
@@ -94,12 +85,11 @@ export const GenericComponent = React.memo(
           id={id}
         />
       );
-    } else if (attribute.type === 'float' || attribute.type === 'int') {
+    } else if (attribute.type === "float" || attribute.type === "int") {
       return (
         <NumberComponent
-          name={name}
           type={attribute.type}
-          parentPath={parentPath}
+          fullAccessPath={fullAccessPath}
           docString={attribute.doc}
           readOnly={attribute.readonly}
           value={Number(attribute.value)}
@@ -110,16 +100,15 @@ export const GenericComponent = React.memo(
           id={id}
         />
       );
-    } else if (attribute.type === 'Quantity') {
+    } else if (attribute.type === "Quantity") {
       return (
         <NumberComponent
-          name={name}
-          type="float"
-          parentPath={parentPath}
+          type="Quantity"
+          fullAccessPath={fullAccessPath}
           docString={attribute.doc}
           readOnly={attribute.readonly}
-          value={Number(attribute.value['magnitude'])}
-          unit={attribute.value['unit']}
+          value={Number(attribute.value["magnitude"])}
+          unit={attribute.value["unit"]}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
           changeCallback={changeCallback}
@@ -127,17 +116,16 @@ export const GenericComponent = React.memo(
           id={id}
         />
       );
-    } else if (attribute.type === 'NumberSlider') {
+    } else if (attribute.type === "NumberSlider") {
       return (
         <SliderComponent
-          name={name}
-          parentPath={parentPath}
-          docString={attribute.value['value'].doc}
+          fullAccessPath={fullAccessPath}
+          docString={attribute.value["value"].doc}
           readOnly={attribute.readonly}
-          value={attribute.value['value']}
-          min={attribute.value['min']}
-          max={attribute.value['max']}
-          stepSize={attribute.value['step_size']}
+          value={attribute.value["value"] as NumberObject}
+          min={attribute.value["min"] as NumberObject}
+          max={attribute.value["max"] as NumberObject}
+          stepSize={attribute.value["step_size"] as NumberObject}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
           changeCallback={changeCallback}
@@ -145,27 +133,21 @@ export const GenericComponent = React.memo(
           id={id}
         />
       );
-    } else if (attribute.type === 'Enum') {
+    } else if (attribute.type === "Enum" || attribute.type === "ColouredEnum") {
       return (
         <EnumComponent
-          name={name}
-          parentPath={parentPath}
-          docString={attribute.doc}
-          value={String(attribute.value)}
-          readOnly={attribute.readonly}
-          enumDict={attribute.enum}
+          {...(attribute as SerializedEnum)}
           addNotification={addNotification}
           changeCallback={changeCallback}
           displayName={displayName}
           id={id}
         />
       );
-    } else if (attribute.type === 'method') {
+    } else if (attribute.type === "method") {
       if (!attribute.async) {
         return (
           <MethodComponent
-            name={name}
-            parentPath={parentPath}
+            fullAccessPath={fullAccessPath}
             docString={attribute.doc}
             addNotification={addNotification}
             displayName={displayName}
@@ -176,10 +158,9 @@ export const GenericComponent = React.memo(
       } else {
         return (
           <AsyncMethodComponent
-            name={name}
-            parentPath={parentPath}
+            fullAccessPath={fullAccessPath}
             docString={attribute.doc}
-            value={attribute.value as Record<string, string>}
+            value={attribute.value as "RUNNING" | null}
             addNotification={addNotification}
             displayName={displayName}
             id={id}
@@ -187,14 +168,13 @@ export const GenericComponent = React.memo(
           />
         );
       }
-    } else if (attribute.type === 'str') {
+    } else if (attribute.type === "str") {
       return (
         <StringComponent
-          name={name}
+          fullAccessPath={fullAccessPath}
           value={attribute.value as string}
           readOnly={attribute.readonly}
           docString={attribute.doc}
-          parentPath={parentPath}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
           changeCallback={changeCallback}
@@ -202,73 +182,63 @@ export const GenericComponent = React.memo(
           id={id}
         />
       );
-    } else if (attribute.type === 'DataService') {
+    } else if (attribute.type === "DataService") {
       return (
         <DataServiceComponent
-          name={name}
           props={attribute.value as DataServiceJSON}
-          parentPath={parentPath}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
           displayName={displayName}
           id={id}
         />
       );
-    } else if (attribute.type === 'DeviceConnection') {
+    } else if (attribute.type === "DeviceConnection") {
       return (
         <DeviceConnectionComponent
-          name={name}
+          fullAccessPath={fullAccessPath}
           props={attribute.value as DataServiceJSON}
-          parentPath={parentPath}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
           displayName={displayName}
           id={id}
         />
       );
-    } else if (attribute.type === 'list') {
+    } else if (attribute.type === "list") {
       return (
         <ListComponent
-          name={name}
-          value={attribute.value as SerializedValue[]}
+          value={attribute.value}
           docString={attribute.doc}
-          parentPath={parentPath}
           isInstantUpdate={isInstantUpdate}
           addNotification={addNotification}
           id={id}
         />
       );
-    } else if (attribute.type === 'Image') {
+    } else if (attribute.type === "dict") {
       return (
-        <ImageComponent
-          name={name}
-          parentPath={parentPath}
-          docString={attribute.value['value'].doc}
-          displayName={displayName}
-          id={id}
+        <DictComponent
+          value={attribute.value}
+          docString={attribute.doc}
+          isInstantUpdate={isInstantUpdate}
           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}
+          id={id}
         />
       );
-    } else if (attribute.type === 'ColouredEnum') {
+    } else if (attribute.type === "Image") {
       return (
-        <ColouredEnumComponent
-          name={name}
-          parentPath={parentPath}
-          docString={attribute.doc}
-          value={String(attribute.value)}
-          readOnly={attribute.readonly}
-          enumDict={attribute.enum}
-          addNotification={addNotification}
-          changeCallback={changeCallback}
+        <ImageComponent
+          fullAccessPath={fullAccessPath}
+          docString={attribute.value["value"].doc}
           displayName={displayName}
           id={id}
+          addNotification={addNotification}
+          value={attribute.value["value"]["value"] as string}
+          format={attribute.value["format"]["value"] as string}
         />
       );
     } else {
-      return <div key={name}>{name}</div>;
+      return <div key={fullAccessPath}>{fullAccessPath}</div>;
     }
-  }
+  },
 );
+
+GenericComponent.displayName = "GenericComponent";

frontend/src/components/ImageComponent.tsx

@@ -1,32 +1,26 @@
-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 { LevelName } from './NotificationsComponent';
+import React, { useEffect, useState } from "react";
+import { Card, Collapse, Image } from "react-bootstrap";
+import { DocStringComponent } from "./DocStringComponent";
+import { ChevronDown, ChevronRight } from "react-bootstrap-icons";
+import { LevelName } from "./NotificationsComponent";
+import useRenderCount from "../hooks/useRenderCount";
 
-type ImageComponentProps = {
-  name: string;
-  parentPath: string;
+interface ImageComponentProps {
+  fullAccessPath: string;
   value: string;
-  docString: string;
+  docString: string | null;
   format: string;
   addNotification: (message: string, levelname?: LevelName) => void;
   displayName: string;
   id: string;
-};
+}
 
 export const ImageComponent = React.memo((props: ImageComponentProps) => {
-  const { value, docString, format, addNotification, displayName, id } = props;
+  const { fullAccessPath, value, docString, format, addNotification, displayName, id } =
+    props;
 
-  const renderCount = useRef(0);
+  const renderCount = useRenderCount();
   const [open, setOpen] = useState(true);
-  const fullAccessPath = [props.parentPath, props.name]
-    .filter((element) => element)
-    .join('.');
-
-  useEffect(() => {
-    renderCount.current++;
-  });
 
   useEffect(() => {
     addNotification(`${fullAccessPath} changed.`);
@@ -37,7 +31,7 @@ export const ImageComponent = React.memo((props: ImageComponentProps) => {
       <Card>
         <Card.Header
           onClick={() => setOpen(!open)}
-          style={{ cursor: 'pointer' }} // Change cursor style on hover
+          style={{ cursor: "pointer" }} // Change cursor style on hover
         >
           {displayName}
           <DocStringComponent docString={docString} />
@@ -45,10 +39,10 @@ export const ImageComponent = React.memo((props: ImageComponentProps) => {
         </Card.Header>
         <Collapse in={open}>
           <Card.Body>
-            {process.env.NODE_ENV === 'development' && (
-              <p>Render count: {renderCount.current}</p>
+            {process.env.NODE_ENV === "development" && (
+              <p>Render count: {renderCount}</p>
             )}
-            {format === '' && value === '' ? (
+            {format === "" && value === "" ? (
               <p>No image set in the backend.</p>
             ) : (
               <Image src={`data:image/${format.toLowerCase()};base64,${value}`}></Image>
@@ -59,3 +53,5 @@ export const ImageComponent = React.memo((props: ImageComponentProps) => {
     </div>
   );
 });
+
+ImageComponent.displayName = "ImageComponent";

frontend/src/components/ListComponent.tsx

@@ -1,41 +1,35 @@
-import React, { useEffect, useRef } from 'react';
-import { DocStringComponent } from './DocStringComponent';
-import { SerializedValue, GenericComponent } from './GenericComponent';
-import { LevelName } from './NotificationsComponent';
+import React from "react";
+import { DocStringComponent } from "./DocStringComponent";
+import { GenericComponent } from "./GenericComponent";
+import { LevelName } from "./NotificationsComponent";
+import { SerializedObject } from "../types/SerializedObject";
+import useRenderCount from "../hooks/useRenderCount";
+import useSortedEntries from "../hooks/useSortedEntries";
 
-type ListComponentProps = {
-  name: string;
-  parentPath?: string;
-  value: SerializedValue[];
-  docString: string;
+interface ListComponentProps {
+  value: SerializedObject[];
+  docString: string | null;
   isInstantUpdate: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
   id: string;
-};
+}
 
 export const ListComponent = React.memo((props: ListComponentProps) => {
-  const { name, parentPath, value, docString, isInstantUpdate, addNotification, id } =
-    props;
+  const { docString, isInstantUpdate, addNotification, id } = props;
 
-  const renderCount = useRef(0);
+  const sortedEntries = useSortedEntries(props.value);
 
-  useEffect(() => {
-    renderCount.current++;
-  }, [props]);
+  const renderCount = useRenderCount();
 
   return (
-    <div className={'listComponent'} id={id}>
-      {process.env.NODE_ENV === 'development' && (
-        <div>Render count: {renderCount.current}</div>
-      )}
+    <div className={"listComponent"} id={id}>
+      {process.env.NODE_ENV === "development" && <div>Render count: {renderCount}</div>}
       <DocStringComponent docString={docString} />
-      {value.map((item, index) => {
+      {sortedEntries.map((item) => {
         return (
           <GenericComponent
-            key={`${name}[${index}]`}
+            key={item.full_access_path}
             attribute={item}
-            name={`${name}[${index}]`}
-            parentPath={parentPath}
             isInstantUpdate={isInstantUpdate}
             addNotification={addNotification}
           />
@@ -44,3 +38,5 @@ export const ListComponent = React.memo((props: ListComponentProps) => {
     </div>
   );
 });
+
+ListComponent.displayName = "ListComponent";

frontend/src/components/MethodComponent.tsx

@@ -1,30 +1,30 @@
-import React, { useEffect, useRef } from 'react';
-import { runMethod } from '../socket';
-import { Button, Form } from 'react-bootstrap';
-import { DocStringComponent } from './DocStringComponent';
-import { LevelName } from './NotificationsComponent';
+import React, { useRef } from "react";
+import { runMethod } from "../socket";
+import { Button, Form } from "react-bootstrap";
+import { DocStringComponent } from "./DocStringComponent";
+import { LevelName } from "./NotificationsComponent";
+import useRenderCount from "../hooks/useRenderCount";
+import { propsAreEqual } from "../utils/propsAreEqual";
 
-type MethodProps = {
-  name: string;
-  parentPath: string;
-  docString?: string;
+interface MethodProps {
+  fullAccessPath: string;
+  docString: string | null;
   addNotification: (message: string, levelname?: LevelName) => void;
   displayName: string;
   id: string;
   render: boolean;
-};
+}
 
 export const MethodComponent = React.memo((props: MethodProps) => {
-  const { name, parentPath, docString, addNotification, displayName, id } = props;
+  const { fullAccessPath, docString, addNotification, displayName, id } = props;
 
   // Conditional rendering based on the 'render' prop.
   if (!props.render) {
     return null;
   }
 
-  const renderCount = useRef(0);
+  const renderCount = useRenderCount();
   const formRef = useRef(null);
-  const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
 
   const triggerNotification = () => {
     const message = `Method ${fullAccessPath} was triggered.`;
@@ -34,20 +34,14 @@ export const MethodComponent = React.memo((props: MethodProps) => {
 
   const execute = async (event: React.FormEvent) => {
     event.preventDefault();
-    runMethod(name, parentPath, {});
+    runMethod(fullAccessPath);
 
     triggerNotification();
   };
 
-  useEffect(() => {
-    renderCount.current++;
-  });
-
   return (
     <div className="component methodComponent" id={id}>
-      {process.env.NODE_ENV === 'development' && (
-        <div>Render count: {renderCount.current}</div>
-      )}
+      {process.env.NODE_ENV === "development" && <div>Render count: {renderCount}</div>}
       <Form onSubmit={execute} ref={formRef}>
         <Button className="component" variant="primary" type="submit">
           {`${displayName} `}
@@ -56,4 +50,6 @@ export const MethodComponent = React.memo((props: MethodProps) => {
       </Form>
     </div>
   );
-});
+}, propsAreEqual);
+
+MethodComponent.displayName = "MethodComponent";

frontend/src/components/NotificationsComponent.tsx

@@ -1,19 +1,19 @@
-import React from 'react';
-import { ToastContainer, Toast } from 'react-bootstrap';
+import React from "react";
+import { ToastContainer, Toast } from "react-bootstrap";
 
-export type LevelName = 'CRITICAL' | 'ERROR' | 'WARNING' | 'INFO' | 'DEBUG';
-export type Notification = {
+export type LevelName = "CRITICAL" | "ERROR" | "WARNING" | "INFO" | "DEBUG";
+export interface Notification {
   id: number;
   timeStamp: string;
   message: string;
   levelname: LevelName;
-};
+}
 
-type NotificationProps = {
+interface NotificationProps {
   showNotification: boolean;
   notifications: Notification[];
   removeNotificationById: (id: number) => void;
-};
+}
 
 export const Notifications = React.memo((props: NotificationProps) => {
   const { showNotification, notifications, removeNotificationById } = props;
@@ -23,10 +23,10 @@ export const Notifications = React.memo((props: NotificationProps) => {
       {notifications.map((notification) => {
         // Determine if the toast should be shown
         const shouldShow =
-          notification.levelname === 'ERROR' ||
-          notification.levelname === 'CRITICAL' ||
+          notification.levelname === "ERROR" ||
+          notification.levelname === "CRITICAL" ||
           (showNotification &&
-            ['WARNING', 'INFO', 'DEBUG'].includes(notification.levelname));
+            ["WARNING", "INFO", "DEBUG"].includes(notification.levelname));
 
         if (!shouldShow) {
           return null;
@@ -34,31 +34,31 @@ export const Notifications = React.memo((props: NotificationProps) => {
 
         return (
           <Toast
-            className={notification.levelname.toLowerCase() + 'Toast'}
+            className={notification.levelname.toLowerCase() + "Toast"}
             key={notification.id}
             onClose={() => removeNotificationById(notification.id)}
             onClick={() => removeNotificationById(notification.id)}
             onMouseLeave={() => {
-              if (notification.levelname !== 'ERROR') {
+              if (notification.levelname !== "ERROR") {
                 removeNotificationById(notification.id);
               }
             }}
             show={true}
             autohide={
-              notification.levelname === 'WARNING' ||
-              notification.levelname === 'INFO' ||
-              notification.levelname === 'DEBUG'
+              notification.levelname === "WARNING" ||
+              notification.levelname === "INFO" ||
+              notification.levelname === "DEBUG"
             }
             delay={
-              notification.levelname === 'WARNING' ||
-              notification.levelname === 'INFO' ||
-              notification.levelname === 'DEBUG'
+              notification.levelname === "WARNING" ||
+              notification.levelname === "INFO" ||
+              notification.levelname === "DEBUG"
                 ? 2000
                 : undefined
             }>
             <Toast.Header
               closeButton={false}
-              className={notification.levelname.toLowerCase() + 'Toast text-right'}>
+              className={notification.levelname.toLowerCase() + "Toast text-right"}>
               <strong className="me-auto">{notification.levelname}</strong>
               <small>{notification.timeStamp}</small>
             </Toast.Header>
@@ -69,3 +69,5 @@ export const Notifications = React.memo((props: NotificationProps) => {
     </ToastContainer>
   );
 });
+
+Notifications.displayName = "Notifications";

frontend/src/components/NumberComponent.tsx

@@ -1,64 +1,58 @@
-import React, { useEffect, useState, useRef } from 'react';
-import { Form, InputGroup } from 'react-bootstrap';
-import { DocStringComponent } from './DocStringComponent';
-import '../App.css';
-import { LevelName } from './NotificationsComponent';
+import React, { useEffect, useState } from "react";
+import { Form, InputGroup } from "react-bootstrap";
+import { DocStringComponent } from "./DocStringComponent";
+import "../App.css";
+import { LevelName } from "./NotificationsComponent";
+import { SerializedObject } from "../types/SerializedObject";
+import { QuantityMap } from "../types/QuantityMap";
+import useRenderCount from "../hooks/useRenderCount";
 
 // TODO: add button functionality
 
-export type QuantityObject = {
-  type: 'Quantity';
+export interface QuantityObject {
+  type: "Quantity";
   readonly: boolean;
-  value: {
-    magnitude: number;
-    unit: string;
-  };
-  doc?: string;
-};
-export type IntObject = {
-  type: 'int';
+  value: QuantityMap;
+  doc: string | null;
+}
+export interface IntObject {
+  type: "int";
   readonly: boolean;
   value: number;
-  doc?: string;
-};
-export type FloatObject = {
-  type: 'float';
+  doc: string | null;
+}
+export interface FloatObject {
+  type: "float";
   readonly: boolean;
   value: number;
-  doc?: string;
-};
+  doc: string | null;
+}
 export type NumberObject = IntObject | FloatObject | QuantityObject;
 
-type NumberComponentProps = {
-  name: string;
-  type: 'float' | 'int';
-  parentPath?: string;
+interface NumberComponentProps {
+  type: "float" | "int" | "Quantity";
+  fullAccessPath: string;
   value: number;
   readOnly: boolean;
-  docString: string;
+  docString: string | null;
   isInstantUpdate: boolean;
   unit?: string;
   addNotification: (message: string, levelname?: LevelName) => void;
-  changeCallback?: (
-    value: unknown,
-    attributeName?: string,
-    prefix?: string,
-    callback?: (ack: unknown) => void
-  ) => void;
+  changeCallback?: (value: SerializedObject, callback?: (ack: unknown) => void) => void;
   displayName?: string;
   id: string;
-};
+}
 
 // TODO: highlight the digit that is being changed by setting both selectionStart and
 // selectionEnd
 const handleArrowKey = (
   key: string,
   value: string,
-  selectionStart: number
+  selectionStart: number,
   // selectionEnd: number
 ) => {
   // Split the input value into the integer part and decimal part
-  const parts = value.split('.');
+  const parts = value.split(".");
   const beforeDecimalCount = parts[0].length; // Count digits before the decimal
   const afterDecimalCount = parts[1] ? parts[1].length : 0; // Count digits after the decimal
 
@@ -74,14 +68,14 @@ const handleArrowKey = (
 
   // Convert the input value to a number, increment or decrement it based on the
   // arrow key
-  const numValue = parseFloat(value) + (key === 'ArrowUp' ? increment : -increment);
+  const numValue = parseFloat(value) + (key === "ArrowUp" ? increment : -increment);
 
   // Convert the resulting number to a string, maintaining the same number of digits
   // after the decimal
   const newValue = numValue.toFixed(afterDecimalCount);
 
   // Check if the length of the integer part of the number string has in-/decreased
-  const newBeforeDecimalCount = newValue.split('.')[0].length;
+  const newBeforeDecimalCount = newValue.split(".")[0].length;
   if (newBeforeDecimalCount > beforeDecimalCount) {
     // Move the cursor one position to the right
     selectionStart += 1;
@@ -95,18 +89,18 @@ const handleArrowKey = (
 const handleBackspaceKey = (
   value: string,
   selectionStart: number,
-  selectionEnd: number
+  selectionEnd: number,
 ) => {
   if (selectionEnd > selectionStart) {
     // If there is a selection, delete all characters in the selection
     return {
       value: value.slice(0, selectionStart) + value.slice(selectionEnd),
-      selectionStart
+      selectionStart,
     };
   } else if (selectionStart > 0) {
     return {
       value: value.slice(0, selectionStart - 1) + value.slice(selectionStart),
-      selectionStart: selectionStart - 1
+      selectionStart: selectionStart - 1,
     };
   }
   return { value, selectionStart };
@@ -115,18 +109,18 @@ const handleBackspaceKey = (
 const handleDeleteKey = (
   value: string,
   selectionStart: number,
-  selectionEnd: number
+  selectionEnd: number,
 ) => {
   if (selectionEnd > selectionStart) {
     // If there is a selection, delete all characters in the selection
     return {
       value: value.slice(0, selectionStart) + value.slice(selectionEnd),
-      selectionStart
+      selectionStart,
     };
   } else if (selectionStart < value.length) {
     return {
       value: value.slice(0, selectionStart) + value.slice(selectionStart + 1),
-      selectionStart
+      selectionStart,
     };
   }
   return { value, selectionStart };
@@ -136,12 +130,12 @@ const handleNumericKey = (
   key: string,
   value: string,
   selectionStart: number,
-  selectionEnd: number
+  selectionEnd: number,
 ) => {
   // Check if a number key or a decimal point key is pressed
-  if (key === '.' && value.includes('.')) {
+  if (key === "." && value.includes(".")) {
     // Check if value already contains a decimal. If so, ignore input.
-    console.warn('Invalid input! Ignoring...');
+    console.warn("Invalid input! Ignoring...");
     return { value, selectionStart };
   }
 
@@ -161,7 +155,7 @@ const handleNumericKey = (
 
 export const NumberComponent = React.memo((props: NumberComponentProps) => {
   const {
-    name,
+    fullAccessPath,
     value,
     readOnly,
     type,
@@ -171,88 +165,110 @@ export const NumberComponent = React.memo((props: NumberComponentProps) => {
     addNotification,
     changeCallback = () => {},
     displayName,
-    id
+    id,
   } = props;
 
   // Create a state for the cursor position
-  const [cursorPosition, setCursorPosition] = useState(null);
+  const [cursorPosition, setCursorPosition] = useState<number | null>(null);
   // Create a state for the input string
   const [inputString, setInputString] = useState(value.toString());
-  const renderCount = useRef(0);
-  const fullAccessPath = [props.parentPath, props.name]
-    .filter((element) => element)
-    .join('.');
+  const renderCount = useRenderCount();
 
-  const handleKeyDown = (event) => {
+  const handleKeyDown = (event: React.KeyboardEvent<HTMLInputElement>) => {
     const { key, target } = event;
+
+    // Typecast
+    const inputTarget = target as HTMLInputElement;
     if (
-      key === 'F1' ||
-      key === 'F5' ||
-      key === 'F12' ||
-      key === 'Tab' ||
-      key === 'ArrowRight' ||
-      key === 'ArrowLeft'
+      key === "F1" ||
+      key === "F5" ||
+      key === "F12" ||
+      key === "Tab" ||
+      key === "ArrowRight" ||
+      key === "ArrowLeft"
     ) {
       return;
     }
     event.preventDefault();
 
     // Get the current input value and cursor position
-    const { value } = target;
-    let { selectionStart } = target;
-    const { selectionEnd } = target;
+    const { value } = inputTarget;
+    const selectionEnd = inputTarget.selectionEnd ?? 0;
+    let selectionStart = inputTarget.selectionStart ?? 0;
 
     let newValue: string = value;
-    if (event.ctrlKey && key === 'a') {
+    if (event.ctrlKey && key === "a") {
       // Select everything when pressing Ctrl + a
-      target.setSelectionRange(0, target.value.length);
+      inputTarget.setSelectionRange(0, value.length);
       return;
-    } else if (key === '-') {
-      if (selectionStart === 0 && !value.startsWith('-')) {
-        newValue = '-' + value;
+    } else if (key === "-") {
+      if (selectionStart === 0 && !value.startsWith("-")) {
+        newValue = "-" + value;
         selectionStart++;
-      } else if (value.startsWith('-') && selectionStart === 1) {
+      } else if (value.startsWith("-") && selectionStart === 1) {
         newValue = value.substring(1); // remove minus sign
         selectionStart--;
       } else {
         return; // Ignore "-" pressed in other positions
       }
-    } else if (!isNaN(key) && key !== ' ') {
+    } else if (key >= "0" && key <= "9") {
       // Check if a number key or a decimal point key is pressed
       ({ value: newValue, selectionStart } = handleNumericKey(
         key,
         value,
         selectionStart,
-        selectionEnd
+        selectionEnd,
       ));
-    } else if (key === '.' && type === 'float') {
+    } else if (key === "." && (type === "float" || type === "Quantity")) {
       ({ value: newValue, selectionStart } = handleNumericKey(
         key,
         value,
         selectionStart,
-        selectionEnd
+        selectionEnd,
       ));
-    } else if (key === 'ArrowUp' || key === 'ArrowDown') {
+    } else if (key === "ArrowUp" || key === "ArrowDown") {
       ({ value: newValue, selectionStart } = handleArrowKey(
         key,
         value,
-        selectionStart
+        selectionStart,
         // selectionEnd
       ));
-    } else if (key === 'Backspace') {
+    } else if (key === "Backspace") {
       ({ value: newValue, selectionStart } = handleBackspaceKey(
         value,
         selectionStart,
-        selectionEnd
+        selectionEnd,
       ));
-    } else if (key === 'Delete') {
+    } else if (key === "Delete") {
       ({ value: newValue, selectionStart } = handleDeleteKey(
         value,
         selectionStart,
-        selectionEnd
+        selectionEnd,
       ));
-    } else if (key === 'Enter' && !isInstantUpdate) {
-      changeCallback(Number(newValue));
+    } else if (key === "Enter" && !isInstantUpdate) {
+      let serializedObject: SerializedObject;
+      if (type === "Quantity") {
+        serializedObject = {
+          type: "Quantity",
+          value: {
+            magnitude: Number(newValue),
+            unit: unit,
+          } as QuantityMap,
+          full_access_path: fullAccessPath,
+          readonly: readOnly,
+          doc: docString,
+        };
+      } else {
+        serializedObject = {
+          type: type,
+          value: Number(newValue),
+          full_access_path: fullAccessPath,
+          readonly: readOnly,
+          doc: docString,
+        };
+      }
+
+      changeCallback(serializedObject);
       return;
     } else {
       console.debug(key);
@@ -261,7 +277,29 @@ export const NumberComponent = React.memo((props: NumberComponentProps) => {
 
     // Update the input value and maintain the cursor position
     if (isInstantUpdate) {
-      changeCallback(Number(newValue));
+      let serializedObject: SerializedObject;
+      if (type === "Quantity") {
+        serializedObject = {
+          type: "Quantity",
+          value: {
+            magnitude: Number(newValue),
+            unit: unit,
+          } as QuantityMap,
+          full_access_path: fullAccessPath,
+          readonly: readOnly,
+          doc: docString,
+        };
+      } else {
+        serializedObject = {
+          type: type,
+          value: Number(newValue),
+          full_access_path: fullAccessPath,
+          readonly: readOnly,
+          doc: docString,
+        };
+      }
+
+      changeCallback(serializedObject);
     }
 
     setInputString(newValue);
@@ -273,13 +311,35 @@ 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
-      changeCallback(Number(inputString));
+      let serializedObject: SerializedObject;
+      if (type === "Quantity") {
+        serializedObject = {
+          type: "Quantity",
+          value: {
+            magnitude: Number(inputString),
+            unit: unit,
+          } as QuantityMap,
+          full_access_path: fullAccessPath,
+          readonly: readOnly,
+          doc: docString,
+        };
+      } else {
+        serializedObject = {
+          type: type,
+          value: Number(inputString),
+          full_access_path: fullAccessPath,
+          readonly: readOnly,
+          doc: docString,
+        };
+      }
+
+      changeCallback(serializedObject);
     }
   };
   useEffect(() => {
     // Parse the input string to a number for comparison
     const numericInputString =
-      type === 'int' ? parseInt(inputString) : parseFloat(inputString);
+      type === "int" ? parseInt(inputString) : parseFloat(inputString);
     // Only update the inputString if it's different from the prop value
     if (value !== numericInputString) {
       setInputString(value.toString());
@@ -288,7 +348,7 @@ export const NumberComponent = React.memo((props: NumberComponentProps) => {
     // emitting notification
     let notificationMsg = `${fullAccessPath} changed to ${props.value}`;
     if (unit === undefined) {
-      notificationMsg += '.';
+      notificationMsg += ".";
     } else {
       notificationMsg += ` ${unit}.`;
     }
@@ -297,7 +357,7 @@ export const NumberComponent = React.memo((props: NumberComponentProps) => {
 
   useEffect(() => {
     // Set the cursor position after the component re-renders
-    const inputElement = document.getElementsByName(name)[0] as HTMLInputElement;
+    const inputElement = document.getElementsByName(id)[0] as HTMLInputElement;
     if (inputElement && cursorPosition !== null) {
       inputElement.setSelectionRange(cursorPosition, cursorPosition);
     }
@@ -305,9 +365,7 @@ export const NumberComponent = React.memo((props: NumberComponentProps) => {
 
   return (
     <div className="component numberComponent" id={id}>
-      {process.env.NODE_ENV === 'development' && (
-        <div>Render count: {renderCount.current}</div>
-      )}
+      {process.env.NODE_ENV === "development" && <div>Render count: {renderCount}</div>}
       <InputGroup>
         {displayName && (
           <InputGroup.Text>
@@ -319,13 +377,16 @@ export const NumberComponent = React.memo((props: NumberComponentProps) => {
           type="text"
           value={inputString}
           disabled={readOnly}
-          name={name}
+          onChange={() => {}}
+          name={id}
           onKeyDown={handleKeyDown}
           onBlur={handleBlur}
-          className={isInstantUpdate && !readOnly ? 'instantUpdate' : ''}
+          className={isInstantUpdate && !readOnly ? "instantUpdate" : ""}
         />
         {unit && <InputGroup.Text>{unit}</InputGroup.Text>}
       </InputGroup>
     </div>
   );
 });
+
+NumberComponent.displayName = "NumberComponent";

frontend/src/components/SliderComponent.tsx

@@ -1,37 +1,51 @@
-import React, { useEffect, useRef, useState } from 'react';
-import { InputGroup, Form, Row, Col, Collapse, ToggleButton } from 'react-bootstrap';
-import { DocStringComponent } from './DocStringComponent';
-import { Slider } from '@mui/material';
-import { NumberComponent, NumberObject } from './NumberComponent';
-import { LevelName } from './NotificationsComponent';
+import React, { useEffect, useState } from "react";
+import { InputGroup, Form, Row, Col, Collapse, ToggleButton } from "react-bootstrap";
+import { DocStringComponent } from "./DocStringComponent";
+import { Slider } from "@mui/material";
+import { NumberComponent, NumberObject } from "./NumberComponent";
+import { LevelName } from "./NotificationsComponent";
+import { SerializedObject } from "../types/SerializedObject";
+import { QuantityMap } from "../types/QuantityMap";
+import { propsAreEqual } from "../utils/propsAreEqual";
+import useRenderCount from "../hooks/useRenderCount";
 
-type SliderComponentProps = {
-  name: string;
+interface SliderComponentProps {
+  fullAccessPath: string;
   min: NumberObject;
   max: NumberObject;
-  parentPath?: string;
   value: NumberObject;
   readOnly: boolean;
-  docString: string;
+  docString: string | null;
   stepSize: NumberObject;
   isInstantUpdate: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
-  changeCallback?: (
-    value: unknown,
-    attributeName?: string,
-    prefix?: string,
-    callback?: (ack: unknown) => void
-  ) => void;
+  changeCallback?: (value: SerializedObject, callback?: (ack: unknown) => void) => void;
   displayName: string;
   id: string;
+}
+
+const deconstructNumberDict = (
+  numberDict: NumberObject,
+): [number, boolean, string | undefined] => {
+  let numberMagnitude = 0;
+  let numberUnit: string | undefined = undefined;
+  const numberReadOnly = numberDict.readonly;
+
+  if (numberDict.type === "int" || numberDict.type === "float") {
+    numberMagnitude = numberDict.value;
+  } else if (numberDict.type === "Quantity") {
+    numberMagnitude = numberDict.value.magnitude;
+    numberUnit = numberDict.value.unit;
+  }
+
+  return [numberMagnitude, numberReadOnly, numberUnit];
 };
 
 export const SliderComponent = React.memo((props: SliderComponentProps) => {
-  const renderCount = useRef(0);
+  const renderCount = useRenderCount();
   const [open, setOpen] = useState(false);
   const {
-    name,
-    parentPath,
+    fullAccessPath,
     value,
     min,
     max,
@@ -41,58 +55,83 @@ export const SliderComponent = React.memo((props: SliderComponentProps) => {
     addNotification,
     changeCallback = () => {},
     displayName,
-    id
+    id,
   } = props;
-  const fullAccessPath = [parentPath, name].filter((element) => element).join('.');
-
-  useEffect(() => {
-    renderCount.current++;
-  });
 
   useEffect(() => {
     addNotification(`${fullAccessPath} changed to ${value.value}.`);
-  }, [props.value]);
+  }, [props.value.value]);
 
   useEffect(() => {
     addNotification(`${fullAccessPath}.min changed to ${min.value}.`);
-  }, [props.min]);
+  }, [props.min.value, props.min.type]);
 
   useEffect(() => {
     addNotification(`${fullAccessPath}.max changed to ${max.value}.`);
-  }, [props.max]);
+  }, [props.max.value, props.max.type]);
 
   useEffect(() => {
     addNotification(`${fullAccessPath}.stepSize changed to ${stepSize.value}.`);
-  }, [props.stepSize]);
+  }, [props.stepSize.value, props.stepSize.type]);
 
-  const handleOnChange = (event, newNumber: number | number[]) => {
+  const handleOnChange = (_: Event, newNumber: number | number[]) => {
     // This will never be the case as we do not have a range slider. However, we should
     // make sure this is properly handled.
     if (Array.isArray(newNumber)) {
       newNumber = newNumber[0];
     }
-    changeCallback(newNumber, `${name}.value`);
-  };
 
-  const handleValueChange = (newValue: number, valueType: string) => {
-    changeCallback(newValue, `${name}.${valueType}`);
-  };
-
-  const deconstructNumberDict = (
-    numberDict: NumberObject
-  ): [number, boolean, string | null] => {
-    let numberMagnitude: number;
-    let numberUnit: string | null = null;
-    const numberReadOnly = numberDict.readonly;
-
-    if (numberDict.type === 'int' || numberDict.type === 'float') {
-      numberMagnitude = numberDict.value;
-    } else if (numberDict.type === 'Quantity') {
-      numberMagnitude = numberDict.value.magnitude;
-      numberUnit = numberDict.value.unit;
+    let serializedObject: SerializedObject;
+    if (value.type === "Quantity") {
+      serializedObject = {
+        type: "Quantity",
+        value: {
+          magnitude: newNumber,
+          unit: value.value.unit,
+        } as QuantityMap,
+        full_access_path: `${fullAccessPath}.value`,
+        readonly: value.readonly,
+        doc: docString,
+      };
+    } else {
+      serializedObject = {
+        type: value.type,
+        value: newNumber,
+        full_access_path: `${fullAccessPath}.value`,
+        readonly: value.readonly,
+        doc: docString,
+      };
     }
+    changeCallback(serializedObject);
+  };
 
-    return [numberMagnitude, numberReadOnly, numberUnit];
+  const handleValueChange = (
+    newValue: number,
+    name: string,
+    valueObject: NumberObject,
+  ) => {
+    let serializedObject: SerializedObject;
+    if (valueObject.type === "Quantity") {
+      serializedObject = {
+        type: valueObject.type,
+        value: {
+          magnitude: newValue,
+          unit: valueObject.value.unit,
+        } as QuantityMap,
+        full_access_path: `${fullAccessPath}.${name}`,
+        readonly: valueObject.readonly,
+        doc: null,
+      };
+    } else {
+      serializedObject = {
+        type: valueObject.type,
+        value: newValue,
+        full_access_path: `${fullAccessPath}.${name}`,
+        readonly: valueObject.readonly,
+        doc: null,
+      };
+    }
+    changeCallback(serializedObject);
   };
 
   const [valueMagnitude, valueReadOnly, valueUnit] = deconstructNumberDict(value);
@@ -102,9 +141,7 @@ export const SliderComponent = React.memo((props: SliderComponentProps) => {
 
   return (
     <div className="component sliderComponent" id={id}>
-      {process.env.NODE_ENV === 'development' && (
-        <div>Render count: {renderCount.current}</div>
-      )}
+      {process.env.NODE_ENV === "development" && <div>Render count: {renderCount}</div>}
 
       <Row>
         <Col xs="auto" xl="auto">
@@ -115,7 +152,7 @@ export const SliderComponent = React.memo((props: SliderComponentProps) => {
         </Col>
         <Col xs="5" xl>
           <Slider
-            style={{ margin: '0px 0px 10px 0px' }}
+            style={{ margin: "0px 0px 10px 0px" }}
             aria-label="Always visible"
             // valueLabelDisplay="on"
             disabled={valueReadOnly}
@@ -126,23 +163,22 @@ export const SliderComponent = React.memo((props: SliderComponentProps) => {
             step={stepSizeMagnitude}
             marks={[
               { value: minMagnitude, label: `${minMagnitude}` },
-              { value: maxMagnitude, label: `${maxMagnitude}` }
+              { value: maxMagnitude, label: `${maxMagnitude}` },
             ]}
           />
         </Col>
         <Col xs="3" xl>
           <NumberComponent
             isInstantUpdate={isInstantUpdate}
-            parentPath={parentPath}
-            name={`${name}.value`}
-            docString=""
+            fullAccessPath={`${fullAccessPath}.value`}
+            docString={docString}
             readOnly={valueReadOnly}
-            type="float"
+            type={value.type}
             value={valueMagnitude}
             unit={valueUnit}
             addNotification={() => {}}
-            changeCallback={(value) => changeCallback(value, name + '.value')}
-            id={id + '-value'}
+            changeCallback={changeCallback}
+            id={id + "-value"}
           />
         </Col>
         <Col xs="auto">
@@ -172,14 +208,14 @@ export const SliderComponent = React.memo((props: SliderComponentProps) => {
         <Form.Group>
           <Row
             className="justify-content-center"
-            style={{ paddingTop: '20px', margin: '10px' }}>
+            style={{ paddingTop: "20px", margin: "10px" }}>
             <Col xs="auto">
               <Form.Label>Min Value</Form.Label>
               <Form.Control
                 type="number"
                 value={minMagnitude}
                 disabled={minReadOnly}
-                onChange={(e) => handleValueChange(Number(e.target.value), 'min')}
+                onChange={(e) => handleValueChange(Number(e.target.value), "min", min)}
               />
             </Col>
 
@@ -189,7 +225,7 @@ export const SliderComponent = React.memo((props: SliderComponentProps) => {
                 type="number"
                 value={maxMagnitude}
                 disabled={maxReadOnly}
-                onChange={(e) => handleValueChange(Number(e.target.value), 'max')}
+                onChange={(e) => handleValueChange(Number(e.target.value), "max", max)}
               />
             </Col>
 
@@ -199,7 +235,9 @@ export const SliderComponent = React.memo((props: SliderComponentProps) => {
                 type="number"
                 value={stepSizeMagnitude}
                 disabled={stepSizeReadOnly}
-                onChange={(e) => handleValueChange(Number(e.target.value), 'step_size')}
+                onChange={(e) =>
+                  handleValueChange(Number(e.target.value), "step_size", stepSize)
+                }
               />
             </Col>
           </Row>
@@ -207,4 +245,6 @@ export const SliderComponent = React.memo((props: SliderComponentProps) => {
       </Collapse>
     </div>
   );
-});
+}, propsAreEqual);
+
+SliderComponent.displayName = "SliderComponent";

frontend/src/components/StringComponent.tsx

@@ -1,50 +1,39 @@
-import React, { useEffect, useRef, useState } from 'react';
-import { Form, InputGroup } from 'react-bootstrap';
-import { DocStringComponent } from './DocStringComponent';
-import '../App.css';
-import { LevelName } from './NotificationsComponent';
+import React, { useEffect, useState } from "react";
+import { Form, InputGroup } from "react-bootstrap";
+import { DocStringComponent } from "./DocStringComponent";
+import "../App.css";
+import { LevelName } from "./NotificationsComponent";
+import { SerializedObject } from "../types/SerializedObject";
+import useRenderCount from "../hooks/useRenderCount";
 
 // TODO: add button functionality
 
-type StringComponentProps = {
-  name: string;
-  parentPath?: string;
+interface StringComponentProps {
+  fullAccessPath: string;
   value: string;
   readOnly: boolean;
-  docString: string;
+  docString: string | null;
   isInstantUpdate: boolean;
   addNotification: (message: string, levelname?: LevelName) => void;
-  changeCallback?: (
-    value: unknown,
-    attributeName?: string,
-    prefix?: string,
-    callback?: (ack: unknown) => void
-  ) => void;
+  changeCallback?: (value: SerializedObject, callback?: (ack: unknown) => void) => void;
   displayName: string;
   id: string;
-};
+}
 
 export const StringComponent = React.memo((props: StringComponentProps) => {
   const {
-    name,
+    fullAccessPath,
     readOnly,
     docString,
     isInstantUpdate,
     addNotification,
     changeCallback = () => {},
     displayName,
-    id
+    id,
   } = props;
 
-  const renderCount = useRef(0);
+  const renderCount = useRenderCount();
   const [inputString, setInputString] = useState(props.value);
-  const fullAccessPath = [props.parentPath, props.name]
-    .filter((element) => element)
-    .join('.');
-
-  useEffect(() => {
-    renderCount.current++;
-  }, [isInstantUpdate, inputString, renderCount]);
 
   useEffect(() => {
     // Only update the inputString if it's different from the prop value
@@ -54,31 +43,47 @@ export const StringComponent = React.memo((props: StringComponentProps) => {
     addNotification(`${fullAccessPath} changed to ${props.value}.`);
   }, [props.value]);
 
-  const handleChange = (event) => {
+  const handleChange = (event: React.ChangeEvent<HTMLInputElement>) => {
     setInputString(event.target.value);
     if (isInstantUpdate) {
-      changeCallback(event.target.value);
+      changeCallback({
+        type: "str",
+        value: event.target.value,
+        full_access_path: fullAccessPath,
+        readonly: readOnly,
+        doc: docString,
+      });
     }
   };
 
-  const handleKeyDown = (event) => {
-    if (event.key === 'Enter' && !isInstantUpdate) {
-      changeCallback(inputString);
+  const handleKeyDown = (event: React.KeyboardEvent<HTMLInputElement>) => {
+    if (event.key === "Enter" && !isInstantUpdate) {
+      changeCallback({
+        type: "str",
+        value: inputString,
+        full_access_path: fullAccessPath,
+        readonly: readOnly,
+        doc: docString,
+      });
       event.preventDefault();
     }
   };
 
   const handleBlur = () => {
     if (!isInstantUpdate) {
-      changeCallback(inputString);
+      changeCallback({
+        type: "str",
+        value: inputString,
+        full_access_path: fullAccessPath,
+        readonly: readOnly,
+        doc: docString,
+      });
     }
   };
 
   return (
     <div className="component stringComponent" id={id}>
-      {process.env.NODE_ENV === 'development' && (
-        <div>Render count: {renderCount.current}</div>
-      )}
+      {process.env.NODE_ENV === "development" && <div>Render count: {renderCount}</div>}
       <InputGroup>
         <InputGroup.Text>
           {displayName}
@@ -86,15 +91,17 @@ export const StringComponent = React.memo((props: StringComponentProps) => {
         </InputGroup.Text>
         <Form.Control
           type="text"
-          name={name}
+          name={id}
           value={inputString}
           disabled={readOnly}
           onChange={handleChange}
           onKeyDown={handleKeyDown}
           onBlur={handleBlur}
-          className={isInstantUpdate && !readOnly ? 'instantUpdate' : ''}
+          className={isInstantUpdate && !readOnly ? "instantUpdate" : ""}
         />
       </InputGroup>
     </div>
   );
 });
+
+StringComponent.displayName = "StringComponent";

frontend/src/hooks/useLocalStorage.ts

@@ -0,0 +1,18 @@
+import { useState, useEffect } from "react";
+
+export default function useLocalStorage(key: string, defaultValue: unknown) {
+  const [value, setValue] = useState(() => {
+    const storedValue = localStorage.getItem(key);
+    if (storedValue) {
+      return JSON.parse(storedValue);
+    }
+    return defaultValue;
+  });
+
+  useEffect(() => {
+    if (value === undefined) return;
+    localStorage.setItem(key, JSON.stringify(value));
+  }, [value, key]);
+
+  return [value, setValue];
+}

frontend/src/hooks/useRenderCount.ts

@@ -0,0 +1,11 @@
+import { useRef, useEffect } from "react";
+
+export default function useRenderCount() {
+  const count = useRef(0);
+
+  useEffect(() => {
+    count.current += 1;
+  });
+
+  return count.current;
+}

frontend/src/hooks/useSortedEntries.ts

@@ -0,0 +1,28 @@
+import { useContext } from "react";
+import { WebSettingsContext } from "../WebSettings";
+import { SerializedObject } from "../types/SerializedObject";
+
+export default function useSortedEntries(
+  props: Record<string, SerializedObject> | SerializedObject[],
+) {
+  const webSettings = useContext(WebSettingsContext);
+
+  // Get the order for sorting
+  const getOrder = (fullAccessPath: string) => {
+    return webSettings[fullAccessPath]?.displayOrder ?? Number.MAX_SAFE_INTEGER;
+  };
+
+  // Sort entries based on whether props is an array or an object
+  let sortedEntries;
+  if (Array.isArray(props)) {
+    // Need to make copy of array to leave the original array unmodified
+    sortedEntries = [...props].sort((objectA, objectB) => {
+      return getOrder(objectA.full_access_path) - getOrder(objectB.full_access_path);
+    });
+  } else {
+    sortedEntries = Object.values(props).sort((objectA, objectB) => {
+      return getOrder(objectA.full_access_path) - getOrder(objectB.full_access_path);
+    });
+  }
+  return sortedEntries;
+}

frontend/src/index.tsx

@@ -1,10 +1,13 @@
-import App from './App';
-import { createRoot } from 'react-dom/client';
+import App from "./App";
+import React from "react";
+import ReactDOM from "react-dom/client";
 
 // Importing the Bootstrap CSS
-import 'bootstrap/dist/css/bootstrap.min.css';
+import "bootstrap/dist/css/bootstrap.min.css";
 
 // Render the App component into the #root div
-const container = document.getElementById('root');
-const root = createRoot(container);
-root.render(<App />);
+ReactDOM.createRoot(document.getElementById("root")!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);

frontend/src/socket.ts

@@ -1,36 +1,54 @@
-import { io } from 'socket.io-client';
+import { io } from "socket.io-client";
+import { serializeDict, serializeList } from "./utils/serializationUtils";
+import { SerializedObject } from "./types/SerializedObject";
 
 export const hostname =
-  process.env.NODE_ENV === 'development' ? `localhost` : window.location.hostname;
+  process.env.NODE_ENV === "development" ? `localhost` : window.location.hostname;
 export const port =
-  process.env.NODE_ENV === 'development' ? 8001 : window.location.port;
+  process.env.NODE_ENV === "development" ? 8001 : window.location.port;
 const URL = `ws://${hostname}:${port}/`;
-console.debug('Websocket: ', URL);
+console.debug("Websocket: ", URL);
 
-export const socket = io(URL, { path: '/ws/socket.io', transports: ['websocket'] });
+export const socket = io(URL, { path: "/ws/socket.io", transports: ["websocket"] });
 
-export const setAttribute = (
-  name: string,
-  parentPath: string,
-  value: unknown,
-  callback?: (ack: unknown) => void
+export const updateValue = (
+  serializedObject: SerializedObject,
+  callback?: (ack: unknown) => void,
 ) => {
   if (callback) {
-    socket.emit('set_attribute', { name, parent_path: parentPath, value }, callback);
+    socket.emit(
+      "update_value",
+      { access_path: serializedObject["full_access_path"], value: serializedObject },
+      callback,
+    );
   } else {
-    socket.emit('set_attribute', { name, parent_path: parentPath, value });
+    socket.emit("update_value", {
+      access_path: serializedObject["full_access_path"],
+      value: serializedObject,
+    });
   }
 };
 
 export const runMethod = (
-  name: string,
-  parentPath: string,
-  kwargs: Record<string, unknown>,
-  callback?: (ack: unknown) => void
+  accessPath: string,
+  args: unknown[] = [],
+  kwargs: Record<string, unknown> = {},
+  callback?: (ack: unknown) => void,
 ) => {
+  const serializedArgs = serializeList(args);
+  const serializedKwargs = serializeDict(kwargs);
+
   if (callback) {
-    socket.emit('run_method', { name, parent_path: parentPath, kwargs }, callback);
+    socket.emit(
+      "trigger_method",
+      { access_path: accessPath, args: serializedArgs, kwargs: serializedKwargs },
+      callback,
+    );
   } else {
-    socket.emit('run_method', { name, parent_path: parentPath, kwargs });
+    socket.emit("trigger_method", {
+      access_path: accessPath,
+      args: serializedArgs,
+      kwargs: serializedKwargs,
+    });
   }
 };

frontend/src/types/QuantityMap.ts

@@ -0,0 +1,4 @@
+export interface QuantityMap {
+  magnitude: number;
+  unit: string;
+}

frontend/src/types/SerializedObject.ts

@@ -0,0 +1,101 @@
+import { QuantityMap } from "./QuantityMap";
+
+interface SignatureDict {
+  parameters: Record<string, Record<string, unknown>>;
+  return_annotation: Record<string, unknown>;
+}
+
+interface SerializedObjectBase {
+  full_access_path: string;
+  doc: string | null;
+  readonly: boolean;
+}
+
+type SerializedInteger = SerializedObjectBase & {
+  value: number;
+  type: "int";
+};
+
+type SerializedFloat = SerializedObjectBase & {
+  value: number;
+  type: "float";
+};
+
+type SerializedQuantity = SerializedObjectBase & {
+  value: QuantityMap;
+  type: "Quantity";
+};
+
+type SerializedBool = SerializedObjectBase & {
+  value: boolean;
+  type: "bool";
+};
+
+type SerializedString = SerializedObjectBase & {
+  value: string;
+  type: "str";
+};
+
+export type SerializedEnum = SerializedObjectBase & {
+  name: string;
+  value: string;
+  type: "Enum" | "ColouredEnum";
+  enum: Record<string, string>;
+};
+
+type SerializedList = SerializedObjectBase & {
+  value: SerializedObject[];
+  type: "list";
+};
+
+type SerializedDict = SerializedObjectBase & {
+  value: Record<string, SerializedObject>;
+  type: "dict";
+};
+
+type SerializedNoneType = SerializedObjectBase & {
+  value: null;
+  type: "NoneType";
+};
+
+type SerializedNoValue = SerializedObjectBase & {
+  value: null;
+  type: "None";
+};
+
+type SerializedMethod = SerializedObjectBase & {
+  value: "RUNNING" | null;
+  type: "method";
+  async: boolean;
+  signature: SignatureDict;
+  frontend_render: boolean;
+};
+
+type SerializedException = SerializedObjectBase & {
+  name: string;
+  value: string;
+  type: "Exception";
+};
+
+type DataServiceTypes = "DataService" | "Image" | "NumberSlider" | "DeviceConnection";
+
+type SerializedDataService = SerializedObjectBase & {
+  name: string;
+  value: Record<string, SerializedObject>;
+  type: DataServiceTypes;
+};
+
+export type SerializedObject =
+  | SerializedBool
+  | SerializedFloat
+  | SerializedInteger
+  | SerializedString
+  | SerializedList
+  | SerializedDict
+  | SerializedNoneType
+  | SerializedMethod
+  | SerializedException
+  | SerializedDataService
+  | SerializedEnum
+  | SerializedQuantity
+  | SerializedNoValue;

frontend/src/utils/propsAreEqual.ts

@@ -0,0 +1,17 @@
+import deepEqual from "deep-equal";
+
+export const propsAreEqual = <T extends object>(
+  prevProps: T,
+  nextProps: T,
+): boolean => {
+  for (const key in nextProps) {
+    if (typeof nextProps[key] === "object") {
+      if (!deepEqual(prevProps[key], nextProps[key])) {
+        return false;
+      }
+    } else if (!Object.is(prevProps[key], nextProps[key])) {
+      return false;
+    }
+  }
+  return true;
+};

frontend/src/utils/serializationUtils.ts

@@ -0,0 +1,97 @@
+import { SerializedObject } from "../types/SerializedObject";
+
+const serializePrimitive = (
+  obj: number | boolean | string | null,
+  accessPath: string,
+): SerializedObject => {
+  if (typeof obj === "number") {
+    return {
+      full_access_path: accessPath,
+      doc: null,
+      readonly: false,
+      type: Number.isInteger(obj) ? "int" : "float",
+      value: obj,
+    };
+  } else if (typeof obj === "boolean") {
+    return {
+      full_access_path: accessPath,
+      doc: null,
+      readonly: false,
+      type: "bool",
+      value: obj,
+    };
+  } else if (typeof obj === "string") {
+    return {
+      full_access_path: accessPath,
+      doc: null,
+      readonly: false,
+      type: "str",
+      value: obj,
+    };
+  } else if (obj === null) {
+    return {
+      full_access_path: accessPath,
+      doc: null,
+      readonly: false,
+      type: "None",
+      value: null,
+    };
+  } else {
+    throw new Error("Unsupported type for serialization");
+  }
+};
+
+export const serializeList = (obj: unknown[], accessPath = "") => {
+  const doc = null;
+  const value = obj.map((item, index) => {
+    if (
+      typeof item === "number" ||
+      typeof item === "boolean" ||
+      typeof item === "string" ||
+      item === null
+    ) {
+      serializePrimitive(
+        item as number | boolean | string | null,
+        `${accessPath}[${index}]`,
+      );
+    }
+  });
+
+  return {
+    full_access_path: accessPath,
+    type: "list",
+    value,
+    readonly: false,
+    doc,
+  };
+};
+export const serializeDict = (obj: Record<string, unknown>, accessPath = "") => {
+  const doc = null;
+  const value = Object.entries(obj).reduce(
+    (acc, [key, val]) => {
+      // Construct the new access path for nested properties
+      const newPath = `${accessPath}["${key}"]`;
+
+      // Serialize each value in the dictionary and assign to the accumulator
+      if (
+        typeof val === "number" ||
+        typeof val === "boolean" ||
+        typeof val === "string" ||
+        val === null
+      ) {
+        acc[key] = serializePrimitive(val as number | boolean | string | null, newPath);
+      }
+
+      return acc;
+    },
+    {} as Record<string, SerializedObject>,
+  );
+
+  return {
+    full_access_path: accessPath,
+    type: "dict",
+    value,
+    readonly: false,
+    doc,
+  };
+};

frontend/src/utils/stateUtils.ts

@@ -1,107 +1,175 @@
-import { SerializedValue } from '../components/GenericComponent';
+import { SerializedObject } from "../types/SerializedObject";
 
-export type State = {
+export interface State {
   type: string;
-  value: Record<string, SerializedValue> | null;
+  name: string;
+  value: Record<string, SerializedObject> | null;
   readonly: boolean;
   doc: string | null;
-};
+}
 
-export function setNestedValueByPath(
-  serializationDict: Record<string, SerializedValue>,
-  path: string,
-  serializedValue: SerializedValue
-): Record<string, SerializedValue> {
-  const parentPathParts = path.split('.').slice(0, -1);
-  const attrName = path.split('.').pop();
+/**
+ * Splits a full access path into its atomic parts, separating attribute names, numeric
+ * indices (including floating points), and string keys within indices.
+ *
+ * @param path The full access path string to be split into components.
+ * @returns An array of components that make up the path, including attribute names,
+ *          numeric indices, and string keys as separate elements.
+ */
+export function parseFullAccessPath(path: string): string[] {
+  // The pattern matches:
+  // \w+ - Words
+  // \[\d+\.\d+\] - Floating point numbers inside brackets
+  // \[\d+\] - Integers inside brackets
+  // \["[^"]*"\] - Double-quoted strings inside brackets
+  // \['[^']*'\] - Single-quoted strings inside brackets
+  const pattern = /\w+|\[\d+\.\d+\]|\[\d+\]|\["[^"]*"\]|\['[^']*'\]/g;
+  const matches = path.match(pattern);
 
-  if (!attrName) {
-    throw new Error('Invalid path');
+  return matches ?? []; // Return an empty array if no matches found
+}
+
+/**
+ * Parse a serialized key and convert it to an appropriate type (number or string).
+ *
+ * @param serializedKey The serialized key, which might be enclosed in brackets and quotes.
+ * @returns The processed key as a number or an unquoted string.
+ *
+ * Examples:
+ * console.log(parseSerializedKey("attr_name"));  // Outputs: attr_name  (string)
+ * console.log(parseSerializedKey("[123]"));      // Outputs: 123  (number)
+ * console.log(parseSerializedKey("[12.3]"));     // Outputs: 12.3  (number)
+ * console.log(parseSerializedKey("['hello']"));  // Outputs: hello  (string)
+ * console.log(parseSerializedKey('["12.34"]'));  // Outputs: "12.34"  (string)
+ * console.log(parseSerializedKey('["complex"]'));// Outputs: "complex"  (string)
+ */
+function parseSerializedKey(serializedKey: string): string | number {
+  // Strip outer brackets if present
+  if (serializedKey.startsWith("[") && serializedKey.endsWith("]")) {
+    serializedKey = serializedKey.slice(1, -1);
   }
 
-  let currentSerializedValue: SerializedValue;
-  const newSerializationDict: Record<string, SerializedValue> = JSON.parse(
-    JSON.stringify(serializationDict)
+  // Strip quotes if the resulting string is quoted
+  if (
+    (serializedKey.startsWith("'") && serializedKey.endsWith("'")) ||
+    (serializedKey.startsWith('"') && serializedKey.endsWith('"'))
+  ) {
+    return serializedKey.slice(1, -1);
+  }
+
+  // Try converting to a number if the string is not quoted
+  const parsedNumber = parseFloat(serializedKey);
+  if (!isNaN(parsedNumber)) {
+    return parsedNumber;
+  }
+
+  // Return the original string if it's not a valid number
+  return serializedKey;
+}
+
+function getOrCreateItemInContainer(
+  container: Record<string | number, SerializedObject> | SerializedObject[],
+  key: string | number,
+  allowAddKey: boolean,
+): SerializedObject {
+  // Check if the key exists and return the item if it does
+  if (key in container) {
+    /* @ts-expect-error Key is in the correct form but converted to type any for some reason */
+    return container[key];
+  }
+
+  // Handling the case where the key does not exist
+  if (Array.isArray(container)) {
+    // Handling arrays
+    if (allowAddKey && key === container.length) {
+      container.push(createEmptySerializedObject());
+      return container[key];
+    }
+    throw new Error(`Index out of bounds: ${key}`);
+  } else {
+    // Handling objects
+    if (allowAddKey) {
+      container[key] = createEmptySerializedObject();
+      return container[key];
+    }
+    throw new Error(`Key not found: ${key}`);
+  }
+}
+
+/**
+ * Retrieve an item from a container specified by the passed key. Add an item to the
+ * container if allowAppend is set to True.
+ *
+ * @param container Either a dictionary or list of serialized objects.
+ * @param key The key name or index (as a string) representing the attribute in the container.
+ * @param allowAppend Whether to allow appending a new entry if the specified index is out of range by exactly one position.
+ * @returns The serialized object corresponding to the specified key.
+ * @throws SerializationPathError If the key is invalid or leads to an access error without append permissions.
+ * @throws SerializationValueError If the expected structure is incorrect.
+ */
+function getContainerItemByKey(
+  container: Record<string, SerializedObject> | SerializedObject[],
+  key: string,
+  allowAppend = false,
+): SerializedObject {
+  const processedKey = parseSerializedKey(key);
+
+  try {
+    return getOrCreateItemInContainer(container, processedKey, allowAppend);
+  } catch (error) {
+    if (error instanceof RangeError) {
+      throw new Error(`Index '${processedKey}': ${error.message}`);
+    } else if (error instanceof Error) {
+      throw new Error(`Key '${processedKey}': ${error.message}`);
+    }
+    throw error; // Re-throw if it's not a known error type
+  }
+}
+
+export function setNestedValueByPath(
+  serializationDict: Record<string, SerializedObject>,
+  path: string,
+  serializedValue: SerializedObject,
+): Record<string, SerializedObject> {
+  const pathParts = parseFullAccessPath(path);
+  const newSerializationDict: Record<string, SerializedObject> = JSON.parse(
+    JSON.stringify(serializationDict),
   );
 
   let currentDict = newSerializationDict;
 
   try {
-    for (const pathPart of parentPathParts) {
-      currentSerializedValue = getNextLevelDictByKey(currentDict, pathPart, false);
-      // @ts-expect-error The value will be of type SerializedValue as we are still
-      // looping through the parent parts
-      currentDict = currentSerializedValue['value'];
+    for (let i = 0; i < pathParts.length - 1; i++) {
+      const pathPart = pathParts[i];
+      const nextLevelSerializedObject = getContainerItemByKey(
+        currentDict,
+        pathPart,
+        false,
+      );
+      currentDict = nextLevelSerializedObject["value"] as Record<
+        string,
+        SerializedObject
+      >;
     }
 
-    currentSerializedValue = getNextLevelDictByKey(currentDict, attrName, true);
+    const finalPart = pathParts[pathParts.length - 1];
+    const finalObject = getContainerItemByKey(currentDict, finalPart, true);
+
+    Object.assign(finalObject, serializedValue);
 
-    Object.assign(currentSerializedValue, serializedValue);
     return newSerializationDict;
   } catch (error) {
-    console.error(error);
-    return currentDict;
+    console.error(`Error occurred trying to change ${path}: ${error}`);
   }
+  return {};
 }
 
-function getNextLevelDictByKey(
-  serializationDict: Record<string, SerializedValue>,
-  attrName: string,
-  allowAppend: boolean = false
-): SerializedValue {
-  const [key, index] = parseListAttrAndIndex(attrName);
-  let currentDict: SerializedValue;
-
-  try {
-    if (index !== null) {
-      if (!serializationDict[key] || !Array.isArray(serializationDict[key]['value'])) {
-        throw new Error(`Expected an array at '${key}', but found something else.`);
-      }
-
-      if (index < serializationDict[key]['value'].length) {
-        currentDict = serializationDict[key]['value'][index];
-      } else if (allowAppend && index === serializationDict[key]['value'].length) {
-        // Appending to list
-        // @ts-expect-error When the index is not null, I expect an array
-        serializationDict[key]['value'].push({});
-        currentDict = serializationDict[key]['value'][index];
-      } else {
-        throw new Error(`Index out of range for '${key}[${index}]'.`);
-      }
-    } else {
-      if (!serializationDict[key]) {
-        throw new Error(`Key '${key}' not found.`);
-      }
-      currentDict = serializationDict[key];
-    }
-  } catch (error) {
-    throw new Error(`Error occurred trying to access '${attrName}': ${error}`);
-  }
-
-  if (typeof currentDict !== 'object' || currentDict === null) {
-    throw new Error(
-      `Expected a dictionary at '${attrName}', but found type '${typeof currentDict}' instead.`
-    );
-  }
-
-  return currentDict;
-}
-
-function parseListAttrAndIndex(attrString: string): [string, number | null] {
-  let index: number | null = null;
-  let attrName = attrString;
-
-  if (attrString.includes('[') && attrString.endsWith(']')) {
-    const parts = attrString.split('[');
-    attrName = parts[0];
-    const indexPart = parts[1].slice(0, -1); // Removes the closing ']'
-
-    if (!isNaN(parseInt(indexPart))) {
-      index = parseInt(indexPart);
-    } else {
-      console.error(`Invalid index format in key: ${attrString}`);
-    }
-  }
-
-  return [attrName, index];
+function createEmptySerializedObject(): SerializedObject {
+  return {
+    full_access_path: "",
+    value: null,
+    type: "None",
+    doc: null,
+    readonly: false,
+  };
 }

frontend/src/utils/stringUtils.ts

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

frontend/tsconfig.app.json

@@ -0,0 +1,31 @@
+{
+    "compilerOptions": {
+        "composite": true,
+        "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+        "target": "ES2020",
+        "useDefineForClassFields": true,
+        "lib": [
+            "ES2020",
+            "DOM",
+            "DOM.Iterable"
+        ],
+        "module": "ESNext",
+        "skipLibCheck": true,
+        /* Bundler mode */
+        "moduleResolution": "bundler",
+        "allowImportingTsExtensions": true,
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "moduleDetection": "force",
+        "noEmit": true,
+        "jsx": "react-jsx",
+        /* Linting */
+        "strict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noFallthroughCasesInSwitch": true
+    },
+    "include": [
+        "src"
+    ]
+}

frontend/tsconfig.json

@@ -1,8 +1,11 @@
 {
-    "compilerOptions": {
-        "jsx": "react-jsx",
-        "allowImportingTsExtensions": true,
-        "noEmit": true,
-        "esModuleInterop": true
-    }
+    "files": [],
+    "references": [
+        {
+            "path": "./tsconfig.app.json"
+        },
+        {
+            "path": "./tsconfig.node.json"
+        }
+    ]
 }

frontend/tsconfig.node.json

@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "composite": true,
+        "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+        "skipLibCheck": true,
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "allowSyntheticDefaultImports": true,
+        "strict": true,
+        "noEmit": true
+    },
+    "include": [
+        "vite.config.ts"
+    ]
+}

frontend/vite.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react-swc";
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    outDir: "../src/pydase/frontend",
+  },
+  esbuild: {
+    drop: ["console", "debugger"],
+  },
+});

mkdocs.yml

@@ -6,6 +6,7 @@ nav:
   - Getting Started: getting-started.md
   - User Guide:
     - Components Guide: user-guide/Components.md
+    - Interacting with pydase Services: user-guide/interaction/main.md
   - Developer Guide: 
     - Developer Guide: dev-guide/README.md
     - API Reference: dev-guide/api.md
@@ -16,7 +17,10 @@ nav:
     - Contributing: about/contributing.md
     - License: about/license.md
 
-theme: readthedocs
+theme: 
+  name: material
+  features:
+    - content.code.copy
 
 extra_css:
   - css/extra.css
@@ -26,17 +30,20 @@ markdown_extensions:
   - toc:
       permalink: true
   - pymdownx.highlight:
+      use_pygments: true
       anchor_linenums: true
+      line_spans: __span
+      pygments_lang_class: true
   - pymdownx.snippets
   - pymdownx.superfences
-  # - pymdownx.highlight:
-  # - pymdownx.inlinehilite
+  - pymdownx.inlinehilite
 
 
 plugins:
   - include-markdown
   - search
   - mkdocstrings
+  - swagger-ui-tag
 
 watch:
   - src/pydase

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pydase"
-version = "0.7.4"
+version = "0.9.0"
 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"
@@ -9,14 +9,14 @@ packages = [{ include = "pydase", from = "src" }]
 
 [tool.poetry.dependencies]
 python = "^3.10"
-rpyc = "^5.3.1"
-fastapi = "^0.108.0"
-uvicorn = "^0.27.0"
 toml = "^0.10.2"
 python-socketio = "^5.8.0"
 confz = "^2.0.0"
-pint = "^0.22"
-pillow = "^10.0.0"
+pint = "^0.24"
+websocket-client = "^1.7.0"
+aiohttp = "^3.9.3"
+click = "^8.1.7"
+aiohttp-middlewares = "^2.3.0"
 
 [tool.poetry.group.dev]
 optional = true
@@ -29,17 +29,18 @@ mypy = "^1.4.1"
 matplotlib = "^3.7.2"
 pyright = "^1.1.323"
 pytest-mock = "^3.11.1"
-ruff = "^0.2.0"
+ruff = "^0.5.0"
 pytest-asyncio = "^0.23.2"
 
 [tool.poetry.group.docs]
 optional = true
 
 [tool.poetry.group.docs.dependencies]
-mkdocs = "^1.5.2"
+mkdocs-material = "^9.5.30"
 mkdocs-include-markdown-plugin = "^3.9.1"
 mkdocstrings = "^0.22.0"
 pymdown-extensions = "^10.1"
+mkdocs-swagger-ui-tag = "^0.6.10"
 
 [build-system]
 requires = ["poetry-core"]

src/pydase/__init__.py

@@ -1,3 +1,4 @@
+from pydase.client.client import Client
 from pydase.data_service import DataService
 from pydase.server import Server
 from pydase.utils.logging import setup_logging
@@ -7,4 +8,5 @@ setup_logging()
 __all__ = [
     "DataService",
     "Server",
+    "Client",
 ]

src/pydase/client/__init__.py

@@ -0,0 +1,3 @@
+from pydase.client.client import Client
+
+__all__ = ["Client"]

src/pydase/client/client.py

@@ -0,0 +1,179 @@
+import asyncio
+import logging
+import sys
+import threading
+from typing import TypedDict, cast
+
+import socketio  # type: ignore
+
+import pydase.components
+from pydase.client.proxy_loader import ProxyClassMixin, ProxyLoader
+from pydase.utils.serialization.deserializer import loads
+from pydase.utils.serialization.types import SerializedDataService, SerializedObject
+
+if sys.version_info < (3, 11):
+    from typing_extensions import Self
+else:
+    from typing import Self
+
+
+logger = logging.getLogger(__name__)
+
+
+class NotifyDataDict(TypedDict):
+    full_access_path: str
+    value: SerializedObject
+
+
+class NotifyDict(TypedDict):
+    data: NotifyDataDict
+
+
+def asyncio_loop_thread(loop: asyncio.AbstractEventLoop) -> None:
+    asyncio.set_event_loop(loop)
+    try:
+        loop.run_forever()
+    except RuntimeError:
+        logger.debug("Tried starting even loop, but it is running already")
+
+
+class ProxyClass(ProxyClassMixin, pydase.components.DeviceConnection):
+    """
+    A proxy class that serves as the interface for interacting with device connections
+    via a socket.io client in an asyncio environment.
+
+    Args:
+        sio_client (socketio.AsyncClient):
+            The socket.io client instance used for asynchronous communication with the
+            pydase service server.
+        loop (asyncio.AbstractEventLoop):
+            The event loop in which the client operations are managed and executed.
+
+    This class is used to create a proxy object that behaves like a local representation
+    of a remote pydase service, facilitating direct interaction as if it were local
+    while actually communicating over network protocols.
+    It can also be used as an attribute of a pydase service itself, e.g.
+
+        ```python
+        import pydase
+
+
+        class MyService(pydase.DataService):
+            proxy = pydase.Client(
+                hostname="...", port=8001, block_until_connected=False
+            ).proxy
+
+
+        if __name__ == "__main__":
+            service = MyService()
+            server = pydase.Server(service, web_port=8002).run()
+        ```
+    """
+
+    def __init__(
+        self, sio_client: socketio.AsyncClient, loop: asyncio.AbstractEventLoop
+    ) -> None:
+        super().__init__()
+        self._initialise(sio_client=sio_client, loop=loop)
+
+
+class Client:
+    """
+    A client for connecting to a remote pydase service using socket.io. This client
+    handles asynchronous communication with a service, manages events such as
+    connection, disconnection, and updates, and ensures that the proxy object is
+    up-to-date with the server state.
+
+    Attributes:
+        proxy (ProxyClass):
+            A proxy object representing the remote service, facilitating interaction as
+            if it were local.
+
+    Args:
+        url (str):
+            The URL of the pydase Socket.IO server. This should always contain the
+            protocol and the hostname.
+            Examples:
+                - wss://my-service.example.com  # for secure connections, use wss
+                - ws://localhost:8001
+        block_until_connected (bool):
+            If set to True, the constructor will block until the connection to the
+            service has been established. This is useful for ensuring the client is
+            ready to use immediately after instantiation. Default is True.
+    """
+
+    def __init__(
+        self,
+        *,
+        url: str,
+        block_until_connected: bool = True,
+    ):
+        self._url = url
+        self._sio = socketio.AsyncClient()
+        self._loop = asyncio.new_event_loop()
+        self.proxy = ProxyClass(sio_client=self._sio, loop=self._loop)
+        self._thread = threading.Thread(
+            target=asyncio_loop_thread, args=(self._loop,), daemon=True
+        )
+        self._thread.start()
+        self.connect(block_until_connected=block_until_connected)
+
+    def __enter__(self) -> Self:
+        self.connect(block_until_connected=True)
+        return self
+
+    def __del__(self) -> None:
+        self.disconnect()
+
+    def connect(self, block_until_connected: bool = True) -> None:
+        connection_future = asyncio.run_coroutine_threadsafe(
+            self._connect(), self._loop
+        )
+        if block_until_connected:
+            connection_future.result()
+
+    def disconnect(self) -> None:
+        connection_future = asyncio.run_coroutine_threadsafe(
+            self._disconnect(), self._loop
+        )
+        connection_future.result()
+
+    async def _connect(self) -> None:
+        logger.debug("Connecting to server '%s' ...", self._url)
+        await self._setup_events()
+        await self._sio.connect(
+            self._url,
+            socketio_path="/ws/socket.io",
+            transports=["websocket"],
+            retry=True,
+        )
+
+    async def _disconnect(self) -> None:
+        await self._sio.disconnect()
+
+    async def _setup_events(self) -> None:
+        self._sio.on("connect", self._handle_connect)
+        self._sio.on("disconnect", self._handle_disconnect)
+        self._sio.on("notify", self._handle_update)
+
+    async def _handle_connect(self) -> None:
+        logger.debug("Connected to '%s' ...", self._url)
+        serialized_object = cast(
+            SerializedDataService, await self._sio.call("service_serialization")
+        )
+        ProxyLoader.update_data_service_proxy(
+            self.proxy, serialized_object=serialized_object
+        )
+        serialized_object["type"] = "DeviceConnection"
+        self.proxy._notify_changed("", loads(serialized_object))
+        self.proxy._connected = True
+
+    async def _handle_disconnect(self) -> None:
+        logger.debug("Disconnected from '%s' ...", self._url)
+        self.proxy._connected = False
+
+    async def _handle_update(self, data: NotifyDict) -> None:
+        self.proxy._notify_changed(
+            data["data"]["full_access_path"],
+            loads(data["data"]["value"]),
+        )

src/pydase/client/proxy_loader.py

@@ -0,0 +1,409 @@
+import asyncio
+import logging
+from collections.abc import Iterable
+from copy import copy
+from typing import TYPE_CHECKING, Any, cast
+
+import socketio  # type: ignore
+from typing_extensions import SupportsIndex
+
+from pydase.utils.serialization.deserializer import Deserializer, loads
+from pydase.utils.serialization.serializer import dump
+from pydase.utils.serialization.types import SerializedObject
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+logger = logging.getLogger(__name__)
+
+
+class ProxyAttributeError(Exception): ...
+
+
+def trigger_method(
+    sio_client: socketio.AsyncClient,
+    loop: asyncio.AbstractEventLoop,
+    access_path: str,
+    args: list[Any],
+    kwargs: dict[str, Any],
+) -> Any:
+    async def async_trigger_method() -> Any:
+        return await sio_client.call(
+            "trigger_method",
+            {
+                "access_path": access_path,
+                "args": dump(args),
+                "kwargs": dump(kwargs),
+            },
+        )
+
+    result: SerializedObject | None = asyncio.run_coroutine_threadsafe(
+        async_trigger_method(),
+        loop=loop,
+    ).result()
+
+    if result is not None:
+        return ProxyLoader.loads_proxy(
+            serialized_object=result, sio_client=sio_client, loop=loop
+        )
+
+    return None
+
+
+def update_value(
+    sio_client: socketio.AsyncClient,
+    loop: asyncio.AbstractEventLoop,
+    access_path: str,
+    value: Any,
+) -> Any:
+    async def set_result() -> Any:
+        return await sio_client.call(
+            "update_value",
+            {
+                "access_path": access_path,
+                "value": dump(value),
+            },
+        )
+
+    result: SerializedObject | None = asyncio.run_coroutine_threadsafe(
+        set_result(),
+        loop=loop,
+    ).result()
+    if result is not None:
+        ProxyLoader.loads_proxy(
+            serialized_object=result, sio_client=sio_client, loop=loop
+        )
+
+
+class ProxyDict(dict[str, Any]):
+    def __init__(
+        self,
+        original_dict: dict[str, Any],
+        parent_path: str,
+        sio_client: socketio.AsyncClient,
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        super().__init__(original_dict)
+        self._parent_path = parent_path
+        self._loop = loop
+        self._sio = sio_client
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        observer_key = key
+        if isinstance(key, str):
+            observer_key = f'"{key}"'
+
+        full_access_path = f"{self._parent_path}[{observer_key}]"
+
+        update_value(self._sio, self._loop, full_access_path, value)
+
+    def pop(self, key: str) -> Any:  # type: ignore
+        """Removes the element from the dictionary on the server. It does not return
+        any proxy as the corresponding object on the server does not live anymore."""
+
+        full_access_path = f"{self._parent_path}.pop"
+
+        trigger_method(self._sio, self._loop, full_access_path, [key], {})
+
+
+class ProxyList(list[Any]):
+    def __init__(
+        self,
+        original_list: list[Any],
+        parent_path: str,
+        sio_client: socketio.AsyncClient,
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        super().__init__(original_list)
+        self._parent_path = parent_path
+        self._loop = loop
+        self._sio = sio_client
+
+    def __setitem__(self, key: int, value: Any) -> None:  # type: ignore[override]
+        full_access_path = f"{self._parent_path}[{key}]"
+
+        update_value(self._sio, self._loop, full_access_path, value)
+
+    def append(self, __object: Any) -> None:
+        full_access_path = f"{self._parent_path}.append"
+
+        trigger_method(self._sio, self._loop, full_access_path, [__object], {})
+
+    def clear(self) -> None:
+        full_access_path = f"{self._parent_path}.clear"
+
+        trigger_method(self._sio, self._loop, full_access_path, [], {})
+
+    def extend(self, __iterable: Iterable[Any]) -> None:
+        full_access_path = f"{self._parent_path}.extend"
+
+        trigger_method(self._sio, self._loop, full_access_path, [__iterable], {})
+
+    def insert(self, __index: SupportsIndex, __object: Any) -> None:
+        full_access_path = f"{self._parent_path}.insert"
+
+        trigger_method(self._sio, self._loop, full_access_path, [__index, __object], {})
+
+    def pop(self, __index: SupportsIndex = -1) -> Any:
+        full_access_path = f"{self._parent_path}.pop"
+
+        return trigger_method(self._sio, self._loop, full_access_path, [__index], {})
+
+    def remove(self, __value: Any) -> None:
+        full_access_path = f"{self._parent_path}.remove"
+
+        trigger_method(self._sio, self._loop, full_access_path, [__value], {})
+
+
+class ProxyClassMixin:
+    def __init__(self) -> None:
+        # declare before DataService init to avoid warning messaged
+        self._observers: dict[str, Any] = {}
+
+        self._proxy_getters: dict[str, Callable[..., Any]] = {}
+        self._proxy_setters: dict[str, Callable[..., Any]] = {}
+        self._proxy_methods: dict[str, Callable[..., Any]] = {}
+
+    def _initialise(
+        self,
+        sio_client: socketio.AsyncClient,
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        self._loop = loop
+        self._sio = sio_client
+
+    def __dir__(self) -> list[str]:
+        """Used to provide tab completion on CLI / notebook"""
+        static_dir = super().__dir__()
+        return sorted({*static_dir, *self._proxy_getters, *self._proxy_methods.keys()})
+
+    def __getattribute__(self, name: str) -> Any:
+        try:
+            if name in super().__getattribute__("_proxy_getters"):
+                return super().__getattribute__("_proxy_getters")[name]()
+            if name in super().__getattribute__("_proxy_methods"):
+                return super().__getattribute__("_proxy_methods")[name]
+        except AttributeError:
+            pass
+        return super().__getattribute__(name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        try:
+            if name in super().__getattribute__("_proxy_setters"):
+                return super().__getattribute__("_proxy_setters")[name](value)
+            if name in super().__getattribute__("_proxy_getters"):
+                raise ProxyAttributeError(
+                    f"Proxy attribute {name!r} of {type(self).__name__!r} is readonly!"
+                )
+        except AttributeError:
+            pass
+        return super().__setattr__(name, value)
+
+    def _handle_serialized_method(
+        self, attr_name: str, serialized_object: SerializedObject
+    ) -> None:
+        def add_prefix_to_last_path_element(s: str, prefix: str) -> str:
+            parts = s.split(".")
+            parts[-1] = f"{prefix}_{parts[-1]}"
+            return ".".join(parts)
+
+        if serialized_object["type"] == "method":
+            if serialized_object["async"] is True:
+                start_method = copy(serialized_object)
+                start_method["full_access_path"] = add_prefix_to_last_path_element(
+                    start_method["full_access_path"], "start"
+                )
+                stop_method = copy(serialized_object)
+                stop_method["full_access_path"] = add_prefix_to_last_path_element(
+                    stop_method["full_access_path"], "stop"
+                )
+                self._add_method_proxy(f"start_{attr_name}", start_method)
+                self._add_method_proxy(f"stop_{attr_name}", stop_method)
+            else:
+                self._add_method_proxy(attr_name, serialized_object)
+
+    def _add_method_proxy(
+        self, attr_name: str, serialized_object: SerializedObject
+    ) -> None:
+        def method_proxy(*args: Any, **kwargs: Any) -> Any:
+            return trigger_method(
+                self._sio,
+                self._loop,
+                serialized_object["full_access_path"],
+                list(args),
+                kwargs,
+            )
+
+        dict.__setitem__(self._proxy_methods, attr_name, method_proxy)
+
+    def _add_attr_proxy(
+        self, attr_name: str, serialized_object: SerializedObject
+    ) -> None:
+        self._add_getattr_proxy(attr_name, serialized_object=serialized_object)
+        if not serialized_object["readonly"]:
+            self._add_setattr_proxy(attr_name, serialized_object=serialized_object)
+
+    def _add_setattr_proxy(
+        self, attr_name: str, serialized_object: SerializedObject
+    ) -> None:
+        self._add_getattr_proxy(attr_name, serialized_object=serialized_object)
+        if not serialized_object["readonly"]:
+
+            def setter_proxy(value: Any) -> None:
+                update_value(
+                    self._sio, self._loop, serialized_object["full_access_path"], value
+                )
+
+            dict.__setitem__(self._proxy_setters, attr_name, setter_proxy)  # type: ignore
+
+    def _add_getattr_proxy(
+        self, attr_name: str, serialized_object: SerializedObject
+    ) -> None:
+        def getter_proxy() -> Any:
+            async def get_result() -> Any:
+                return await self._sio.call(
+                    "get_value", serialized_object["full_access_path"]
+                )
+
+            result = asyncio.run_coroutine_threadsafe(
+                get_result(),
+                loop=self._loop,
+            ).result()
+            return ProxyLoader.loads_proxy(result, self._sio, self._loop)
+
+        dict.__setitem__(self._proxy_getters, attr_name, getter_proxy)  # type: ignore
+
+
+class ProxyLoader:
+    @staticmethod
+    def load_list_proxy(
+        serialized_object: SerializedObject,
+        sio_client: socketio.AsyncClient,
+        loop: asyncio.AbstractEventLoop,
+    ) -> Any:
+        return ProxyList(
+            [
+                ProxyLoader.loads_proxy(item, sio_client, loop)
+                for item in cast(list[SerializedObject], serialized_object["value"])
+            ],
+            parent_path=serialized_object["full_access_path"],
+            sio_client=sio_client,
+            loop=loop,
+        )
+
+    @staticmethod
+    def load_dict_proxy(
+        serialized_object: SerializedObject,
+        sio_client: socketio.AsyncClient,
+        loop: asyncio.AbstractEventLoop,
+    ) -> Any:
+        return ProxyDict(
+            {
+                key: ProxyLoader.loads_proxy(value, sio_client, loop)
+                for key, value in cast(
+                    dict[str, SerializedObject], serialized_object["value"]
+                ).items()
+            },
+            parent_path=serialized_object["full_access_path"],
+            sio_client=sio_client,
+            loop=loop,
+        )
+
+    @staticmethod
+    def update_data_service_proxy(
+        proxy_class: ProxyClassMixin,
+        serialized_object: SerializedObject,
+    ) -> Any:
+        proxy_class._proxy_getters.clear()
+        proxy_class._proxy_setters.clear()
+        proxy_class._proxy_methods.clear()
+        for key, value in cast(
+            dict[str, SerializedObject], serialized_object["value"]
+        ).items():
+            type_handler: dict[str | None, None | Callable[..., Any]] = {
+                None: None,
+                "int": proxy_class._add_attr_proxy,
+                "float": proxy_class._add_attr_proxy,
+                "bool": proxy_class._add_attr_proxy,
+                "str": proxy_class._add_attr_proxy,
+                "NoneType": proxy_class._add_attr_proxy,
+                "Quantity": proxy_class._add_attr_proxy,
+                "Enum": proxy_class._add_attr_proxy,
+                "ColouredEnum": proxy_class._add_attr_proxy,
+                "method": proxy_class._handle_serialized_method,
+                "list": proxy_class._add_getattr_proxy,
+                "dict": proxy_class._add_getattr_proxy,
+            }
+
+            # First go through handled types (as ColouredEnum is also within the
+            # components)
+            handler = type_handler.get(value["type"])
+            if handler:
+                handler(key, value)
+            else:
+                proxy_class._add_getattr_proxy(key, value)
+
+    @staticmethod
+    def load_data_service_proxy(
+        serialized_object: SerializedObject,
+        sio_client: socketio.AsyncClient,
+        loop: asyncio.AbstractEventLoop,
+    ) -> Any:
+        # Custom types like Components or DataService classes
+        component_class = cast(
+            type, Deserializer.get_component_class(serialized_object["type"])
+        )
+        class_bases = (
+            ProxyClassMixin,
+            component_class,
+        )
+        proxy_base_class: type[ProxyClassMixin] = type(
+            serialized_object["name"],  # type: ignore
+            class_bases,
+            {},
+        )
+        proxy_class_instance = proxy_base_class()
+        proxy_class_instance._initialise(sio_client=sio_client, loop=loop)
+        ProxyLoader.update_data_service_proxy(
+            proxy_class=proxy_class_instance, serialized_object=serialized_object
+        )
+        return proxy_class_instance
+
+    @staticmethod
+    def load_default(
+        serialized_object: SerializedObject,
+        sio_client: socketio.AsyncClient,
+        loop: asyncio.AbstractEventLoop,
+    ) -> Any:
+        return loads(serialized_object)
+
+    @staticmethod
+    def loads_proxy(
+        serialized_object: SerializedObject,
+        sio_client: socketio.AsyncClient,
+        loop: asyncio.AbstractEventLoop,
+    ) -> Any:
+        type_handler: dict[str | None, None | Callable[..., Any]] = {
+            "int": ProxyLoader.load_default,
+            "float": ProxyLoader.load_default,
+            "bool": ProxyLoader.load_default,
+            "str": ProxyLoader.load_default,
+            "NoneType": ProxyLoader.load_default,
+            "Quantity": ProxyLoader.load_default,
+            "Enum": ProxyLoader.load_default,
+            "ColouredEnum": ProxyLoader.load_default,
+            "Exception": ProxyLoader.load_default,
+            "list": ProxyLoader.load_list_proxy,
+            "dict": ProxyLoader.load_dict_proxy,
+        }
+
+        # First go through handled types (as ColouredEnum is also within the components)
+        handler = type_handler.get(serialized_object["type"])
+        if handler:
+            return handler(
+                serialized_object=serialized_object, sio_client=sio_client, loop=loop
+            )
+
+        return ProxyLoader.load_data_service_proxy(
+            serialized_object=serialized_object, sio_client=sio_client, loop=loop
+        )

src/pydase/components/coloured_enum.py

@@ -56,4 +56,9 @@ class ColouredEnum(Enum):
     my_service = StatusExample()
     my_service.status = MyStatus.FAILED
     ```
+
+    Note
+    ----
+    Each enumeration name and value must be unique. This means that you should use
+    different colour formats when you want to use a colour multiple times.
     """

src/pydase/components/device_connection.py

@@ -1,9 +1,9 @@
 import asyncio
 
-import pydase
+import pydase.data_service
 
 
-class DeviceConnection(pydase.DataService):
+class DeviceConnection(pydase.data_service.DataService):
     """
     Base class for device connection management within the pydase framework.
 

src/pydase/components/image.py

@@ -5,8 +5,6 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 from urllib.request import urlopen
 
-import PIL.Image  # type: ignore[import-untyped]
-
 from pydase.data_service.data_service import DataService
 
 if TYPE_CHECKING:
@@ -16,9 +14,7 @@ logger = logging.getLogger(__name__)
 
 
 class Image(DataService):
-    def __init__(
-        self,
-    ) -> None:
+    def __init__(self) -> None:
         super().__init__()
         self._value: str = ""
         self._format: str = ""
@@ -32,8 +28,14 @@ class Image(DataService):
         return self._format
 
     def load_from_path(self, path: Path | str) -> None:
-        with PIL.Image.open(path) as image:
-            self._load_from_pil(image)
+        with open(path, "rb") as image_file:
+            image_data = image_file.read()
+        format_ = self._get_image_format_from_bytes(image_data)
+        if format_ is None:
+            logger.error("Unsupported image format. Skipping...")
+            return
+        value_ = base64.b64encode(image_data)
+        self._load_from_base64(value_, format_)
 
     def load_from_matplotlib_figure(self, fig: "Figure", format_: str = "png") -> None:
         buffer = io.BytesIO()
@@ -42,12 +44,18 @@ class Image(DataService):
         self._load_from_base64(value_, format_)
 
     def load_from_url(self, url: str) -> None:
-        image = PIL.Image.open(urlopen(url))
-        self._load_from_pil(image)
+        with urlopen(url) as response:
+            image_data = response.read()
+        format_ = self._get_image_format_from_bytes(image_data)
+        if format_ is None:
+            logger.error("Unsupported image format. Skipping...")
+            return
+        value_ = base64.b64encode(image_data)
+        self._load_from_base64(value_, format_)
 
     def load_from_base64(self, value_: bytes, format_: str | None = None) -> None:
         if format_ is None:
-            format_ = self._get_image_format_from_bytes(value_)
+            format_ = self._get_image_format_from_bytes(base64.b64decode(value_))
             if format_ is None:
                 logger.warning(
                     "Format of passed byte string could not be determined. Skipping..."
@@ -60,19 +68,14 @@ class Image(DataService):
         self._value = value
         self._format = format_
 
-    def _load_from_pil(self, image: PIL.Image.Image) -> None:
-        if image.format is not None:
-            format_ = image.format
-            buffer = io.BytesIO()
-            image.save(buffer, format=format_)
-            value_ = base64.b64encode(buffer.getvalue())
-            self._load_from_base64(value_, format_)
-        else:
-            logger.error("Image format is 'None'. Skipping...")
-
     def _get_image_format_from_bytes(self, value_: bytes) -> str | None:
-        image_data = base64.b64decode(value_)
-        # Create a writable memory buffer for the image
-        image_buffer = io.BytesIO(image_data)
-        # Read the image from the buffer and return format
-        return PIL.Image.open(image_buffer).format
+        format_map = {
+            b"\xff\xd8": "JPEG",
+            b"\x89PNG": "PNG",
+            b"GIF": "GIF",
+            b"RIFF": "WEBP",
+        }
+        for signature, format_name in format_map.items():
+            if value_.startswith(signature):
+                return format_name
+        return None

src/pydase/config.py

@@ -13,7 +13,6 @@ class OperationMode(BaseConfig):  # type: ignore[misc]
 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")
 

src/pydase/data_service/data_service.py

@@ -1,9 +1,7 @@
 import inspect
 import logging
 from enum import Enum
-from typing import Any, get_type_hints
-
-import rpyc  # type: ignore[import-untyped]
+from typing import Any
 
 import pydase.units as u
 from pydase.data_service.abstract_data_service import AbstractDataService
@@ -12,11 +10,10 @@ from pydase.observer_pattern.observable.observable import (
     Observable,
 )
 from pydase.utils.helpers import (
-    convert_arguments_to_hinted_types,
     get_class_and_instance_attributes,
     is_property_attribute,
 )
-from pydase.utils.serializer import (
+from pydase.utils.serialization.serializer import (
     SerializedObject,
     Serializer,
 )
@@ -24,19 +21,8 @@ from pydase.utils.serializer import (
 logger = logging.getLogger(__name__)
 
 
-def process_callable_attribute(attr: Any, args: dict[str, Any]) -> Any:
-    converted_args_or_error_msg = convert_arguments_to_hinted_types(
-        args, get_type_hints(attr)
-    )
-    return (
-        attr(**converted_args_or_error_msg)
-        if not isinstance(converted_args_or_error_msg, str)
-        else converted_args_or_error_msg
-    )
-
-
-class DataService(rpyc.Service, AbstractDataService):
-    def __init__(self, **kwargs: Any) -> None:
+class DataService(AbstractDataService):
+    def __init__(self) -> None:
         super().__init__()
         self._task_manager = TaskManager(self)
 
@@ -87,7 +73,7 @@ class DataService(rpyc.Service, AbstractDataService):
 
         if not issubclass(
             value_class,
-            (int | float | bool | str | list | Enum | u.Quantity | Observable),
+            (int | float | bool | str | list | dict | Enum | u.Quantity | Observable),
         ):
             logger.warning(
                 "Class '%s' does not inherit from DataService. This may lead to"
@@ -106,26 +92,6 @@ class DataService(rpyc.Service, AbstractDataService):
             ):
                 self.__warn_if_not_observable(attr_value)
 
-    def _rpyc_getattr(self, name: str) -> Any:
-        if name.startswith("_"):
-            # disallow special and private attributes
-            raise AttributeError("cannot access private/special names")
-        # allow all other attributes
-        return getattr(self, name)
-
-    def _rpyc_setattr(self, name: str, value: Any) -> None:
-        if name.startswith("_"):
-            # disallow special and private attributes
-            raise AttributeError("cannot access private/special names")
-
-        # check if the attribute has a setter method
-        attr = getattr(self, name, None)
-        if isinstance(attr, property) and attr.fset is None:
-            raise AttributeError(f"{name} attribute does not have a setter method")
-
-        # allow all other attributes
-        setattr(self, name, value)
-
     def serialize(self) -> SerializedObject:
         """
         Serializes the instance into a dictionary, preserving the structure of the

src/pydase/data_service/data_service_cache.py

@@ -1,9 +1,7 @@
 import logging
 from typing import TYPE_CHECKING, Any, cast
 
-from pydase.utils.serializer import (
-    SerializationPathError,
-    SerializationValueError,
+from pydase.utils.serialization.serializer import (
     SerializedObject,
     get_nested_dict_by_path,
     set_nested_value_by_path,
@@ -38,15 +36,7 @@ class DataServiceCache:
         )
 
     def get_value_dict_from_cache(self, full_access_path: str) -> SerializedObject:
-        try:
-            return get_nested_dict_by_path(
-                cast(dict[str, SerializedObject], self._cache["value"]),
-                full_access_path,
-            )
-        except (SerializationPathError, SerializationValueError, KeyError):
-            return {
-                "value": None,
-                "type": None,
-                "doc": None,
-                "readonly": False,
-            }
+        return get_nested_dict_by_path(
+            cast(dict[str, SerializedObject], self._cache["value"]),
+            full_access_path,
+        )

src/pydase/data_service/data_service_observer.py

@@ -8,8 +8,12 @@ from pydase.observer_pattern.observable.observable_object import ObservableObjec
 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 SerializedObject, dump
+from pydase.utils.helpers import get_object_attr_from_path
+from pydase.utils.serialization.serializer import (
+    SerializationPathError,
+    SerializedObject,
+    dump,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -29,23 +33,34 @@ class DataServiceObserver(PropertyObserver):
             for changing_attribute in self.changing_attributes
         ):
             return
+        cached_value_dict: SerializedObject
 
-        cached_value_dict = deepcopy(
-            self.state_manager._data_service_cache.get_value_dict_from_cache(
-                full_access_path
+        try:
+            cached_value_dict = deepcopy(
+                self.state_manager.cache_manager.get_value_dict_from_cache(
+                    full_access_path
+                )
             )
-        )
+        except (SerializationPathError, KeyError):
+            cached_value_dict = {
+                "full_access_path": full_access_path,
+                "value": None,
+                "type": "None",
+                "doc": None,
+                "readonly": False,
+            }
 
         cached_value = cached_value_dict.get("value")
-        if cached_value != dump(value)["value"] and all(
-            part[0] != "_" for part in full_access_path.split(".")
+        if (
+            all(part[0] != "_" for part in full_access_path.split("."))
+            and cached_value != value
         ):
             logger.debug("'%s' changed to '%s'", full_access_path, value)
 
             self._update_cache_value(full_access_path, value, cached_value_dict)
 
             cached_value_dict = deepcopy(
-                self.state_manager._data_service_cache.get_value_dict_from_cache(
+                self.state_manager.cache_manager.get_value_dict_from_cache(
                     full_access_path
                 )
             )
@@ -65,23 +80,23 @@ class DataServiceObserver(PropertyObserver):
         cached_value_dict: SerializedObject | dict[str, Any],
     ) -> None:
         value_dict = dump(value)
-        if cached_value_dict != {}:
-            if (
-                cached_value_dict["type"] != "method"
-                and cached_value_dict["type"] != value_dict["type"]
-            ):
-                logger.warning(
-                    "Type of '%s' changed from '%s' to '%s'. This could have unwanted "
-                    "side effects! Consider setting it to '%s' directly.",
-                    full_access_path,
-                    cached_value_dict["type"],
-                    value_dict["type"],
-                    cached_value_dict["type"],
-                )
-            self.state_manager._data_service_cache.update_cache(
+        if (
+            cached_value_dict != {}
+            and cached_value_dict["type"] != "method"
+            and cached_value_dict["type"] != value_dict["type"]
+        ):
+            logger.warning(
+                "Type of '%s' changed from '%s' to '%s'. This could have unwanted "
+                "side effects! Consider setting it to '%s' directly.",
                 full_access_path,
-                value,
+                cached_value_dict["type"],
+                value_dict["type"],
+                cached_value_dict["type"],
             )
+        self.state_manager.cache_manager.update_cache(
+            full_access_path,
+            value,
+        )
 
     def _notify_dependent_property_changes(self, changed_attr_path: str) -> None:
         changed_props = self.property_deps_dict.get(changed_attr_path, [])
@@ -92,7 +107,7 @@ class DataServiceObserver(PropertyObserver):
             if prop not in self.changing_attributes:
                 self._notify_changed(
                     prop,
-                    get_object_attr_from_path_list(self.observable, prop.split(".")),
+                    get_object_attr_from_path(self.observable, prop),
                 )
 
     def add_notification_callback(

src/pydase/data_service/state_manager.py

@@ -1,3 +1,4 @@
+import contextlib
 import json
 import logging
 import os
@@ -5,16 +6,17 @@ from collections.abc import Callable
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 
-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,
+    get_object_by_path_parts,
     is_property_attribute,
-    parse_list_attr_and_index,
+    parse_full_access_path,
+    parse_serialized_key,
 )
-from pydase.utils.serializer import (
+from pydase.utils.serialization.deserializer import loads
+from pydase.utils.serialization.serializer import (
+    SerializationPathError,
     SerializedObject,
-    dump,
     generate_serialized_data_paths,
     get_nested_dict_by_path,
     serialized_dict_is_nested_object,
@@ -112,19 +114,12 @@ class StateManager:
             self.filename = filename
 
         self.service = service
-        self._data_service_cache = DataServiceCache(self.service)
-
-    @property
-    def cache(self) -> SerializedObject:
-        """Returns the cached DataService state."""
-        return self._data_service_cache.cache
+        self.cache_manager = DataServiceCache(self.service)
 
     @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"]
-        )
+        return cast(dict[str, SerializedObject], self.cache_manager.cache["value"])
 
     def save_state(self) -> None:
         """
@@ -154,23 +149,34 @@ class StateManager:
             return
 
         for path in generate_serialized_data_paths(json_dict):
-            nested_json_dict = get_nested_dict_by_path(json_dict, path)
-            nested_class_dict = self._data_service_cache.get_value_dict_from_cache(path)
+            if self.__is_loadable_state_attribute(path):
+                nested_json_dict = get_nested_dict_by_path(json_dict, path)
+                try:
+                    nested_class_dict = self.cache_manager.get_value_dict_from_cache(
+                        path
+                    )
+                except (SerializationPathError, KeyError):
+                    nested_class_dict = {
+                        "full_access_path": path,
+                        "value": None,
+                        "type": "None",
+                        "doc": None,
+                        "readonly": False,
+                    }
 
-            value, value_type = nested_json_dict["value"], nested_json_dict["type"]
-            class_attr_value_type = nested_class_dict.get("type", None)
+                value_type = nested_json_dict["type"]
+                class_attr_value_type = nested_class_dict.get("type", None)
 
-            if class_attr_value_type == value_type:
-                if self.__is_loadable_state_attribute(path):
-                    self.set_service_attribute_value_by_path(path, value)
-            else:
-                logger.info(
-                    "Attribute type of '%s' changed from '%s' to "
-                    "'%s'. Ignoring value from JSON file...",
-                    path,
-                    value_type,
-                    class_attr_value_type,
-                )
+                if class_attr_value_type == value_type:
+                    self.set_service_attribute_value_by_path(path, nested_json_dict)
+                else:
+                    logger.info(
+                        "Attribute type of '%s' changed from '%s' to "
+                        "'%s'. Ignoring value from JSON file...",
+                        path,
+                        value_type,
+                        class_attr_value_type,
+                    )
 
     def _get_state_dict_from_json_file(self) -> dict[str, Any]:
         if self.filename is not None and os.path.exists(self.filename):
@@ -183,7 +189,7 @@ class StateManager:
     def set_service_attribute_value_by_path(
         self,
         path: str,
-        value: Any,
+        serialized_value: SerializedObject,
     ) -> None:
         """
         Sets the value of an attribute in the service managed by the `StateManager`
@@ -199,64 +205,77 @@ class StateManager:
             value: The new value to set for the attribute.
         """
 
-        current_value_dict = get_nested_dict_by_path(self.cache_value, path)
+        try:
+            current_value_dict = self.cache_manager.get_value_dict_from_cache(path)
+        except (SerializationPathError, KeyError):
+            current_value_dict = {
+                "full_access_path": path,
+                "value": None,
+                "type": "None",
+                "doc": None,
+                "readonly": False,
+            }
 
-        # This will also filter out methods as they are 'read-only'
-        if current_value_dict["readonly"]:
-            logger.debug("Attribute '%s' is read-only. Ignoring new value...", path)
-            return
-
-        converted_value = self.__convert_value_if_needed(value, current_value_dict)
+        if "full_access_path" not in serialized_value:
+            # Backwards compatibility for JSON files not containing the
+            # full_access_path
+            logger.warning(
+                "The format of your JSON file is out-of-date. This might lead "
+                "to unexpected errors. Please consider updating it."
+            )
+            serialized_value["full_access_path"] = current_value_dict[
+                "full_access_path"
+            ]
 
         # only set value when it has changed
-        if self.__attr_value_has_changed(converted_value, current_value_dict["value"]):
-            self.__update_attribute_by_path(path, converted_value)
+        if self.__attr_value_has_changed(serialized_value, current_value_dict):
+            self.__update_attribute_by_path(path, serialized_value)
         else:
             logger.debug("Value of attribute '%s' has not changed...", path)
 
-    def __attr_value_has_changed(self, value_object: Any, current_value: Any) -> bool:
-        """Check if the serialized value of `value_object` differs from `current_value`.
+    def __attr_value_has_changed(
+        self, serialized_new_value: Any, serialized_current_value: Any
+    ) -> bool:
+        return not (
+            serialized_new_value["type"] == serialized_current_value["type"]
+            and serialized_new_value["value"] == serialized_current_value["value"]
+        )
 
-        The method serializes `value_object` to compare it, which is mainly
-        necessary for handling Quantity objects.
-        """
+    def __update_attribute_by_path(
+        self, path: str, serialized_value: SerializedObject
+    ) -> None:
+        is_value_set = False
+        path_parts = parse_full_access_path(path)
+        target_obj = get_object_by_path_parts(self.service, path_parts[:-1])
 
-        return dump(value_object)["value"] != current_value
+        if self.__cached_value_is_enum(path):
+            enum_attr = get_object_by_path_parts(target_obj, [path_parts[-1]])
+            # take the value of the existing enum class
+            if serialized_value["type"] in ("ColouredEnum", "Enum"):
+                # This error will arise when setting an enum from another enum class.
+                # In this case, we resort to loading the enum and setting it directly.
+                with contextlib.suppress(KeyError):
+                    value = enum_attr.__class__[serialized_value["value"]]
+                    is_value_set = True
 
-    def __convert_value_if_needed(
-        self, value: Any, current_value_dict: SerializedObject
-    ) -> Any:
-        if current_value_dict["type"] == "Quantity":
-            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
+        if not is_value_set:
+            value = loads(serialized_value)
 
-    def __update_attribute_by_path(self, path: str, value: Any) -> None:
-        parent_path_list, attr_name = path.split(".")[:-1], path.split(".")[-1]
-
-        # 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)
-
-        # 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_value, path)["type"]
-
-        # Traverse the object according to the path parts
-        target_obj = get_object_attr_from_path_list(self.service, parent_path_list)
-
-        if attr_cache_type in ("ColouredEnum", "Enum"):
-            enum_attr = get_object_attr_from_path_list(target_obj, [attr_name])
-            setattr(target_obj, attr_name, enum_attr.__class__[value])
-        elif attr_cache_type == "list":
-            list_obj = get_object_attr_from_path_list(target_obj, [attr_name])
-            list_obj[index] = value
+        # set the value
+        if isinstance(target_obj, list | dict):
+            processed_key = parse_serialized_key(path_parts[-1])
+            target_obj[processed_key] = value  # type: ignore
         else:
-            setattr(target_obj, attr_name, value)
+            # Don't allow adding attributes to objects through state manager
+            if self.__attr_exists_on_target_obj(
+                target_obj=target_obj, name=path_parts[-1]
+            ):
+                raise AttributeError(
+                    f"{target_obj.__class__.__name__!r} object has no attribute "
+                    f"{path_parts[-1]!r}"
+                )
+
+            setattr(target_obj, path_parts[-1], value)
 
     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
@@ -266,28 +285,47 @@ class StateManager:
         attributes default to being loadable.
         """
 
-        parent_object = get_object_attr_from_path_list(
-            self.service, full_access_path.split(".")[:-1]
-        )
-        attr_name = full_access_path.split(".")[-1]
+        path_parts = parse_full_access_path(full_access_path)
+        parent_object = get_object_by_path_parts(self.service, path_parts[:-1])
 
-        if is_property_attribute(parent_object, attr_name):
-            prop = getattr(type(parent_object), attr_name)
+        if is_property_attribute(parent_object, path_parts[-1]):
+            prop = getattr(type(parent_object), path_parts[-1])
             has_decorator = has_load_state_decorator(prop)
             if not has_decorator:
                 logger.debug(
                     "Property '%s' has no '@load_state' decorator. "
                     "Ignoring value from JSON file...",
-                    attr_name,
+                    path_parts[-1],
                 )
             return has_decorator
 
-        cached_serialization_dict = get_nested_dict_by_path(
-            self.cache_value, full_access_path
-        )
+        try:
+            cached_serialization_dict = self.cache_manager.get_value_dict_from_cache(
+                full_access_path
+            )
 
-        if cached_serialization_dict["value"] == "method":
+            if cached_serialization_dict["value"] == "method":
+                return False
+
+            # nested objects cannot be loaded
+            return not serialized_dict_is_nested_object(cached_serialization_dict)
+        except SerializationPathError:
+            logger.debug(
+                "Path %a could not be loaded. It does not correspond to an attribute of"
+                " the class. Ignoring value from JSON file...",
+                path_parts[-1],
+            )
             return False
 
-        # nested objects cannot be loaded
-        return not serialized_dict_is_nested_object(cached_serialization_dict)
+    def __cached_value_is_enum(self, path: str) -> bool:
+        try:
+            attr_cache_type = self.cache_manager.get_value_dict_from_cache(path)["type"]
+
+            return attr_cache_type in ("ColouredEnum", "Enum")
+        except Exception:
+            return False
+
+    def __attr_exists_on_target_obj(self, target_obj: Any, name: str) -> bool:
+        return not is_property_attribute(target_obj, name) and not hasattr(
+            target_obj, name
+        )

src/pydase/data_service/task_manager.py

@@ -21,10 +21,6 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-class TaskDefinitionError(Exception):
-    pass
-
-
 class TaskStatus(Enum):
     RUNNING = "running"
 
@@ -107,12 +103,13 @@ class TaskManager:
             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."
+                    logger.info(
+                        "Async function %a is defined with at least one argument. If "
+                        "you want to use it as a task, remove the argument(s) from the "
+                        "function definition.",
+                        method.__name__,
                     )
+                    continue
 
                 # create start and stop methods for each coroutine
                 setattr(

src/pydase/frontend/asset-manifest.json

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

src/pydase/frontend/index.html

@@ -1 +1,18 @@
-<!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>
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="theme-color" content="#000000" />
+    <meta name="description" content="Web site displaying a pydase UI." />
+  <script type="module" crossorigin src="/assets/index-D7tStNHJ.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-D2aktF3W.css">
+</head>
+
+<body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+</body>
+
+</html>

src/pydase/frontend/manifest.json

@@ -1,25 +0,0 @@
-{
-  "short_name": "React App",
-  "name": "Create React App Sample",
-  "icons": [
-    {
-      "src": "favicon.ico",
-      "sizes": "64x64 32x32 24x24 16x16",
-      "type": "image/x-icon"
-    },
-    {
-      "src": "logo192.png",
-      "type": "image/png",
-      "sizes": "192x192"
-    },
-    {
-      "src": "logo512.png",
-      "type": "image/png",
-      "sizes": "512x512"
-    }
-  ],
-  "start_url": ".",
-  "display": "standalone",
-  "theme_color": "#000000",
-  "background_color": "#ffffff"
-}

src/pydase/frontend/robots.txt

@@ -1,3 +0,0 @@
-# https://www.robotstxt.org/robotstxt.html
-User-agent: *
-Disallow:

src/pydase/frontend/static/js/main.97ef73ea.js.LICENSE.txt

@@ -1,45 +0,0 @@
-/*!
-	Copyright (c) 2018 Jed Watson.
-	Licensed under the MIT License (MIT), see
-	http://jedwatson.github.io/classnames
-*/
-
-/**
- * @license React
- * react-dom.production.min.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @license React
- * react-jsx-runtime.production.min.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @license React
- * react.production.min.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @license React
- * scheduler.production.min.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */

src/pydase/observer_pattern/observable/decorators.py

@@ -0,0 +1,101 @@
+import time
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ParamSpec, TypeVar
+
+if TYPE_CHECKING:
+    from pydase.observer_pattern.observable.observable import Observable
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def validate_set(
+    *, timeout: float = 0.1, precision: float | None = None
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """
+    Decorator marking a property setter to read back the set value using the property
+    getter and check against the desired value.
+
+    Args:
+        timeout (float):
+            The maximum time (in seconds) to wait for the value to be within the
+            precision boundary.
+        precision (float | None):
+            The acceptable deviation from the desired value. If None, the value must be
+            exact.
+    """
+
+    def validate_set_decorator(func: Callable[P, R]) -> Callable[P, R]:
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            return func(*args, **kwargs)
+
+        wrapper._validate_kwargs = {  # type: ignore
+            "timeout": timeout,
+            "precision": precision,
+        }
+
+        return wrapper
+
+    return validate_set_decorator
+
+
+def has_validate_set_decorator(prop: property) -> bool:
+    """
+    Checks if a property setter has been decorated with the `validate_set` decorator.
+
+    Args:
+        prop (property):
+            The property to check.
+
+    Returns:
+        bool:
+            True if the property setter has the `validate_set` decorator, False
+            otherwise.
+    """
+
+    property_setter = prop.fset
+    return hasattr(property_setter, "_validate_kwargs")
+
+
+def _validate_value_was_correctly_set(
+    *,
+    obj: "Observable",
+    name: str,
+    value: Any,
+) -> None:
+    """
+    Validates if the property `name` of `obj` attains the desired `value` within the
+    specified `precision` and time `timeout`.
+
+    Args:
+        obj (Observable):
+            The instance of the class containing the property.
+        name (str):
+            The name of the property to validate.
+        value (Any):
+            The desired value to check against.
+
+    Raises:
+        ValueError:
+            If the property value does not match the desired value within the specified
+            precision and timeout.
+    """
+
+    prop: property = getattr(type(obj), name)
+
+    timeout = prop.fset._validate_kwargs["timeout"]  # type: ignore
+    precision = prop.fset._validate_kwargs["precision"]  # type: ignore
+    if precision is None:
+        precision = 0.0
+
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        current_value = obj.__getattribute__(name)
+        # This check is faster than rounding and comparing to 0
+        if abs(current_value - value) <= precision:
+            return
+        time.sleep(0.01)
+    raise ValueError(
+        f"Failed to set value to {value} within {timeout} seconds. Current value: "
+        f"{current_value}."
+    )

src/pydase/observer_pattern/observable/observable.py

@@ -1,6 +1,10 @@
 import logging
 from typing import Any
 
+from pydase.observer_pattern.observable.decorators import (
+    _validate_value_was_correctly_set,
+    has_validate_set_decorator,
+)
 from pydase.observer_pattern.observable.observable_object import ObservableObject
 from pydase.utils.helpers import is_property_attribute
 
@@ -15,6 +19,7 @@ class Observable(ObservableObject):
             for k in set(type(self).__dict__)
             - set(Observable.__dict__)
             - set(self.__dict__)
+            - {"__annotations__"}
         }
         for name, value in class_attrs.items():
             if isinstance(value, property) or callable(value):
@@ -34,7 +39,12 @@ class Observable(ObservableObject):
 
         super().__setattr__(name, value)
 
-        self._notify_changed(name, value)
+        if is_property_attribute(self, name) and has_validate_set_decorator(
+            getattr(type(self), name)
+        ):
+            _validate_value_was_correctly_set(obj=self, name=name, value=value)
+        else:
+            self._notify_changed(name, value)
 
     def __getattribute__(self, name: str) -> Any:
         if is_property_attribute(self, name):
@@ -67,5 +77,9 @@ class Observable(ObservableObject):
         self, observer_attr_name: str, instance_attr_name: str
     ) -> str:
         if observer_attr_name != "":
-            return f"{observer_attr_name}.{instance_attr_name}"
+            return (
+                f"{observer_attr_name}.{instance_attr_name}"
+                if instance_attr_name != ""
+                else observer_attr_name
+            )
         return instance_attr_name

src/pydase/observer_pattern/observable/observable_object.py

@@ -1,34 +1,44 @@
+from __future__ import annotations
+
 import logging
+import weakref
 from abc import ABC, abstractmethod
-from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any, ClassVar, SupportsIndex
 
+from pydase.utils.helpers import parse_serialized_key
+
 if TYPE_CHECKING:
+    from collections.abc import Iterable
+
     from pydase.observer_pattern.observer.observer import Observer
 
 logger = logging.getLogger(__name__)
 
 
 class ObservableObject(ABC):
-    _list_mapping: ClassVar[dict[int, "_ObservableList"]] = {}
-    _dict_mapping: ClassVar[dict[int, "_ObservableDict"]] = {}
+    _list_mapping: ClassVar[dict[int, weakref.ReferenceType[_ObservableList]]] = {}
+    _dict_mapping: ClassVar[dict[int, weakref.ReferenceType[_ObservableDict]]] = {}
 
     def __init__(self) -> None:
         if not hasattr(self, "_observers"):
-            self._observers: dict[str, list["ObservableObject | Observer"]] = {}
+            self._observers: dict[str, list[ObservableObject | Observer]] = {}
 
     def add_observer(
-        self, observer: "ObservableObject | Observer", attr_name: str = ""
+        self, observer: ObservableObject | Observer, attr_name: str = ""
     ) -> None:
         if attr_name not in self._observers:
             self._observers[attr_name] = []
         if observer not in self._observers[attr_name]:
             self._observers[attr_name].append(observer)
 
-    def _remove_observer(self, observer: "ObservableObject", attribute: str) -> None:
+    def _remove_observer(self, observer: ObservableObject, attribute: str) -> None:
         if attribute in self._observers:
             self._observers[attribute].remove(observer)
 
+            # remove attribute key from observers dict if list of observers is empty
+            if not self._observers[attribute]:
+                del self._observers[attribute]
+
     @abstractmethod
     def _remove_observer_if_observable(self, name: str) -> None:
         """Removes the current object as an observer from an observable attribute.
@@ -81,26 +91,30 @@ class ObservableObject(ABC):
                 )
                 observer._notify_change_start(extended_attr_path)
 
-    def _initialise_new_objects(self, attr_name_or_key: Any, value: Any) -> Any:
+    def _initialise_new_objects(self, attr_name_or_key: str, value: Any) -> Any:
         new_value = value
         if isinstance(value, list):
             if id(value) in self._list_mapping:
                 # If the list `value` was already referenced somewhere else
-                new_value = self._list_mapping[id(value)]
+                new_value = self._list_mapping[id(value)]()
             else:
                 # convert the builtin list into a ObservableList
                 new_value = _ObservableList(original_list=value)
-                self._list_mapping[id(value)] = new_value
+
+                # Use weakref to allow the GC to collect unused objects
+                self._list_mapping[id(value)] = weakref.ref(new_value)
         elif isinstance(value, dict):
             if id(value) in self._dict_mapping:
-                # If the list `value` was already referenced somewhere else
-                new_value = self._dict_mapping[id(value)]
+                # If the dict `value` was already referenced somewhere else
+                new_value = self._dict_mapping[id(value)]()
             else:
-                # convert the builtin list into a ObservableList
+                # convert the builtin dict into a ObservableDict
                 new_value = _ObservableDict(original_dict=value)
-                self._dict_mapping[id(value)] = new_value
+
+                # Use weakref to allow the GC to collect unused objects
+                self._dict_mapping[id(value)] = weakref.ref(new_value)
         if isinstance(new_value, ObservableObject):
-            new_value.add_observer(self, str(attr_name_or_key))
+            new_value.add_observer(self, attr_name_or_key)
         return new_value
 
     @abstractmethod
@@ -137,6 +151,9 @@ class _ObservableList(ObservableObject, list[Any]):
         for i, item in enumerate(self._original_list):
             super().__setitem__(i, self._initialise_new_objects(f"[{i}]", item))
 
+    def __del__(self) -> None:
+        self._list_mapping.pop(id(self._original_list))
+
     def __setitem__(self, key: int, value: Any) -> None:  # type: ignore[override]
         if hasattr(self, "_observers"):
             self._remove_observer_if_observable(f"[{key}]")
@@ -149,8 +166,7 @@ class _ObservableList(ObservableObject, list[Any]):
 
     def append(self, __object: Any) -> None:
         self._notify_change_start("")
-        self._initialise_new_objects(f"[{len(self)}]", __object)
-        super().append(__object)
+        super().append(self._initialise_new_objects(f"[{len(self)}]", __object))
         self._notify_changed("", self)
 
     def clear(self) -> None:
@@ -224,7 +240,7 @@ class _ObservableList(ObservableObject, list[Any]):
         return instance_attr_name
 
 
-class _ObservableDict(dict[str, Any], ObservableObject):
+class _ObservableDict(ObservableObject, dict[str, Any]):
     def __init__(
         self,
         original_dict: dict[str, Any],
@@ -233,24 +249,29 @@ class _ObservableDict(dict[str, Any], ObservableObject):
         ObservableObject.__init__(self)
         dict.__init__(self)
         for key, value in self._original_dict.items():
-            super().__setitem__(key, self._initialise_new_objects(f"['{key}']", value))
+            self.__setitem__(key, self._initialise_new_objects(f'["{key}"]', value))
+
+    def __del__(self) -> None:
+        self._dict_mapping.pop(id(self._original_dict))
 
     def __setitem__(self, key: str, value: Any) -> None:
         if not isinstance(key, str):
-            logger.warning("Converting non-string dictionary key %s to string.", key)
-            key = str(key)
+            raise ValueError(
+                f"Invalid key type: {key} ({type(key).__name__}). In pydase services, "
+                "dictionary keys must be strings."
+            )
 
         if hasattr(self, "_observers"):
-            self._remove_observer_if_observable(f"['{key}']")
-            value = self._initialise_new_objects(key, value)
-            self._notify_change_start(f"['{key}']")
+            self._remove_observer_if_observable(f'["{key}"]')
+            value = self._initialise_new_objects(f'["{key}"]', value)
+            self._notify_change_start(f'["{key}"]')
 
         super().__setitem__(key, value)
 
-        self._notify_changed(f"['{key}']", value)
+        self._notify_changed(f'["{key}"]', value)
 
     def _remove_observer_if_observable(self, name: str) -> None:
-        key = name[2:-2]
+        key = str(parse_serialized_key(name))
         current_value = self.get(key, None)
 
         if isinstance(current_value, ObservableObject):
@@ -262,3 +283,11 @@ class _ObservableDict(dict[str, Any], ObservableObject):
         if observer_attr_name != "":
             return f"{observer_attr_name}{instance_attr_name}"
         return instance_attr_name
+
+    def pop(self, key: str) -> Any:  # type: ignore[override]
+        self._remove_observer_if_observable(f'["{key}"]')
+
+        popped_item = super().pop(key)
+
+        self._notify_changed("", self)
+        return popped_item

src/pydase/observer_pattern/observer/property_observer.py

@@ -49,7 +49,7 @@ class PropertyObserver(Observer):
     def _process_observable_properties(
         self, obj: Observable, deps: dict[str, Any], prefix: str
     ) -> None:
-        for k, value in vars(type(obj)).items():
+        for k, value in inspect.getmembers(type(obj)):
             prefix = (
                 f"{prefix}." if prefix != "" and not prefix.endswith(".") else prefix
             )

src/pydase/server/server.py

@@ -2,21 +2,25 @@ import asyncio
 import logging
 import os
 import signal
+import sys
 import threading
-from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 from types import FrameType
 from typing import Any, Protocol, TypedDict
 
-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.server.web_server import WebServer
 
+HANDLED_SIGNALS = (
+    signal.SIGINT,  # Unix signal 2. Sent by Ctrl+C.
+    signal.SIGTERM,  # Unix signal 15. Sent by `kill <pid>`.
+)
+if sys.platform == "win32":  # pragma: py-not-win32
+    HANDLED_SIGNALS += (signal.SIGBREAK,)  # Windows signal 21. Sent by Ctrl+Break.
+
 logger = logging.getLogger(__name__)
 
 
@@ -51,8 +55,7 @@ class AdditionalServerProtocol(Protocol):
         host: str,
         port: int,
         **kwargs: Any,
-    ) -> None:
-        ...
+    ) -> None: ...
 
     async def serve(self) -> Any:
         """Starts the server. This method should be implemented as an asynchronous
@@ -81,71 +84,67 @@ class Server:
 
     Args:
         service: DataService
-          The DataService instance that this server will manage.
+            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`.
+            The host address for the server. Default is '0.0.0.0', which means all
+            available network interfaces.
         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.
+            The port number for the web server. Default is
+            `pydase.config.ServiceConfig().web_port`.
         enable_web: bool
-          Whether to enable the web server. Default is True.
+            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.
+            Filename of the file managing the service state persistence.
+            Defaults to None.
         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.
+            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.
 
-          Here's an example of how you might define an additional server:
+            Here's an example of how you might define an additional server:
 
+            ```python
+            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...
 
-          >>>     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...
+                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:
-
-          >>>    server = Server(
-          ...        service=my_data_service,
-          ...        additional_servers=[
-          ...            {
-          ...                "server": MyCustomServer,
-          ...                "port": 12345,
-          ...                "kwargs": {"some_arg": "some_value"}
-          ...            }
-          ...        ],
-          ...    )
-          ...    server.run()
+            And here's how you might add it to the `additional_servers` list when
+            creating a `Server` instance:
 
+            ```python
+            server = Server(
+                service=my_data_service,
+                additional_servers=[
+                    {
+                        "server": MyCustomServer,
+                        "port": 12345,
+                        "kwargs": {"some_arg": "some_value"}
+                    }
+                ],
+            )
+            server.run()
+            ```
         **kwargs: Any
           Additional keyword arguments.
     """
@@ -154,9 +153,7 @@ class Server:
         self,
         service: DataService,
         host: str = "0.0.0.0",
-        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,
         additional_servers: list[AdditionalServer] | None = None,
@@ -166,16 +163,13 @@ class Server:
             additional_servers = []
         self._service = service
         self._host = host
-        self._rpc_port = rpc_port
         self._web_port = web_port
-        self._enable_rpc = enable_rpc
         self._enable_web = enable_web
         self._kwargs = kwargs
         self._loop: asyncio.AbstractEventLoop
         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)
         self._observer = DataServiceObserver(self._state_manager)
         self._state_manager.load_state()
@@ -207,20 +201,6 @@ class Server:
         self.install_signal_handlers()
         self._service._task_manager.start_autostart_tasks()
 
-        if self._enable_rpc:
-            self.executor = ThreadPoolExecutor()
-            self._rpc_server = ThreadedServer(
-                self._service,
-                port=self._rpc_port,
-                protocol_config={
-                    "allow_all_attrs": True,
-                    "allow_setattr": True,
-                },
-            )
-            future_or_task = self._loop.run_in_executor(
-                executor=self.executor, func=self._rpc_server.start
-            )
-            self.servers["rpyc"] = future_or_task
         for server in self._additional_servers:
             addin_server = server["server"](
                 data_service_observer=self._observer,
@@ -233,8 +213,9 @@ class Server:
                 addin_server.__module__ + "." + addin_server.__class__.__name__
             )
 
-            future_or_task = self._loop.create_task(addin_server.serve())
-            self.servers[server_name] = future_or_task
+            server_task = self._loop.create_task(addin_server.serve())
+            server_task.add_done_callback(self.handle_server_shutdown)
+            self.servers[server_name] = server_task
         if self._enable_web:
             self._web_server = WebServer(
                 data_service_observer=self._observer,
@@ -242,8 +223,22 @@ class Server:
                 port=self._web_port,
                 **self._kwargs,
             )
-            future_or_task = self._loop.create_task(self._web_server.serve())
-            self.servers["web"] = future_or_task
+            server_task = self._loop.create_task(self._web_server.serve())
+
+            server_task.add_done_callback(self.handle_server_shutdown)
+            self.servers["web"] = server_task
+
+    def handle_server_shutdown(self, task: asyncio.Task[Any]) -> None:
+        """Handle server shutdown. If the service should exit, do nothing. Else, make
+        the service exit."""
+
+        if self.should_exit:
+            return
+
+        try:
+            task.result()
+        except Exception:
+            self.should_exit = True
 
     async def main_loop(self) -> None:
         while not self.should_exit:
@@ -255,13 +250,11 @@ class Server:
         logger.info("Saving data to %s.", self._state_manager.filename)
         self._state_manager.save_state()
 
+        logger.debug("Cancelling servers")
         await self.__cancel_servers()
+        logger.debug("Cancelling tasks")
         await self.__cancel_tasks()
 
-        if hasattr(self, "_rpc_server") and self._enable_rpc:
-            logger.debug("Closing rpyc server.")
-            self._rpc_server.close()
-
     async def __cancel_servers(self) -> None:
         for server_name, task in self.servers.items():
             task.cancel()
@@ -270,7 +263,7 @@ class Server:
             except asyncio.CancelledError:
                 logger.debug("Cancelled '%s' server.", server_name)
             except Exception as e:
-                logger.warning("Unexpected exception: %s", e)
+                logger.error("Unexpected exception: %s", e)
 
     async def __cancel_tasks(self) -> None:
         for task in asyncio.all_tasks(self._loop):

src/pydase/server/web_server/api/__init__.py

@@ -0,0 +1,24 @@
+import logging
+
+import aiohttp.web
+import aiohttp_middlewares.error
+
+import pydase.server.web_server.api.v1.application
+from pydase.data_service.state_manager import StateManager
+
+logger = logging.getLogger(__name__)
+
+
+def create_api_application(state_manager: StateManager) -> aiohttp.web.Application:
+    api_application = aiohttp.web.Application(
+        middlewares=(aiohttp_middlewares.error.error_middleware(),)
+    )
+
+    api_application.add_subapp(
+        "/v1/",
+        pydase.server.web_server.api.v1.application.create_api_application(
+            state_manager
+        ),
+    )
+
+    return api_application

src/pydase/server/web_server/api/v1/application.py

@@ -0,0 +1,70 @@
+import logging
+from typing import TYPE_CHECKING
+
+import aiohttp.web
+import aiohttp_middlewares.error
+
+from pydase.data_service.state_manager import StateManager
+from pydase.server.web_server.api.v1.endpoints import (
+    get_value,
+    trigger_method,
+    update_value,
+)
+from pydase.utils.serialization.serializer import dump
+
+if TYPE_CHECKING:
+    from pydase.server.web_server.sio_setup import TriggerMethodDict, UpdateDict
+
+logger = logging.getLogger(__name__)
+
+API_VERSION = "v1"
+
+STATUS_OK = 200
+STATUS_FAILED = 400
+
+
+def create_api_application(state_manager: StateManager) -> aiohttp.web.Application:
+    api_application = aiohttp.web.Application(
+        middlewares=(aiohttp_middlewares.error.error_middleware(),)
+    )
+
+    async def _get_value(request: aiohttp.web.Request) -> aiohttp.web.Response:
+        logger.info("Handle api request: %s", request)
+
+        access_path = request.rel_url.query["access_path"]
+
+        status = STATUS_OK
+        try:
+            result = get_value(state_manager, access_path)
+        except Exception as e:
+            logger.exception(e)
+            result = dump(e)
+            status = STATUS_FAILED
+        return aiohttp.web.json_response(result, status=status)
+
+    async def _update_value(request: aiohttp.web.Request) -> aiohttp.web.Response:
+        data: UpdateDict = await request.json()
+
+        try:
+            update_value(state_manager, data)
+
+            return aiohttp.web.json_response()
+        except Exception as e:
+            logger.exception(e)
+            return aiohttp.web.json_response(dump(e), status=STATUS_FAILED)
+
+    async def _trigger_method(request: aiohttp.web.Request) -> aiohttp.web.Response:
+        data: TriggerMethodDict = await request.json()
+
+        try:
+            return aiohttp.web.json_response(trigger_method(state_manager, data))
+
+        except Exception as e:
+            logger.exception(e)
+            return aiohttp.web.json_response(dump(e), status=STATUS_FAILED)
+
+    api_application.router.add_get("/get_value", _get_value)
+    api_application.router.add_put("/update_value", _update_value)
+    api_application.router.add_put("/trigger_method", _trigger_method)
+
+    return api_application

src/pydase/server/web_server/api/v1/endpoints.py

@@ -0,0 +1,38 @@
+from typing import Any
+
+import pydase.utils.serialization.deserializer
+import pydase.utils.serialization.serializer
+from pydase.data_service.state_manager import StateManager
+from pydase.server.web_server.sio_setup import TriggerMethodDict, UpdateDict
+from pydase.utils.helpers import get_object_attr_from_path
+from pydase.utils.serialization.types import SerializedObject
+
+loads = pydase.utils.serialization.deserializer.loads
+Serializer = pydase.utils.serialization.serializer.Serializer
+
+
+def update_value(state_manager: StateManager, data: UpdateDict) -> None:
+    path = data["access_path"]
+
+    state_manager.set_service_attribute_value_by_path(
+        path=path, serialized_value=data["value"]
+    )
+
+
+def get_value(state_manager: StateManager, access_path: str) -> SerializedObject:
+    return Serializer.serialize_object(
+        get_object_attr_from_path(state_manager.service, access_path),
+        access_path=access_path,
+    )
+
+
+def trigger_method(state_manager: StateManager, data: TriggerMethodDict) -> Any:
+    method = get_object_attr_from_path(state_manager.service, data["access_path"])
+
+    serialized_args = data.get("args", None)
+    args = loads(serialized_args) if serialized_args else []
+
+    serialized_kwargs = data.get("kwargs", None)
+    kwargs: dict[str, Any] = loads(serialized_kwargs) if serialized_kwargs else {}
+
+    return Serializer.serialize_object(method(*args, **kwargs))

src/pydase/server/web_server/sio_setup.py

@@ -1,18 +1,29 @@
 import asyncio
 import logging
+import sys
 from typing import Any, TypedDict
 
+if sys.version_info < (3, 11):
+    from typing_extensions import NotRequired
+else:
+    from typing import NotRequired
+
+import click
 import socketio  # type: ignore[import-untyped]
 
-from pydase.data_service.data_service import process_callable_attribute
+import pydase.server.web_server.api.v1.endpoints
+import pydase.utils.serialization.deserializer
+import pydase.utils.serialization.serializer
 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
+from pydase.utils.serialization.serializer import SerializedObject
 
 logger = logging.getLogger(__name__)
 
+# These functions can be monkey-patched by other libraries at runtime
+dump = pydase.utils.serialization.serializer.dump
+
 
 class UpdateDict(TypedDict):
     """
@@ -21,26 +32,20 @@ class UpdateDict(TypedDict):
 
     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.
+    access_path : string
+        The full access path of the attribute to be updated.
+    value : SerializedObject
+        The serialized new value to be assigned to the attribute.
     """
 
-    name: str
-    parent_path: str
-    value: Any
+    access_path: str
+    value: SerializedObject
+
+
+class TriggerMethodDict(TypedDict):
+    access_path: str
+    args: NotRequired[SerializedObject]
+    kwargs: NotRequired[SerializedObject]
 
 
 class RunMethodDict(TypedDict):
@@ -85,9 +90,9 @@ def setup_sio_server(
     state_manager = observer.state_manager
 
     if enable_cors:
-        sio = socketio.AsyncServer(async_mode="asgi", cors_allowed_origins="*")
+        sio = socketio.AsyncServer(async_mode="aiohttp", cors_allowed_origins="*")
     else:
-        sio = socketio.AsyncServer(async_mode="asgi")
+        sio = socketio.AsyncServer(async_mode="aiohttp")
 
     setup_sio_events(sio, state_manager)
     setup_logging_handler(sio)
@@ -119,26 +124,55 @@ def setup_sio_server(
     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"]
+def setup_sio_events(sio: socketio.AsyncServer, state_manager: StateManager) -> None:  # noqa: C901
+    @sio.event  # type: ignore
+    async def connect(sid: str, environ: Any) -> None:
+        logging.debug("Client [%s] connected", click.style(str(sid), fg="cyan"))
+
+    @sio.event  # type: ignore
+    async def disconnect(sid: str) -> None:
+        logging.debug("Client [%s] disconnected", click.style(str(sid), fg="cyan"))
+
+    @sio.event  # type: ignore
+    async def service_serialization(sid: str) -> SerializedObject:
+        logging.debug(
+            "Client [%s] requested service serialization",
+            click.style(str(sid), fg="cyan"),
         )
+        return state_manager.cache_manager.cache
 
     @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"])
+    async def update_value(sid: str, data: UpdateDict) -> SerializedObject | None:
+        try:
+            pydase.server.web_server.api.v1.endpoints.update_value(
+                state_manager=state_manager, data=data
+            )
+        except Exception as e:
+            logger.exception(e)
+            return dump(e)
+        return None
+
+    @sio.event
+    async def get_value(sid: str, access_path: str) -> SerializedObject:
+        try:
+            return pydase.server.web_server.api.v1.endpoints.get_value(
+                state_manager=state_manager, access_path=access_path
+            )
+        except Exception as e:
+            logger.exception(e)
+            return dump(e)
+
+    @sio.event
+    async def trigger_method(sid: str, data: TriggerMethodDict) -> Any:
+        try:
+            return pydase.server.web_server.api.v1.endpoints.trigger_method(
+                state_manager=state_manager, data=data
+            )
+        except Exception as e:
+            logger.error(e)
+            return dump(e)
 
 
 def setup_logging_handler(sio: socketio.AsyncServer) -> None:
-    logger = logging.getLogger()
-    logger.addHandler(SocketIOHandler(sio))
+    logging.getLogger().addHandler(SocketIOHandler(sio))
+    logging.getLogger("pydase").addHandler(SocketIOHandler(sio))

src/pydase/server/web_server/web_server.py

@@ -4,22 +4,23 @@ 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
+import aiohttp.web
+import aiohttp_middlewares.cors
 
 from pydase.config import ServiceConfig, WebServerConfig
 from pydase.data_service.data_service_observer import DataServiceObserver
+from pydase.server.web_server.api import create_api_application
 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__
+from pydase.utils.helpers import (
+    get_path_from_path_parts,
+    parse_full_access_path,
+)
+from pydase.utils.serialization.serializer import generate_serialized_data_paths
 
 logger = logging.getLogger(__name__)
+API_VERSION = "v1"
 
 
 class WebServer:
@@ -87,24 +88,68 @@ class WebServer:
 
     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)
+        self._sio = setup_sio_server(self.observer, self.enable_cors, self._loop)
+
+        async def index(request: aiohttp.web.Request) -> aiohttp.web.FileResponse:
+            return aiohttp.web.FileResponse(self.frontend_src / "index.html")
+
+        app = aiohttp.web.Application()
+
+        # Add CORS middleware if enabled
+        if self.enable_cors:
+            app.middlewares.append(
+                aiohttp_middlewares.cors.cors_middleware(allow_all=True)
+            )
+
+        # Define routes
+        self._sio.attach(app, socketio_path="/ws/socket.io")
+        app.router.add_static("/assets", self.frontend_src / "assets")
+        app.router.add_get("/service-properties", self._service_properties_route)
+        app.router.add_get("/web-settings", self._web_settings_route)
+        app.router.add_get("/custom.css", self._styles_route)
+        app.add_subapp("/api/", create_api_application(self.state_manager))
+
+        app.router.add_get(r"/", index)
+        app.router.add_get(r"/{tail:.*}", index)
+
+        await aiohttp.web._run_app(
+            app,
+            host=self.host,
+            port=self.port,
+            handle_signals=False,
+            print=logger.info,
+            shutdown_timeout=0.1,
         )
-        # 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()
+
+    async def _service_properties_route(
+        self,
+        request: aiohttp.web.Request,
+    ) -> aiohttp.web.Response:
+        return aiohttp.web.json_response(self.state_manager.cache_manager.cache)
+
+    async def _web_settings_route(
+        self,
+        request: aiohttp.web.Request,
+    ) -> aiohttp.web.Response:
+        return aiohttp.web.json_response(self.web_settings)
+
+    async def _styles_route(
+        self,
+        request: aiohttp.web.Request,
+    ) -> aiohttp.web.FileResponse | aiohttp.web.Response:
+        if self.css is not None:
+            return aiohttp.web.FileResponse(self.css)
+
+        return aiohttp.web.Response(content_type="text/css")
 
     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 = self._service_config_dir / "web_settings.json"
+
+            # File does not exist, create it with default content
             file_path.parent.mkdir(
                 parents=True, exist_ok=True
             )  # Ensure directory exists
@@ -131,60 +176,19 @@ class WebServer:
             if path in current_web_settings:
                 continue
 
+            # Creating the display name by reversely looping through the path parts
+            # until an item does not start with a square bracket, and putting the parts
+            # back together again. This allows for display names like
+            #       >>> 'dict_attr["some.dotted.key"]'
+            display_name_parts: list[str] = []
+            for item in parse_full_access_path(path)[::-1]:
+                display_name_parts.insert(0, item)
+                if not item.startswith("["):
+                    break
+
             current_web_settings[path] = {
-                "displayName": path.split(".")[-1],
+                "displayName": get_path_from_path_parts(display_name_parts),
                 "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/units.py

@@ -3,7 +3,7 @@ from typing import TypedDict
 import pint
 
 units: pint.UnitRegistry = pint.UnitRegistry(autoconvert_offset_to_baseunit=True)
-units.default_format = "~P"  # pretty and short format
+units.formatter.default_format = "~P"  # pretty and short format
 
 Quantity = pint.Quantity
 Unit = units.Unit

src/pydase/utils/decorators.py

@@ -1,3 +1,4 @@
+import inspect
 from collections.abc import Callable
 from typing import Any
 
@@ -25,3 +26,17 @@ def frontend(func: Callable[..., Any]) -> Callable[..., Any]:
     # Mark the function for frontend display.
     func._display_in_frontend = True  # type: ignore
     return func
+
+
+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/helpers.py

@@ -1,5 +1,6 @@
 import inspect
 import logging
+import re
 from collections.abc import Callable
 from itertools import chain
 from typing import Any
@@ -7,6 +8,96 @@ from typing import Any
 logger = logging.getLogger(__name__)
 
 
+def parse_serialized_key(serialized_key: str) -> str | int | float:
+    """
+    Parse a serialized key and convert it to an appropriate type (int, float, or str).
+
+    Args:
+        serialized_key: str
+            The serialized key, which might be enclosed in brackets and quotes.
+
+    Returns:
+        int | float | str:
+            The processed key as an integer, float, or unquoted string.
+
+    Examples:
+        ```python
+        print(parse_serialized_key("attr_name"))  # Outputs: attr_name  (str)
+        print(parse_serialized_key("[123]"))  # Outputs: 123  (int)
+        print(parse_serialized_key("[12.3]"))  # Outputs: 12.3  (float)
+        print(parse_serialized_key("['hello']"))  # Outputs: hello  (str)
+        print(parse_serialized_key('["12.34"]'))  # Outputs: 12.34  (str)
+        print(parse_serialized_key('["complex"]'))  # Outputs: complex  (str)
+        ```
+    """
+
+    # Strip outer brackets if present
+    if serialized_key.startswith("[") and serialized_key.endswith("]"):
+        serialized_key = serialized_key[1:-1]
+
+    # Strip quotes if the resulting string is quoted
+    if serialized_key.startswith(("'", '"')) and serialized_key.endswith(("'", '"')):
+        return serialized_key[1:-1]
+
+    # Try converting to float or int if the string is not quoted
+    try:
+        return float(serialized_key) if "." in serialized_key else int(serialized_key)
+    except ValueError:
+        # Return the original string if it's not a valid number
+        return serialized_key
+
+
+def parse_full_access_path(path: str) -> list[str]:
+    """
+    Splits a full access path into its atomic parts, separating attribute names, numeric
+    indices (including floating points), and string keys within indices.
+
+    Args:
+        path: str
+            The full access path string to be split into components.
+
+    Returns:
+        list[str]
+            A list of components that make up the path, including attribute names,
+            numeric indices, and string keys as separate elements.
+
+    Example:
+        >>> parse_full_access_path('dict_attr["some_key"].attr_name["other_key"]')
+        ["dict_attr", '["some_key"]', "attr_name", '["other_key"]']
+    """
+    # Matches:
+    # \w+ - Words
+    # \[\d+\.\d+\] - Floating point numbers inside brackets
+    # \[\d+\] - Integers inside brackets
+    # \["[^"]*"\] - Double-quoted strings inside brackets
+    # \['[^']*'\] - Single-quoted strings inside brackets
+    pattern = r'\w+|\[\d+\.\d+\]|\[\d+\]|\["[^"]*"\]|\[\'[^\']*\']'
+    return re.findall(pattern, path)
+
+
+def get_path_from_path_parts(path_parts: list[str]) -> str:
+    """Creates the full access path from its atomic parts.
+
+    The reverse function is given by `parse_full_access_path`.
+
+    Args:
+        path_parts: list[str]
+            A list of components that make up the path, including attribute names,
+            numeric indices and string keys enclosed in square brackets as separate
+            elements.
+    Returns:
+        str
+            The full access path corresponding to the path_parts.
+    """
+
+    path = ""
+    for path_part in path_parts:
+        if not path_part.startswith("[") and path != "":
+            path += "."
+        path += path_part
+    return path
+
+
 def get_attribute_doc(attr: Any) -> str | None:
     """This function takes an input attribute attr and returns its documentation
     string if it's different from the documentation of its type, otherwise,
@@ -30,13 +121,31 @@ def get_class_and_instance_attributes(obj: object) -> dict[str, Any]:
     return dict(chain(type(obj).__dict__.items(), obj.__dict__.items()))
 
 
-def get_object_attr_from_path_list(target_obj: Any, path: list[str]) -> Any:
+def get_object_by_path_parts(target_obj: Any, path_parts: list[str]) -> Any:
+    """Gets nested attribute of `target_object` specified by `path_parts`.
+
+    Raises:
+        AttributeError: Attribute does not exist.
+        KeyError: Key in dict does not exist.
+        IndexError: Index out of list range.
+        TypeError: List index in the path is not a valid integer.
+    """
+    for part in path_parts:
+        if part.startswith("["):
+            deserialized_part = parse_serialized_key(part)
+            target_obj = target_obj[deserialized_part]
+        else:
+            target_obj = getattr(target_obj, part)
+    return target_obj
+
+
+def get_object_attr_from_path(target_obj: Any, path: str) -> Any:
     """
     Traverse the object tree according to the given path.
 
     Args:
         target_obj: The root object to start the traversal from.
-        path: A list of attribute names representing the path to traverse.
+        path: Access path of the object.
 
     Returns:
         The attribute at the end of the path. If the path includes a list index,
@@ -44,138 +153,13 @@ def get_object_attr_from_path_list(target_obj: Any, path: list[str]) -> Any:
         the path does not exist, the function logs a debug message and returns None.
 
     Raises:
-        ValueError: If a list index in the path is not a valid integer.
+        AttributeError: Attribute does not exist.
+        KeyError: Key in dict does not exist.
+        IndexError: Index out of list range.
+        TypeError: List index in the path is not a valid integer.
     """
-    for part in path:
-        try:
-            # Try to split the part into attribute and index
-            attr, index_str = part.split("[", maxsplit=1)
-            index_str = index_str.replace("]", "")
-            index = int(index_str)
-            target_obj = getattr(target_obj, attr)[index]
-        except ValueError:
-            # No index, so just get the attribute
-            target_obj = getattr(target_obj, part)
-        except AttributeError:
-            # The attribute doesn't exist
-            logger.debug("Attribute % does not exist in the object.", part)
-            return None
-    return target_obj
-
-
-def convert_arguments_to_hinted_types(
-    args: dict[str, Any], type_hints: dict[str, Any]
-) -> dict[str, Any] | str:
-    """
-    Convert the given arguments to their types hinted in the type_hints dictionary.
-
-    This function attempts to convert each argument in the args dictionary to the type
-    specified for the argument in the type_hints dictionary. If the conversion is
-    successful, the function replaces the original argument in the args dictionary with
-    the converted argument.
-
-    If a ValueError is raised during the conversion of an argument, the function logs
-    an error message and returns the error message as a string.
-
-    Args:
-        args: A dictionary of arguments to be converted. The keys are argument names
-              and the values are the arguments themselves.
-        type_hints: A dictionary of type hints for the arguments. The keys are
-                    argument names and the values are the hinted types.
-
-    Returns:
-        A dictionary of the converted arguments if all conversions are successful,
-        or an error message string if a ValueError is raised during a conversion.
-    """
-
-    # Convert arguments to their hinted types
-    for arg_name, arg_value in args.items():
-        if arg_name in type_hints:
-            arg_type = type_hints[arg_name]
-            if isinstance(arg_type, type):
-                # Attempt to convert the argument to its hinted type
-                try:
-                    args[arg_name] = arg_type(arg_value)
-                except ValueError:
-                    msg = (
-                        f"Failed to convert argument '{arg_name}' to type "
-                        f"{arg_type.__name__}"
-                    )
-                    logger.error(msg)
-                    return msg
-    return args
-
-
-def update_value_if_changed(
-    target: Any, attr_name_or_index: str | int, new_value: Any
-) -> None:
-    """
-    Updates the value of an attribute or a list element on a target object if the new
-    value differs from the current one.
-
-    This function supports updating both attributes of an object and elements of a list.
-
-    - For objects, the function first checks the current value of the attribute. If the
-      current value differs from the new value, the function updates the attribute.
-
-    - For lists, the function checks the current value at the specified index. If the
-      current value differs from the new value, the function updates the list element
-      at the given index.
-
-    Args:
-        target (Any):
-            The target object that has the attribute or the list.
-        attr_name_or_index (str | int):
-            The name of the attribute or the index of the list element.
-        new_value (Any):
-            The new value for the attribute or the list element.
-    """
-
-    if isinstance(target, list) and isinstance(attr_name_or_index, int):
-        if target[attr_name_or_index] != new_value:
-            target[attr_name_or_index] = new_value
-    elif isinstance(attr_name_or_index, str):
-        # If the type matches and the current value is different from the new value,
-        # update the attribute.
-        if getattr(target, attr_name_or_index) != new_value:
-            setattr(target, attr_name_or_index, new_value)
-    else:
-        logger.error("Incompatible arguments: %s, %s.", target, attr_name_or_index)
-
-
-def parse_list_attr_and_index(attr_string: str) -> tuple[str, int | None]:
-    """
-    Parses an attribute string and extracts a potential list attribute name and its
-    index.
-    Logs an error if the index is not a valid digit.
-
-    Args:
-        attr_string (str):
-            The attribute string to parse. Can be a regular attribute name (e.g.,
-            'attr_name') or a list attribute with an index (e.g., 'list_attr[2]').
-
-    Returns:
-        tuple[str, Optional[int]]:
-            A tuple containing the attribute name as a string and the index as an
-            integer if present, otherwise None.
-
-    Examples:
-        >>> parse_attribute_and_index('list_attr[2]')
-        ('list_attr', 2)
-        >>> parse_attribute_and_index('attr_name')
-        ('attr_name', None)
-    """
-
-    index = None
-    attr_name = attr_string
-    if "[" in attr_string and attr_string.endswith("]"):
-        attr_name, index_part = attr_string.split("[", 1)
-        index_part = index_part.rstrip("]")
-        if index_part.isdigit():
-            index = int(index_part)
-        else:
-            logger.error("Invalid index format in key: %s", attr_name)
-    return attr_name, index
+    path_parts = parse_full_access_path(path)
+    return get_object_by_path_parts(target_obj, path_parts)
 
 
 def get_component_classes() -> list[type]:
@@ -195,8 +179,13 @@ def get_data_service_class_reference() -> Any:
     return getattr(pydase.data_service.data_service, "DataService")
 
 
-def is_property_attribute(target_obj: Any, attr_name: str) -> bool:
-    return isinstance(getattr(type(target_obj), attr_name, None), property)
+def is_property_attribute(target_obj: Any, access_path: str) -> bool:
+    path_parts = parse_full_access_path(access_path)
+    target_obj = get_object_by_path_parts(target_obj, path_parts[:-1])
+
+    # don't have to check if target_obj is dict or list as their content cannot be
+    # properties -> always return False then
+    return isinstance(getattr(type(target_obj), path_parts[-1], None), property)
 
 
 def function_has_arguments(func: Callable[..., Any]) -> bool:
@@ -206,20 +195,4 @@ def function_has_arguments(func: Callable[..., Any]) -> bool:
     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
+    return len(parameters) > 0

src/pydase/utils/logging.py

@@ -1,16 +1,58 @@
 import asyncio
 import logging
+import logging.config
 import sys
+from collections.abc import Callable
 from copy import copy
+from typing import ClassVar, Literal
 
+import click
 import socketio  # type: ignore[import-untyped]
-import uvicorn.logging
-from uvicorn.config import LOGGING_CONFIG
 
 import pydase.config
 
+logger = logging.getLogger(__name__)
 
-class DefaultFormatter(uvicorn.logging.ColourizedFormatter):
+if pydase.config.OperationMode().environment == "development":
+    LOG_LEVEL = logging.DEBUG
+else:
+    LOG_LEVEL = logging.INFO
+
+LOGGING_CONFIG = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "default": {
+            "()": "pydase.utils.logging.DefaultFormatter",
+            "fmt": "%(asctime)s.%(msecs)03d | %(levelprefix)s | "
+            "%(name)s:%(funcName)s:%(lineno)d - %(message)s",
+            "datefmt": "%Y-%m-%d %H:%M:%S",
+        },
+    },
+    "handlers": {
+        "default": {
+            "formatter": "default",
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stderr",
+        },
+    },
+    "loggers": {
+        "pydase": {"handlers": ["default"], "level": LOG_LEVEL, "propagate": False},
+        "aiohttp_middlewares": {
+            "handlers": ["default"],
+            "level": logging.WARNING,
+            "propagate": False,
+        },
+        "aiohttp": {
+            "handlers": ["default"],
+            "level": logging.INFO,
+            "propagate": False,
+        },
+    },
+}
+
+
+class DefaultFormatter(logging.Formatter):
     """
     A custom log formatter class that:
 
@@ -19,6 +61,36 @@ class DefaultFormatter(uvicorn.logging.ColourizedFormatter):
       for formatting the output, instead of the plain text message.
     """
 
+    level_name_colors: ClassVar[dict[int, Callable[..., str]]] = {
+        logging.DEBUG: lambda level_name: click.style(str(level_name), fg="cyan"),
+        logging.INFO: lambda level_name: click.style(str(level_name), fg="green"),
+        logging.WARNING: lambda level_name: click.style(str(level_name), fg="yellow"),
+        logging.ERROR: lambda level_name: click.style(str(level_name), fg="red"),
+        logging.CRITICAL: lambda level_name: click.style(
+            str(level_name), fg="bright_red"
+        ),
+    }
+
+    def __init__(
+        self,
+        fmt: str | None = None,
+        datefmt: str | None = None,
+        style: Literal["%", "{", "$"] = "%",
+        use_colors: bool | None = None,
+    ):
+        if use_colors in (True, False):
+            self.use_colors = use_colors
+        else:
+            self.use_colors = sys.stdout.isatty()
+        super().__init__(fmt=fmt, datefmt=datefmt, style=style)
+
+    def color_level_name(self, level_name: str, level_no: int) -> str:
+        def default(level_name: str) -> str:
+            return str(level_name)
+
+        func = self.level_name_colors.get(level_no, default)
+        return func(level_name)
+
     def formatMessage(self, record: logging.LogRecord) -> str:  # noqa: N802
         recordcopy = copy(record)
         levelname = recordcopy.levelname
@@ -47,7 +119,8 @@ class SocketIOHandler(logging.Handler):
         self._sio = sio
 
     def format(self, record: logging.LogRecord) -> str:
-        return f"{record.name}:{record.funcName}:{record.lineno} - {record.message}"
+        msg = record.getMessage()
+        return f"{record.name}:{record.funcName}:{record.lineno} - {msg}"
 
     def emit(self, record: logging.LogRecord) -> None:
         log_entry = self.format(record)
@@ -64,86 +137,16 @@ class SocketIOHandler(logging.Handler):
         )
 
 
-def setup_logging(level: str | int | None = None) -> None:
+def setup_logging() -> None:
     """
     Configures the logging settings for the application.
 
     This function sets up logging with specific formatting and colorization of log
-    messages. The log level is determined based on the application's operation mode,
-    with an option to override the level. By default, in a development environment, the
-    log level is set to DEBUG, whereas in other environments, it is set to INFO.
-
-    Args:
-        level (Optional[str | int]):
-            A specific log level to set for the application. If None, the log level is
-            determined based on the application's operation mode. Accepts standard log
-            level names ('DEBUG', 'INFO', etc.) and corresponding numerical values.
-
-    Example:
-
-    ```python
-    >>> import logging
-    >>> setup_logging(logging.DEBUG)
-    >>> setup_logging("INFO")
-    ```
+    messages. The log level is determined based on the application's operation mode. By
+    default, in a development environment, the log level is set to DEBUG, whereas in
+    other environments, it is set to INFO.
     """
 
-    logger = logging.getLogger()
+    logger.debug("Configuring pydase logging.")
 
-    if pydase.config.OperationMode().environment == "development":
-        log_level = logging.DEBUG
-    else:
-        log_level = logging.INFO
-
-    # If a level is specified, check whether it's a string or an integer.
-    if level is not None:
-        if isinstance(level, str):
-            # Convert known log level strings directly to their corresponding logging
-            # module constants.
-            level_name = level.upper()  # Ensure level names are uppercase
-            if hasattr(logging, level_name):
-                log_level = getattr(logging, level_name)
-            else:
-                raise ValueError(
-                    f"Invalid log level: {level}. Must be one of 'DEBUG', 'INFO', "
-                    "'WARNING', 'ERROR', etc."
-                )
-        elif isinstance(level, int):
-            log_level = level  # Directly use integer levels
-        else:
-            raise ValueError("Log level must be a string or an integer.")
-
-    # Set the logger's level.
-    logger.setLevel(log_level)
-
-    # create console handler and set level to debug
-    ch = logging.StreamHandler()
-
-    # add formatter to ch
-    ch.setFormatter(
-        DefaultFormatter(
-            fmt=(
-                "%(asctime)s.%(msecs)03d | %(levelprefix)s | "
-                "%(name)s:%(funcName)s:%(lineno)d - %(message)s"
-            ),
-            datefmt="%Y-%m-%d %H:%M:%S",
-        )
-    )
-
-    # add ch to logger
-    logger.addHandler(ch)
-
-    logger.debug("Configuring service logging.")
-    logging.getLogger("asyncio").setLevel(logging.INFO)
-    logging.getLogger("urllib3").setLevel(logging.INFO)
-
-    # configuring uvicorn logger
-    LOGGING_CONFIG["formatters"]["default"][
-        "fmt"
-    ] = "%(asctime)s.%(msecs)03d | %(levelprefix)s %(message)s"
-    LOGGING_CONFIG["formatters"]["default"]["datefmt"] = "%Y-%m-%d %H:%M:%S"
-    LOGGING_CONFIG["formatters"]["access"]["fmt"] = (
-        "%(asctime)s.%(msecs)03d | %(levelprefix)s %(client_addr)s "
-        '- "%(request_line)s" %(status_code)s'
-    )
-    LOGGING_CONFIG["formatters"]["access"]["datefmt"] = "%Y-%m-%d %H:%M:%S"
+    logging.config.dictConfig(LOGGING_CONFIG)

src/pydase/utils/serialization/deserializer.py

@@ -0,0 +1,162 @@
+import enum
+import logging
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, NoReturn, cast
+
+import pydase
+import pydase.components
+import pydase.units as u
+from pydase.utils.helpers import get_component_classes
+from pydase.utils.serialization.types import (
+    SerializedDatetime,
+    SerializedException,
+    SerializedObject,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+logger = logging.getLogger(__name__)
+
+
+class Deserializer:
+    @classmethod
+    def deserialize(cls, serialized_object: SerializedObject) -> Any:
+        type_handler: dict[str | None, None | Callable[..., Any]] = {
+            None: None,
+            "int": cls.deserialize_primitive,
+            "float": cls.deserialize_primitive,
+            "bool": cls.deserialize_primitive,
+            "str": cls.deserialize_primitive,
+            "NoneType": cls.deserialize_primitive,
+            "Quantity": cls.deserialize_quantity,
+            "Enum": cls.deserialize_enum,
+            "ColouredEnum": lambda serialized_object: cls.deserialize_enum(
+                serialized_object, enum_class=pydase.components.ColouredEnum
+            ),
+            "list": cls.deserialize_list,
+            "dict": cls.deserialize_dict,
+            "method": cls.deserialize_method,
+            "Exception": cls.deserialize_exception,
+            "datetime": cls.deserialize_datetime,
+        }
+
+        # First go through handled types (as ColouredEnum is also within the components)
+        handler = type_handler.get(serialized_object["type"])
+        if handler:
+            return handler(serialized_object)
+
+        # Custom types like Components or DataService classes
+        component_class = cls.get_component_class(serialized_object["type"])
+        if component_class:
+            return cls.deserialize_component_type(serialized_object, component_class)
+
+        return None
+
+    @classmethod
+    def deserialize_primitive(cls, serialized_object: SerializedObject) -> Any:
+        if serialized_object["type"] == "float":
+            return float(serialized_object["value"])
+        return serialized_object["value"]
+
+    @classmethod
+    def deserialize_quantity(cls, serialized_object: SerializedObject) -> Any:
+        return u.convert_to_quantity(serialized_object["value"])  # type: ignore
+
+    @classmethod
+    def deserialize_datetime(cls, serialized_object: SerializedDatetime) -> datetime:
+        return datetime.fromisoformat(serialized_object["value"])
+
+    @classmethod
+    def deserialize_enum(
+        cls,
+        serialized_object: SerializedObject,
+        enum_class: type[enum.Enum] = enum.Enum,
+    ) -> Any:
+        return enum_class(serialized_object["name"], serialized_object["enum"])[  # type: ignore
+            serialized_object["value"]
+        ]
+
+    @classmethod
+    def deserialize_list(cls, serialized_object: SerializedObject) -> Any:
+        return [
+            cls.deserialize(item)
+            for item in cast(list[SerializedObject], serialized_object["value"])
+        ]
+
+    @classmethod
+    def deserialize_dict(cls, serialized_object: SerializedObject) -> Any:
+        return {
+            key: cls.deserialize(value)
+            for key, value in cast(
+                dict[str, SerializedObject], serialized_object["value"]
+            ).items()
+        }
+
+    @classmethod
+    def deserialize_method(cls, serialized_object: SerializedObject) -> Any:
+        return
+
+    @classmethod
+    def deserialize_exception(cls, serialized_object: SerializedException) -> NoReturn:
+        import builtins
+
+        try:
+            exception = getattr(builtins, serialized_object["name"])
+        except AttributeError:
+            exception = type(serialized_object["name"], (Exception,), {})  # type: ignore
+        raise exception(serialized_object["value"])
+
+    @staticmethod
+    def get_component_class(type_name: str | None) -> type | None:
+        for component_class in get_component_classes():
+            if type_name == component_class.__name__:
+                return component_class
+        if type_name == "DataService":
+            import pydase
+
+            return pydase.DataService
+        return None
+
+    @classmethod  # TODO: this shouldn't be a class method
+    def create_attr_property(cls, serialized_attr: SerializedObject) -> property:
+        attr_name = serialized_attr["full_access_path"].split(".")[-1]
+
+        def get(self) -> Any:  # type: ignore
+            return getattr(self, f"_{attr_name}")
+
+        get.__doc__ = serialized_attr["doc"]
+
+        def set(self, value: Any) -> None:  # type: ignore
+            return setattr(self, f"_{attr_name}", value)
+
+        if serialized_attr["readonly"]:
+            return property(get)
+        return property(get, set)
+
+    @classmethod
+    def deserialize_component_type(
+        cls, serialized_object: SerializedObject, base_class: type
+    ) -> Any:
+        def create_proxy_class(serialized_object: SerializedObject) -> type:
+            class_bases = (base_class,)
+            class_attrs = {}
+
+            # Process and add properties based on the serialized object
+            for key, value in cast(
+                dict[str, SerializedObject], serialized_object["value"]
+            ).items():
+                if value["type"] != "method":
+                    class_attrs[key] = cls.create_attr_property(value)
+                    # Initialize a placeholder for the attribute to avoid AttributeError
+                    class_attrs[f"_{key}"] = cls.deserialize(value)
+
+            # Create the dynamic class with the given name and attributes
+            return type(serialized_object["name"], class_bases, class_attrs)  # type: ignore
+
+        return create_proxy_class(serialized_object)()
+
+
+def loads(serialized_object: SerializedObject) -> Any:
+    return Deserializer.deserialize(serialized_object)